- make stats struct fields' names uniform

- add `|` separator to summary report for better visibility

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## v1.21.2 - 2023-5-8
+
+- make `stats` struct fields' names uniform
+- add `|` separator to summary report for better visibility
+
 ## v1.21.1 - 2023-5-8
 
 - fix retry resolve logic

statsprinter.go

@@ -108,19 +108,19 @@ func (p *statsPlanePrinter) printRttResults(rtt *rttResults) {
 /* Print statistics when program exits */
 func (p *statsPlanePrinter) printStatistics() {
 
-	totalPackets := p.totalSuccessfulPkts + p.totalUnsuccessfulPkts
+	totalPackets := p.totalSuccessfulProbes + p.totalUnsuccessfulProbes
 	totalUptime := calcTime(uint(p.totalUptime.Seconds()))
 	totalDowntime := calcTime(uint(p.totalDowntime.Seconds()))
-	packetLoss := (float32(p.totalUnsuccessfulPkts) / float32(totalPackets)) * 100
+	packetLoss := (float32(p.totalUnsuccessfulProbes) / float32(totalPackets)) * 100
 
 	/* general stats */
 	if !p.isIP {
 		colorYellow("\n--- %s (%s) TCPing statistics ---\n", p.hostname, p.ip)
 	} else {
 		colorYellow("\n--- %s TCPing statistics ---\n", p.hostname)
 	}
-	colorYellow("%d probes transmitted on port %d, ", totalPackets, p.port)
-	colorYellow("%d received, ", p.totalSuccessfulPkts)
+	colorYellow("%d probes transmitted on port %d | ", totalPackets, p.port)
+	colorYellow("%d received, ", p.totalSuccessfulProbes)
 
 	/* packet loss stats */
 	if packetLoss == 0 {
@@ -135,11 +135,11 @@ func (p *statsPlanePrinter) printStatistics() {
 
 	/* successful packet stats */
 	colorYellow("successful probes:   ")
-	colorGreen("%d\n", p.totalSuccessfulPkts)
+	colorGreen("%d\n", p.totalSuccessfulProbes)
 
 	/* unsuccessful packet stats */
 	colorYellow("unsuccessful probes: ")
-	colorRed("%d\n", p.totalUnsuccessfulPkts)
+	colorRed("%d\n", p.totalUnsuccessfulProbes)
 
 	p.printLastSucUnsucProbes()
 
@@ -182,18 +182,18 @@ func (p *statsPlanePrinter) printReply(replyMsg replyMsg) {
 	if p.isIP {
 		if replyMsg.msg == noReply {
 			colorRed("%s from %s on port %d TCP_conn=%d\n",
-				replyMsg.msg, p.ip, p.port, p.totalUnsuccessfulPkts)
+				replyMsg.msg, p.ip, p.port, p.totalUnsuccessfulProbes)
 		} else {
 			colorLightGreen("%s from %s on port %d TCP_conn=%d time=%.3f ms\n",
-				replyMsg.msg, p.ip, p.port, p.totalSuccessfulPkts, replyMsg.rtt)
+				replyMsg.msg, p.ip, p.port, p.totalSuccessfulProbes, replyMsg.rtt)
 		}
 	} else {
 		if replyMsg.msg == noReply {
 			colorRed("%s from %s (%s) on port %d TCP_conn=%d\n",
-				replyMsg.msg, p.hostname, p.ip, p.port, p.totalUnsuccessfulPkts)
+				replyMsg.msg, p.hostname, p.ip, p.port, p.totalUnsuccessfulProbes)
 		} else {
 			colorLightGreen("%s from %s (%s) on port %d TCP_conn=%d time=%.3f ms\n",
-				replyMsg.msg, p.hostname, p.ip, p.port, p.totalSuccessfulPkts, replyMsg.rtt)
+				replyMsg.msg, p.hostname, p.ip, p.port, p.totalSuccessfulProbes, replyMsg.rtt)
 		}
 	}
 }
@@ -322,22 +322,22 @@ func (j *statsJsonPrinter) printStatistics() {
 		return
 	}
 
-	totalPackets := j.totalSuccessfulPkts + j.totalUnsuccessfulPkts
+	totalPackets := j.totalSuccessfulProbes + j.totalUnsuccessfulProbes
 	totalUptime := calcTime(uint(j.totalUptime.Seconds()))
 	totalDowntime := calcTime(uint(j.totalDowntime.Seconds()))
