hyperswarm-stats 1.0.1 → 1.1.1

package/index.js

@@ -1,17 +1,27 @@
+const HyperDhtStats = require('hyperdht-stats')
+
 class HyperswarmStats {
   constructor (swarm) {
     this.swarm = swarm
+    this.dhtStats = new HyperDhtStats(this.swarm.dht)
 
     this._bytesTransmittedOverClosedSwarmStreams = 0
     this._packetsTransmittedOverClosedSwarmStreams = 0
     this._bytesReceivedOverClosedSwarmStreams = 0
     this._packetsReceivedOverClosedSwarmStreams = 0
+    this._retransmitsOfClosedSwarmStreams = 0
+    this._fastRecoveriesOfClosedSwarmStreams = 0
+    this._rtoCountOfClosedSwarmStreams = 0
+
     swarm.on('connection', conn => {
       conn.on('close', () => {
         this._bytesTransmittedOverClosedSwarmStreams += conn.rawStream?.bytesTransmitted || 0
         this._packetsTransmittedOverClosedSwarmStreams += conn.rawStream?.packetsTransmitted || 0
         this._bytesReceivedOverClosedSwarmStreams += conn.rawStream?.bytesReceived || 0
         this._packetsReceivedOverClosedSwarmStreams += conn.rawStream?.packetsReceived || 0
+        this._retransmitsOfClosedSwarmStreams += conn.rawStream?.retransmits
+        this._fastRecoveriesOfClosedSwarmStreams += conn.rawStream?.fastRecoveries
+        this._rtoCountOfClosedSwarmStreams += conn.rawStream?.rtoCount
       })
     })
   }
@@ -24,12 +34,57 @@ class HyperswarmStats {
     return this.swarm.stats.updates
   }
 
-  get punches () {
-    return this.swarm.dht.stats.punches
+  getAvgCongestionWindow () {
+    let totalCongestionWindow = 0
+    let count = 0
+    for (const conn of this.swarm.connections) {
+      if (conn.rawStream) {
+        count++
+        totalCongestionWindow += conn.rawStream.cwnd
+      }
+    }
+
+    return totalCongestionWindow / count
+  }
+
+  getAvgMTU () {
+    let totalMTU = 0
+    let count = 0
+    for (const conn of this.swarm.connections) {
+      if (conn.rawStream) {
+        count++
+        totalMTU += conn.rawStream.mtu
+      }
+    }
+
+    return totalMTU / count
+  }
+
+  getRetransmitsAcrossAllStreams () {
+    let countFromCurrentConns = 0
+    for (const conn of this.swarm.connections) {
+      countFromCurrentConns += conn.rawStream?.retransmits || 0
+    }
+
+    return countFromCurrentConns + this._retransmitsOfClosedSwarmStreams
+  }
+
+  getFastRecoveriesAcrossAllStreams () {
+    let countFromCurrentConns = 0
+    for (const conn of this.swarm.connections) {
+      countFromCurrentConns += conn.rawStream?.fastRecoveries || 0
+    }
+
+    return countFromCurrentConns + this._fastRecoveriesOfClosedSwarmStreams
   }
 
-  get dhtQueries () {
-    return this.swarm.dht.stats.queries
+  getRTOCountAcrossAllStreams () {
+    let countFromCurrentConns = 0
+    for (const conn of this.swarm.connections) {
+      countFromCurrentConns += conn.rawStream?.rtoCount || 0
+    }
+
+    return countFromCurrentConns + this._rtoCountOfClosedSwarmStreams
   }
 
   getBytesTransmittedAcrossAllStreams () {
@@ -68,62 +123,13 @@ class HyperswarmStats {
     return packetsFromCurrentConns + this._packetsReceivedOverClosedSwarmStreams
   }
 
-  get dhtClientSocketBytesTransmitted () {
-    return this.swarm.dht.io.clientSocket?.bytesTransmitted || 0
-  }
-
-  get dhtClientSocketPacketsTransmitted () {
-    return this.swarm.dht.io.clientSocket?.packetsTransmitted || 0
-  }
-
-  get dhtClientSocketBytesReceived () {
-    return this.swarm.dht.io.clientSocket?.bytesReceived || 0
-  }
-
-  get dhtClientSocketPacketsReceived () {
-    return this.swarm.dht.io.clientSocket?.packetsReceived || 0
-  }
-
-  get dhtServerSocketBytesTransmitted () {
-    return this.swarm.dht.io.serverSocket?.bytesTransmitted || 0
-  }
-
-  get dhtServerSocketPacketsTransmitted () {
-    return this.swarm.dht.io.serverSocket?.packetsTransmitted || 0
-  }
-
-  get dhtServerSocketBytesReceived () {
-    return this.swarm.dht.io.serverSocket?.bytesReceived || 0
-  }
-
-  get dhtServerSocketPacketsReceived () {
-    return this.swarm.dht.io.serverSocket?.packetsReceived || 0
-  }
-
-  get udxBytesTransmitted () {
-    return this.swarm.dht.udx.bytesTransmitted
-  }
-
-  get udxPacketsTransmitted () {
-    return this.swarm.dht.udx.packetsTransmitted
-  }
-
-  get udxBytesReceived () {
-    return this.swarm.dht.udx.bytesReceived
-  }
-
-  get udxPacketsReceived () {
-    return this.swarm.dht.udx.packetsReceived
-  }
-
-  // TODO
-  // get nrDhtEntries () {}
-
   get nrPeers () {
     return this.swarm.peers.size
   }
 
   registerPrometheusMetrics (promClient) {
+    this.dhtStats.registerPrometheusMetrics(promClient)
+
     const self = this
     new promClient.Gauge({ // eslint-disable-line no-new
       name: 'hyperswarm_nr_peers',
@@ -171,156 +177,69 @@ class HyperswarmStats {
     })
 
     new promClient.Gauge({ // eslint-disable-line no-new
-      name: 'dht_consistent_punches',
-      help: 'Total number of consistent holepunches performed by the hyperdht instance',
-      collect () {
-        this.set(self.punches.consistent)
-      }
-    })
-    new promClient.Gauge({ // eslint-disable-line no-new
-      name: 'dht_random_punches',
-      help: 'Total number of random holepunches performed by the hyperdht instance',
-      collect () {
-        this.set(self.punches.random)
-      }
-    })
-    new promClient.Gauge({ // eslint-disable-line no-new
-      name: 'dht_open_punches',
-      help: 'Total number of open holepunches performed by the hyperdht instance',
-      collect () {
-        this.set(self.punches.open)
-      }
-    })
-
-    new promClient.Gauge({ // eslint-disable-line no-new
-      name: 'dht_active_queries',
-      help: 'Number of currently active queries in the dht-rpc instance',
-      collect () {
-        this.set(self.dhtQueries.active)
-      }
-    })
-
-    new promClient.Gauge({ // eslint-disable-line no-new
-      name: 'dht_total_queries',
-      help: 'Total number of queries in the dht-rpc instance',
-      collect () {
-        this.set(self.dhtQueries.total)
-      }
-    })
-
-    new promClient.Gauge({ // eslint-disable-line no-new
-      name: 'hyperswarm_total_bytes_transmitted',
-      help: 'Total bytes transmitted by the hyperswarm and the DHT',
+      name: 'hyperswarm_total_bytes_transmitted_over_swarm_streams',
+      help: 'Total bytes transmitted over the streams exposed explicitly by hyperswarm connections',
       collect () {
-        this.set(self.udxBytesTransmitted)
+        this.set(self.getBytesTransmittedAcrossAllStreams())
       }
     })
     new promClient.Gauge({ // eslint-disable-line no-new
-      name: 'hyperswarm_total_packets_transmitted',
-      help: 'Total packets transmitted by the hyperswarm and the DHT',
+      name: 'hyperswarm_total_bytes_received_over_swarm_streams',
+      help: 'Total bytes received over the streams exposed explicitly by hyperswarm connections',
       collect () {
-        this.set(self.udxPacketsTransmitted)
+        this.set(self.getBytesReceivedAcrossAllStreams())
       }
     })
     new promClient.Gauge({ // eslint-disable-line no-new
-      name: 'hyperswarm_total_bytes_received',
-      help: 'Total bytes received by the hyperswarm and the DHT',
+      name: 'hyperswarm_total_packets_transmitted_over_swarm_streams',
+      help: 'Total packets transmitted over the streams exposed explicitly by hyperswarm connections',
       collect () {
-        this.set(self.udxBytesReceived)
+        this.set(self.getPacketsTransmittedAcrossAllStreams())
       }
     })
     new promClient.Gauge({ // eslint-disable-line no-new
-      name: 'hyperswarm_total_packets_received',
-      help: 'Total packets received by the hyperswarm and the DHT',
+      name: 'hyperswarm_total_packets_received_over_swarm_streams',
+      help: 'Total packets received over the streams exposed explicitly by hyperswarm connections',
       collect () {
-        this.set(self.udxPacketsReceived)
+        this.set(self.getPacketsReceivedAcrossAllStreams())
       }
     })
 
     new promClient.Gauge({ // eslint-disable-line no-new
-      name: 'dht_client_socket_bytes_transmitted',
-      help: 'Total bytes transmitted by the client socket of the DHT',
-      collect () {
-        this.set(self.dhtClientSocketBytesTransmitted)
-      }
-    })
-    new promClient.Gauge({ // eslint-disable-line no-new
-      name: 'dht_client_socket_packets_transmitted',
-      help: 'Total packets transmitted by the client socket of the DHT',
-      collect () {
-        this.set(self.dhtClientSocketPacketsTransmitted)
-      }
-    })
-    new promClient.Gauge({ // eslint-disable-line no-new
-      name: 'dht_client_socket_bytes_received',
-      help: 'Total bytes received by the client socket of the DHT',
+      name: 'hyperswarm_avg_congestion_window',
+      help: 'Average size of the congestion window (over all hyperswarm connections)',
       collect () {
-        this.set(self.dhtClientSocketBytesReceived)
-      }
-    })
-    new promClient.Gauge({ // eslint-disable-line no-new
-      name: 'dht_client_socket_packets_received',
-      help: 'Total packets received by the client socket of the DHT',
-      collect () {
-        this.set(self.dhtClientSocketPacketsReceived)
+        this.set(self.getAvgCongestionWindow())
       }
     })
 
     new promClient.Gauge({ // eslint-disable-line no-new
-      name: 'dht_server_socket_bytes_transmitted',
-      help: 'Total bytes transmitted by the server socket of the DHT',
-      collect () {
-        this.set(self.dhtServerSocketBytesTransmitted)
-      }
-    })
-    new promClient.Gauge({ // eslint-disable-line no-new
-      name: 'dht_server_socket_packets_transmitted',
-      help: 'Total packets transmitted by the server socket of the DHT',
-      collect () {
-        this.set(self.dhtServerSocketPacketsTransmitted)
-      }
-    })
-    new promClient.Gauge({ // eslint-disable-line no-new
-      name: 'dht_server_socket_bytes_received',
-      help: 'Total bytes received by the server socket of the DHT',
-      collect () {
-        this.set(self.dhtServerSocketBytesReceived)
-      }
-    })
-    new promClient.Gauge({ // eslint-disable-line no-new
-      name: 'dht_server_socket_packets_received',
-      help: 'Total packets received by the server socket of the DHT',
+      name: 'hyperswarm_avg_mtu',
+      help: 'Average size of the Maximum Transmission Unit (over all hyperswarm connections)',
       collect () {
-        this.set(self.dhtServerSocketPacketsReceived)
+        this.set(self.getAvgMTU())
       }
     })
 
     new promClient.Gauge({ // eslint-disable-line no-new
-      name: 'hyperswarm_total_bytes_transmitted_over_swarm_streams',
-      help: 'Total bytes transmitted over the streams exposed explicitly by hyperswarm connections',
+      name: 'hyperswarm_total_retransmits_over_swarm_streams',
+      help: 'Total UDX retransmits (after a lost packet), summed across the streams exposed explicitly by hyperswarm connections',
       collect () {
-        this.set(self.getBytesTransmittedAcrossAllStreams())
+        this.set(self.getRetransmitsAcrossAllStreams())
       }
     })
     new promClient.Gauge({ // eslint-disable-line no-new
-      name: 'hyperswarm_total_bytes_received_over_swarm_streams',
-      help: 'Total bytes received over the streams exposed explicitly by hyperswarm connections',
+      name: 'hyperswarm_total_fast_recoveries_over_swarm_streams',
+      help: 'Total UDX fast recoveries summed across the streams exposed explicitly by hyperswarm connections',
       collect () {
-        this.set(self.getBytesReceivedAcrossAllStreams())
+        this.set(self.getFastRecoveriesAcrossAllStreams())
       }
     })
     new promClient.Gauge({ // eslint-disable-line no-new
-      name: 'hyperswarm_total_packets_transmitted_over_swarm_streams',
-      help: 'Total packets transmitted over the streams exposed explicitly by hyperswarm connections',
+      name: 'hyperswarm_total_rto_count_over_swarm_streams',
+      help: 'Total UDX retransmission time-outs, summed across the streams exposed explicitly by hyperswarm connections',
       collect () {
-        this.set(self.getPacketsTransmittedAcrossAllStreams())
-      }
-    })
-    new promClient.Gauge({ // eslint-disable-line no-new
-      name: 'hyperswarm_total_packets_received_over_swarm_streams',
-      help: 'Total packets received over the streams exposed explicitly by hyperswarm connections',
-      collect () {
-        this.set(self.getPacketsReceivedAcrossAllStreams())
+        this.set(self.getRTOCountAcrossAllStreams())
       }
     })
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hyperswarm-stats",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "Hyperswarm stats with prometheus support",
   "main": "index.js",
   "scripts": {
@@ -30,5 +30,9 @@
     "hyperswarm": "^4.8.2",
     "prom-client": "^15.1.3",
     "standard": "^17.1.0"
+  },
+  "dependencies": {
+    "hyperdht-stats": "1.0.0",
+    "udx-native": "^1.12.0"
   }
 }