Multiplexing counters return -1 whenever not used and "prepared commands ration" now returns value between 0 and 100 (#3963)

vonzshik · web-flow · commit c397fddc8c28 · 2021-09-04T23:34:24.000+03:00
diff --git a/src/Npgsql/NpgsqlEventSource.cs b/src/Npgsql/NpgsqlEventSource.cs
@@ -96,7 +96,7 @@ internal void MultiplexingBatchSent(int numCommands, Stopwatch stopwatch)
         }
 
 #if !NETSTANDARD2_0
-        int GetIdleConnections()
+        double GetIdleConnections()
         {
             // Note: there's no attempt here to be coherent in terms of race conditions, especially not with regards
             // to different counters. So idle and busy and be unsynchronized, as they're not polled together.
@@ -111,7 +111,7 @@ int GetIdleConnections()
             }
         }
 
-        int GetBusyConnections()
+        double GetBusyConnections()
         {
             // Note: there's no attempt here to be coherent in terms of race conditions, especially not with regards
             // to different counters. So idle and busy and be unsynchronized, as they're not polled together.
@@ -126,14 +126,34 @@ int GetBusyConnections()
             }
         }
 
-        int GetPoolsCount()
+        double GetPoolsCount()
         {
             lock (_poolsLock)
             {
                 return _pools.Count;
             }
         }
 
+        double GetMultiplexingAverageCommandsPerBatch()
+        {
+            var batchesSent = Interlocked.Read(ref _multiplexingBatchesSent);
+            if (batchesSent == 0)
+                return -1;
+
+            var commandsSent = (double)Interlocked.Read(ref _multiplexingCommandsSent);
+            return commandsSent / batchesSent;
+        }
+
+        double GetMultiplexingAverageWriteTimePerBatch()
+        {
+            var batchesSent = Interlocked.Read(ref _multiplexingBatchesSent);
+            if (batchesSent == 0)
+                return -1;
+
+            var ticksWritten = (double)Interlocked.Read(ref _multiplexingTicksWritten);
+            return ticksWritten / batchesSent / 1000;
+        }
+
         protected override void OnEventCommand(EventCommandEventArgs command)
         {
             if (command.Command == EventCommand.Enable)
@@ -180,33 +200,33 @@ protected override void OnEventCommand(EventCommandEventArgs command)
                 _preparedCommandsRatioCounter = new PollingCounter(
                     "prepared-commands-ratio",
                     this,
-                    () => (double)Interlocked.Read(ref _totalPreparedCommands) / Interlocked.Read(ref _totalCommands))
+                    () => (double)Interlocked.Read(ref _totalPreparedCommands) / Interlocked.Read(ref _totalCommands) * 100)
                 {
                     DisplayName = "Prepared Commands Ratio",
                     DisplayUnits = "%"
                 };
 
-                _poolsCounter = new PollingCounter("connection-pools", this, () => GetPoolsCount())
+                _poolsCounter = new PollingCounter("connection-pools", this, GetPoolsCount)
                 {
                     DisplayName = "Connection Pools"
                 };
 
-                _idleConnectionsCounter = new PollingCounter("idle-connections", this, () => GetIdleConnections())
+                _idleConnectionsCounter = new PollingCounter("idle-connections", this, GetIdleConnections)
                 {
                     DisplayName = "Idle Connections"
                 };
 
-                _busyConnectionsCounter = new PollingCounter("busy-connections", this, () => GetBusyConnections())
+                _busyConnectionsCounter = new PollingCounter("busy-connections", this, GetBusyConnections)
                 {
                     DisplayName = "Busy Connections"
                 };
 
-                _multiplexingAverageCommandsPerBatchCounter = new PollingCounter("multiplexing-average-commands-per-batch", this, () => (double)Interlocked.Read(ref _multiplexingCommandsSent) / Interlocked.Read(ref _multiplexingBatchesSent))
+                _multiplexingAverageCommandsPerBatchCounter = new PollingCounter("multiplexing-average-commands-per-batch", this, GetMultiplexingAverageCommandsPerBatch)
                 {
                     DisplayName = "Average commands per multiplexing batch"
                 };
 