-	packetLoss := (float32(j.totalUnsuccessfulPkts) / float32(totalPackets)) * 100
+	packetLoss := (float32(j.totalUnsuccessfulProbes) / float32(totalPackets)) * 100
 
 	/* general stats */
-	jsonPrintf("%s TCPing statistics: %d probes transmitted, %d received", j.hostname, totalPackets, j.totalSuccessfulPkts)
+	jsonPrintf("%s TCPing statistics: %d probes transmitted, %d received", j.hostname, totalPackets, j.totalSuccessfulProbes)
 
 	/* packet loss stats */
 	jsonPrintf("%.2f%% packet loss", packetLoss)
 
 	/* successful packet stats */
-	jsonPrintf("successful probes: %d", j.totalSuccessfulPkts)
+	jsonPrintf("successful probes: %d", j.totalSuccessfulProbes)
 
 	/* unsuccessful packet stats */
-	jsonPrintf("unsuccessful probes: %d", j.totalUnsuccessfulPkts)
+	jsonPrintf("unsuccessful probes: %d", j.totalUnsuccessfulProbes)
 
 	j.printLastSucUnsucProbes()
 
@@ -375,18 +375,18 @@ func (j *statsJsonPrinter) printReply(replyMsg replyMsg) {
 	if j.isIP {
 		if replyMsg.msg == noReply {
 			jsonPrintf("%s from %s on port %d TCP_conn=%d",
-				replyMsg.msg, j.ip, j.port, j.totalUnsuccessfulPkts)
+				replyMsg.msg, j.ip, j.port, j.totalUnsuccessfulProbes)
 		} else {
 			jsonPrintf("%s from %s on port %d TCP_conn=%d time=%.3f ms",
-				replyMsg.msg, j.ip, j.port, j.totalSuccessfulPkts, replyMsg.rtt)
+				replyMsg.msg, j.ip, j.port, j.totalSuccessfulProbes, replyMsg.rtt)
 		}
 	} else {
 		if replyMsg.msg == noReply {
 			jsonPrintf("%s from %s (%s) on port %d TCP_conn=%d",
-				replyMsg.msg, j.hostname, j.ip, j.port, j.totalUnsuccessfulPkts)
+				replyMsg.msg, j.hostname, j.ip, j.port, j.totalUnsuccessfulProbes)
 		} else {
 			jsonPrintf("%s from %s (%s) on port %d TCP_conn=%d time=%.3f ms",
-				replyMsg.msg, j.hostname, j.ip, j.port, j.totalSuccessfulPkts, replyMsg.rtt)
+				replyMsg.msg, j.hostname, j.ip, j.port, j.totalSuccessfulProbes, replyMsg.rtt)
 		}
 	}
 }

tcping.go