-                _multiplexingAverageWriteTimePerBatchCounter = new PollingCounter("multiplexing-average-write-time-per-batch", this, () => (double)Interlocked.Read(ref _multiplexingTicksWritten) / Interlocked.Read(ref _multiplexingBatchesSent) / 1000)
+                _multiplexingAverageWriteTimePerBatchCounter = new PollingCounter("multiplexing-average-write-time-per-batch", this, GetMultiplexingAverageWriteTimePerBatch)
                 {
                     DisplayName = "Average write time per multiplexing batch (us)",
                     DisplayUnits = "us"

Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,7 @@ internal void MultiplexingBatchSent(int numCommands, Stopwatch stopwatch)`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`#if !NETSTANDARD2_0`
`99`		`- int GetIdleConnections()`
	`99`	`+ double GetIdleConnections()`
`100`	`100`	`{`
`101`	`101`	`// Note: there's no attempt here to be coherent in terms of race conditions, especially not with regards`
`102`	`102`	`// to different counters. So idle and busy and be unsynchronized, as they're not polled together.`
`@@ -111,7 +111,7 @@ int GetIdleConnections()`
`111`	`111`	`}`
`112`	`112`	`}`
`113`	`113`
`114`		`- int GetBusyConnections()`
	`114`	`+ double GetBusyConnections()`
`115`	`115`	`{`
`116`	`116`	`// Note: there's no attempt here to be coherent in terms of race conditions, especially not with regards`
`117`	`117`	`// to different counters. So idle and busy and be unsynchronized, as they're not polled together.`
`@@ -126,14 +126,34 @@ int GetBusyConnections()`
`126`	`126`	`}`
`127`	`127`	`}`
`128`	`128`
`129`		`- int GetPoolsCount()`
	`129`	`+ double GetPoolsCount()`
`130`	`130`	`{`
`131`	`131`	`lock (_poolsLock)`
`132`	`132`	`{`
`133`	`133`	`return _pools.Count;`
`134`	`134`	`}`
`135`	`135`	`}`
`136`	`136`
	`137`	`+ double GetMultiplexingAverageCommandsPerBatch()`
	`138`	`+ {`
	`139`	`+ var batchesSent = Interlocked.Read(ref _multiplexingBatchesSent);`
	`140`	`+ if (batchesSent == 0)`
	`141`	`+ return -1;`
	`142`	`+`
	`143`	`+ var commandsSent = (double)Interlocked.Read(ref _multiplexingCommandsSent);`
	`144`	`+ return commandsSent / batchesSent;`
	`145`	`+ }`
	`146`	`+`
	`147`	`+ double GetMultiplexingAverageWriteTimePerBatch()`
	`148`	`+ {`
	`149`	`+ var batchesSent = Interlocked.Read(ref _multiplexingBatchesSent);`
	`150`	`+ if (batchesSent == 0)`
	`151`	`+ return -1;`
	`152`	`+`
	`153`	`+ var ticksWritten = (double)Interlocked.Read(ref _multiplexingTicksWritten);`
	`154`	`+ return ticksWritten / batchesSent / 1000;`
	`155`	`+ }`
	`156`	`+`
`137`	`157`	`protected override void OnEventCommand(EventCommandEventArgs command)`
`138`	`158`	`{`
`139`	`159`	`if (command.Command == EventCommand.Enable)`
`@@ -180,33 +200,33 @@ protected override void OnEventCommand(EventCommandEventArgs command)`
`180`	`200`	`_preparedCommandsRatioCounter = new PollingCounter(`
`181`	`201`	`"prepared-commands-ratio",`
`182`	`202`	`this,`
`183`		`- () => (double)Interlocked.Read(ref _totalPreparedCommands) / Interlocked.Read(ref _totalCommands))`
	`203`	`+ () => (double)Interlocked.Read(ref _totalPreparedCommands) / Interlocked.Read(ref _totalCommands) * 100)`
`184`	`204`	`{`
`185`	`205`	`DisplayName = "Prepared Commands Ratio",`
`186`	`206`	`DisplayUnits = "%"`
`187`	`207`	`};`
`188`	`208`
`189`		`- _poolsCounter = new PollingCounter("connection-pools", this, () => GetPoolsCount())`
	`209`	`+ _poolsCounter = new PollingCounter("connection-pools", this, GetPoolsCount)`
`190`	`210`	`{`
`191`	`211`	`DisplayName = "Connection Pools"`
`192`	`212`	`};`
`193`	`213`
`194`		`- _idleConnectionsCounter = new PollingCounter("idle-connections", this, () => GetIdleConnections())`
	`214`	`+ _idleConnectionsCounter = new PollingCounter("idle-connections", this, GetIdleConnections)`
`195`	`215`	`{`
`196`	`216`	`DisplayName = "Idle Connections"`
`197`	`217`	`};`
`198`	`218`
`199`		`- _busyConnectionsCounter = new PollingCounter("busy-connections", this, () => GetBusyConnections())`
	`219`	`+ _busyConnectionsCounter = new PollingCounter("busy-connections", this, GetBusyConnections)`
`200`	`220`	`{`
`201`	`221`	`DisplayName = "Busy Connections"`
`202`	`222`	`};`
`203`	`223`
`204`		`- _multiplexingAverageCommandsPerBatchCounter = new PollingCounter("multiplexing-average-commands-per-batch", this, () => (double)Interlocked.Read(ref _multiplexingCommandsSent) / Interlocked.Read(ref _multiplexingBatchesSent))`
	`224`	`+ _multiplexingAverageCommandsPerBatchCounter = new PollingCounter("multiplexing-average-commands-per-batch", this, GetMultiplexingAverageCommandsPerBatch)`
`205`	`225`	`{`
`206`	`226`	`DisplayName = "Average commands per multiplexing batch"`
`207`	`227`	`};`
`208`	`228`
`209`		`- _multiplexingAverageWriteTimePerBatchCounter = new PollingCounter("multiplexing-average-write-time-per-batch", this, () => (double)Interlocked.Read(ref _multiplexingTicksWritten) / Interlocked.Read(ref _multiplexingBatchesSent) / 1000)`
	`229`	`+ _multiplexingAverageWriteTimePerBatchCounter = new PollingCounter("multiplexing-average-write-time-per-batch", this, GetMultiplexingAverageWriteTimePerBatch)`
`210`	`230`	`{`
`211`	`231`	`DisplayName = "Average write time per multiplexing batch (us)",`
`212`	`232`	`DisplayUnits = "us"`