@@ -27,17 +27,17 @@ type stats struct {
 	ip                    ipAddress
 	startTime             time.Time
 	statsPrinter
-	retryHostnameResolveAfter *uint // Retry resolving target's hostname after a certain number of failed requests
+	retryHostnameResolveAfter uint // Retry resolving target's hostname after a certain number of failed requests
 	hostname                  string
 	rtt                       []float32
-	ongoingUnsuccessfulPkts   uint
+	ongoingUnsuccessfulProbes uint
 	longestDowntime           longestTime
-	totalSuccessfulPkts       uint
+	totalSuccessfulProbes     uint
 	totalUptime               time.Duration
 	retriedHostnameResolves   uint
 	longestUptime             longestTime
 	totalDowntime             time.Duration
-	totalUnsuccessfulPkts     uint
+	totalUnsuccessfulProbes   uint
 	port                      uint16
 	wasDown                   bool // Used to determine the duration of a downtime
 	isIP                      bool // If IP is provided instead of hostname, suppresses printing the IP information twice
@@ -69,7 +69,7 @@ type cliArgs = []string
 type calculatedTimeString = string
 
 const (
-	version             = "1.21.1"
+	version             = "1.21.2"
 	owner               = "pouriyajamshidi"
 	repo                = "tcping"
 	thousandMilliSecond = 1000 * time.Millisecond
@@ -111,7 +111,7 @@ func usage() {
 
 /* Get and validate user input */
 func processUserInput(tcpStats *stats) {
-	tcpStats.retryHostnameResolveAfter = flag.Uint("r", 0, "retry resolving target's hostname after <n> number of failed requests. e.g. -r 10 for 10 failed probes.")
+	retryHostnameResolveAfter := flag.Uint("r", 0, "retry resolving target's hostname after <n> number of failed requests. e.g. -r 10 for 10 failed probes.")
 	shouldCheckUpdates := flag.Bool("u", false, "check for updates.")
 	outputJson := flag.Bool("j", false, "output in JSON format.")
 	showVersion := flag.Bool("v", false, "show version.")
@@ -127,6 +127,10 @@ func processUserInput(tcpStats *stats) {
 	args := flag.Args()
 	nFlag := flag.NFlag()
 
+	if *retryHostnameResolveAfter > 0 {
+		tcpStats.retryHostnameResolveAfter = *retryHostnameResolveAfter
+	}
+
 	/* -u works on its own. */
 	if *shouldCheckUpdates {
 		if len(args) == 0 && nFlag == 1 {
@@ -181,7 +185,7 @@ func processUserInput(tcpStats *stats) {
 		tcpStats.isIP = true
 	}
 
-	if *tcpStats.retryHostnameResolveAfter > 0 && !tcpStats.isIP {
+	if tcpStats.retryHostnameResolveAfter > 0 && !tcpStats.isIP {
 		tcpStats.shouldRetryResolve = true
 	}
 
@@ -273,7 +277,7 @@ func resolveHostname(tcpStats *stats) ipAddress {
 
 	ipAddrs, err := net.LookupIP(tcpStats.hostname)
 
-	if err != nil && (tcpStats.totalSuccessfulPkts != 0 || tcpStats.totalUnsuccessfulPkts != 0) {
+	if err != nil && (tcpStats.totalSuccessfulProbes != 0 || tcpStats.totalUnsuccessfulProbes != 0) {
 		/* Prevent exit if application has been running for a while */
 		return tcpStats.ip
 	} else if err != nil {
@@ -333,10 +337,10 @@ func resolveHostname(tcpStats *stats) ipAddress {
 
 /* Retry resolve hostname after certain number of failures */
 func retryResolve(tcpStats *stats) {
-	if tcpStats.ongoingUnsuccessfulPkts >= *tcpStats.retryHostnameResolveAfter {
+	if tcpStats.ongoingUnsuccessfulProbes >= tcpStats.retryHostnameResolveAfter {
 		tcpStats.printRetryingToResolve()
 		tcpStats.ip = resolveHostname(tcpStats)
-		tcpStats.ongoingUnsuccessfulPkts = 0
+		tcpStats.ongoingUnsuccessfulProbes = 0
 		tcpStats.retriedHostnameResolves += 1
 	}
 }
@@ -474,9 +478,9 @@ func (tcpStats *stats) handleConnError(now time.Time) {
 	}
 
 	tcpStats.totalDowntime += time.Second
-	tcpStats.totalUnsuccessfulPkts += 1
 	tcpStats.lastUnsuccessfulProbe = now
-	tcpStats.ongoingUnsuccessfulPkts += 1
+	tcpStats.totalUnsuccessfulProbes += 1
+	tcpStats.ongoingUnsuccessfulProbes += 1
 
 	tcpStats.statsPrinter.printReply(replyMsg{msg: "No reply", rtt: 0})
 }
@@ -488,16 +492,16 @@ func (tcpStats *stats) handleConnSuccess(rtt float32, now time.Time) {
 		calcLongestDowntime(tcpStats, now)
 		tcpStats.startOfDowntime = time.Time{}
 		tcpStats.wasDown = false
-		tcpStats.ongoingUnsuccessfulPkts = 0
+		tcpStats.ongoingUnsuccessfulProbes = 0
 	}
 
 	if tcpStats.startOfUptime.Format(timeFormat) == nullTimeFormat {
 		tcpStats.startOfUptime = now
 	}
 
 	tcpStats.totalUptime += time.Second
-	tcpStats.totalSuccessfulPkts += 1
 	tcpStats.lastSuccessfulProbe = now
+	tcpStats.totalSuccessfulProbes += 1
 	tcpStats.rtt = append(tcpStats.rtt, rtt)
 
 	tcpStats.statsPrinter.printReply(replyMsg{msg: "Reply", rtt: rtt})