@olane/o-monitor 0.7.12-alpha.9 → 0.7.12

package/README.md

@@ -81,6 +81,10 @@ MONITOR_POLLING_INTERVAL=60000      # Polling interval in ms (default: 60000)
 # Cleanup
 MONITOR_CLEANUP_INTERVAL=3600000    # Metrics cleanup interval (default: 1 hour)
 
+# LibP2P Metrics Polling
+LIBP2P_METRICS_AUTO_POLL=true       # Enable automatic libp2p metrics polling (default: false)
+LIBP2P_METRICS_POLLING_INTERVAL=60000 # Polling interval in ms (default: 60000)
+
 # Optional Heartbeat (for all nodes)
 MONITOR_ENABLED=true                # Enable heartbeat from all nodes
 MONITOR_ADDRESS=o://monitor         # Monitor address for heartbeats
@@ -300,6 +304,56 @@ Get all libp2p metrics in one call.
 }
 ```
 
+#### `collect_libp2p_metrics`
+
+Manually trigger collection of libp2p metrics into MetricsStore.
+
+**Returns:**
+```typescript
+{
+  message: 'libp2p metrics collected',
+  timestamp: 1234567890,
+  metrics: {
+    peerCount: 10,
+    connectionCount: 5,
+    inboundConnections: 2,
+    outboundConnections: 3,
+    dhtEnabled: true,
+    dhtMode: 'server',
+    dhtRoutingTableSize: 20,
+    protocols: ['/olane/1.0.0', '/ipfs/id/1.0.0'],
+    selfPeerId: '12D3KooW...',
+    multiaddrs: ['/ip4/127.0.0.1/tcp/4001']
+  }
+}
+```
+
+#### `get_stored_libp2p_metrics`
+
+Get historical libp2p metrics from MetricsStore.
+
+**Returns:**
+```typescript
+{
+  timestamp: 1234567890,
+  latest: {
+    peerCount: 10,
+    connectionCount: 5,
+    inboundConnections: 2,
+    outboundConnections: 3,
+    dhtEnabled: true,
+    dhtMode: 'server',
+    dhtRoutingTableSize: 20
+  },
+  history: [
+    {
+      timestamp: 1234567000,
+      metrics: { ... }
+    }
+  ]
+}
+```
+
 ## HTTP API Endpoints
 
 ### Prometheus Metrics
@@ -317,11 +371,21 @@ Returns Prometheus-formatted metrics including:
 - `olane_service_last_heartbeat_timestamp{node_address="o://storage"}` - Last heartbeat timestamp
 - `olane_network_node_count` - Total nodes in network
 
-**libp2p metrics** (if enabled):
+**libp2p metrics** (when polling is enabled):
+- `libp2p_peer_count` - Number of known peers
+- `libp2p_connection_count` - Total active connections
+- `libp2p_inbound_connections` - Inbound connections
+- `libp2p_outbound_connections` - Outbound connections
+- `libp2p_dht_routing_table_size` - DHT routing table size
+
+**Native libp2p metrics** (from @libp2p/prometheus-metrics when registry is shared):
 - `libp2p_data_transfer_bytes_total` - Network I/O
 - `libp2p_kad_dht_wan_query_time_seconds` - DHT query latency
+
+**Default Node.js metrics:**
 - `process_cpu_user_seconds_total` - CPU usage
 - `nodejs_memory_usage_bytes` - Memory usage
+- And many more...
 
 ### REST API
 

package/dist/src/http/server.d.ts

@@ -1,9 +1,10 @@
-import express from 'express';
+import * as express from 'express';
 import * as promClient from 'prom-client';
 import { MetricsStore } from '../utils/metrics-store.js';
 export interface MonitorHTTPServerConfig {
     port: number;
     metricsStore: MetricsStore;
+    registry?: promClient.Registry;
     onNodeQuery?: (address: string) => Promise<any>;
     onNetworkQuery?: () => Promise<any>;
 }
@@ -20,6 +21,12 @@ export declare class MonitorHTTPServer {
     private olaneNodeActiveRequests;
     private olaneServiceLastHeartbeat;
     private olaneNetworkNodeCount;
+    private libp2pPeerCount;
+    private libp2pConnectionCount;
+    private libp2pInboundConnections;
+    private libp2pOutboundConnections;
+    private libp2pStreamCount;
+    private libp2pDhtRoutingTableSize;
     constructor(config: MonitorHTTPServerConfig);
     private setupRoutes;
     /**

package/dist/src/http/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/http/server.ts"],"names":[],"mappings":"AAAA,OAAO,OAA8B,MAAM,SAAS,CAAC;AAErD,OAAO,KAAK,UAAU,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAKzD,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,YAAY,CAAC;IAC3B,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IAChD,cAAc,CAAC,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;CACrC;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,GAAG,CAAsB;IACjC,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,WAAW,CAAC,CAAoC;IACxD,OAAO,CAAC,cAAc,CAAC,CAAqB;IAG5C,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,qBAAqB,CAAmB;IAChD,OAAO,CAAC,mBAAmB,CAAmB;IAC9C,OAAO,CAAC,uBAAuB,CAAmB;IAClD,OAAO,CAAC,yBAAyB,CAAmB;IACpD,OAAO,CAAC,qBAAqB,CAAmB;gBAEpC,MAAM,EAAE,uBAAuB;IAmD3C,OAAO,CAAC,WAAW;IA0JnB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IA0B/B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAW5B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB3B;;OAEG;IACH,MAAM,IAAI,OAAO,CAAC,WAAW;IAI7B;;OAEG;IACH,WAAW,IAAI,UAAU,CAAC,QAAQ;CAGnC"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/http/server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AAGnC,OAAO,KAAK,UAAU,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAKzD,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,YAAY,CAAC;IAC3B,QAAQ,CAAC,EAAE,UAAU,CAAC,QAAQ,CAAC;IAC/B,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IAChD,cAAc,CAAC,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;CACrC;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,GAAG,CAAc;IACzB,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,WAAW,CAAC,CAAoC;IACxD,OAAO,CAAC,cAAc,CAAC,CAAqB;IAG5C,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,qBAAqB,CAAmB;IAChD,OAAO,CAAC,mBAAmB,CAAmB;IAC9C,OAAO,CAAC,uBAAuB,CAAmB;IAClD,OAAO,CAAC,yBAAyB,CAAmB;IACpD,OAAO,CAAC,qBAAqB,CAAmB;IAGhD,OAAO,CAAC,eAAe,CAAmB;IAC1C,OAAO,CAAC,qBAAqB,CAAmB;IAChD,OAAO,CAAC,wBAAwB,CAAmB;IACnD,OAAO,CAAC,yBAAyB,CAAmB;IACpD,OAAO,CAAC,iBAAiB,CAAmB;IAC5C,OAAO,CAAC,yBAAyB,CAAmB;gBAExC,MAAM,EAAE,uBAAuB;IA6F3C,OAAO,CAAC,WAAW;IA0JnB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IA2D/B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAW5B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB3B;;OAEG;IACH,MAAM,IAAI,OAAO,CAAC,WAAW;IAI7B;;OAEG;IACH,WAAW,IAAI,UAAU,CAAC,QAAQ;CAGnC"}

package/dist/src/http/server.js

@@ -1,4 +1,5 @@
-import express from 'express';
+import * as express from 'express';
+import { json } from 'express';
 import * as promClient from 'prom-client';
 import debug from 'debug';
 const logger = debug('olane-os:monitor:http');
@@ -9,8 +10,10 @@ export class MonitorHTTPServer {
         this.port = config.port;
         this.onNodeQuery = config.onNodeQuery;
         this.onNetworkQuery = config.onNetworkQuery;
-        // Initialize Prometheus registry
-        this.registry = new promClient.Registry();
+        // Use provided registry or create new one
+        this.registry = config.registry || new promClient.Registry();
+        // Determine if we should register custom metrics
+        const shouldRegisterCustomMetrics = !config.registry;
         // Register custom Olane metrics
         this.olaneNodeSuccessCount = new promClient.Gauge({
             name: 'olane_node_success_count',
@@ -41,12 +44,45 @@ export class MonitorHTTPServer {
             help: 'Total number of nodes in the network',
             registers: [this.registry],
         });
-        // Merge with default Prometheus metrics (if libp2p metrics are enabled)
-        promClient.collectDefaultMetrics({ register: this.registry });
+        // Register libp2p metrics
+        this.libp2pPeerCount = new promClient.Gauge({
+            name: 'libp2p_peer_count',
+            help: 'Number of known peers in libp2p peer store',
+            registers: [this.registry],
+        });
+        this.libp2pConnectionCount = new promClient.Gauge({
+            name: 'libp2p_connection_count',
+            help: 'Total number of active libp2p connections',
+            registers: [this.registry],
+        });
+        this.libp2pInboundConnections = new promClient.Gauge({
+            name: 'libp2p_inbound_connections',
+            help: 'Number of inbound libp2p connections',
+            registers: [this.registry],
+        });
+        this.libp2pOutboundConnections = new promClient.Gauge({
+            name: 'libp2p_outbound_connections',
+            help: 'Number of outbound libp2p connections',
+            registers: [this.registry],
+        });
+        this.libp2pStreamCount = new promClient.Gauge({
+            name: 'libp2p_stream_count',
+            help: 'Total number of active libp2p streams',
+            registers: [this.registry],
+        });
+        this.libp2pDhtRoutingTableSize = new promClient.Gauge({
+            name: 'libp2p_dht_routing_table_size',
+            help: 'Size of the DHT routing table',
+            registers: [this.registry],
+        });
+        // Only collect default metrics if we created the registry
+        if (shouldRegisterCustomMetrics) {
+            promClient.collectDefaultMetrics({ register: this.registry });
+        }
         this.setupRoutes();
     }
     setupRoutes() {
-        this.app.use(express.json());
+        this.app.use(json());
         // Health check endpoint
         this.app.get('/health', (req, res) => {
             res.status(200).json({ status: 'ok', timestamp: Date.now() });
@@ -212,6 +248,29 @@ export class MonitorHTTPServer {
         // Update network-wide metrics
         const summary = this.metricsStore.getSummary();
         this.olaneNetworkNodeCount.set(summary.totalNodes);
+        // Update libp2p metrics from stored data
+        const libp2pMetrics = this.metricsStore.getLatestMetrics('o://libp2p');
+        if (libp2pMetrics?.libp2pMetrics) {
+            const lm = libp2pMetrics.libp2pMetrics;
+            if (lm.peerCount !== undefined) {
+                this.libp2pPeerCount.set(lm.peerCount);
+            }
+            if (lm.connectionCount !== undefined) {
+                this.libp2pConnectionCount.set(lm.connectionCount);
+            }
+            if (lm.inboundConnections !== undefined) {
+                this.libp2pInboundConnections.set(lm.inboundConnections);
+            }
+            if (lm.outboundConnections !== undefined) {
+                this.libp2pOutboundConnections.set(lm.outboundConnections);
+            }
+            if (lm.streamCount !== undefined) {
+                this.libp2pStreamCount.set(lm.streamCount);
+            }
+            if (lm.dhtRoutingTableSize !== undefined) {
+                this.libp2pDhtRoutingTableSize.set(lm.dhtRoutingTableSize);
+            }
+        }
     }
     /**
      * Start the HTTP server

package/dist/src/index.d.ts

@@ -7,4 +7,5 @@ export { MetricsStore } from './utils/metrics-store.js';
 export type { MetricEntry, HeartbeatEntry } from './utils/metrics-store.js';
 export { MonitorHTTPServer } from './http/server.js';
 export type { MonitorHTTPServerConfig } from './http/server.js';
+export { prometheusMetrics } from '@libp2p/prometheus-metrics';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAG3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACzE,OAAO,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAG/E,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACxD,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAG5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,YAAY,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAG3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACzE,OAAO,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAG/E,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACxD,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAG5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,YAAY,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAGhE,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/src/index.js

@@ -8,3 +8,5 @@ export { LibP2PMetricsProvider } from './providers/libp2p-metrics.provider.js';
 export { MetricsStore } from './utils/metrics-store.js';
 // HTTP server exports
 export { MonitorHTTPServer } from './http/server.js';
+// Prometheus exports
+export { prometheusMetrics } from '@libp2p/prometheus-metrics';

package/dist/src/monitor.tool.d.ts

@@ -1,10 +1,12 @@
 import { oAddress, oRequest } from '@olane/o-core';
 import { oNodeToolConfig } from '@olane/o-node';
 import { oLaneTool } from '@olane/o-lane';
+import * as promClient from 'prom-client';
 export interface MonitorToolConfig extends Partial<oNodeToolConfig> {
     httpPort?: number;
     enableHTTP?: boolean;
     address?: oAddress;
+    prometheusRegistry?: promClient.Registry;
 }
 /**
  * MonitorTool - Comprehensive monitoring tool for Olane OS
@@ -24,6 +26,7 @@ export declare class MonitorTool extends oLaneTool {
     private httpPort;
     private enableHTTP;
     private cleanupInterval?;
+    private prometheusRegistry?;
     private heartbeatProvider?;
     private nodeHealthProvider?;
     private libp2pMetricsProvider?;

package/dist/src/monitor.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"monitor.tool.d.ts","sourceRoot":"","sources":["../../src/monitor.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAO1C,MAAM,WAAW,iBAAkB,SAAQ,OAAO,CAAC,eAAe,CAAC;IACjE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,QAAQ,CAAC;CACpB;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,WAAY,SAAQ,SAAS;IACxC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,UAAU,CAAC,CAAoB;IACvC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,UAAU,CAAU;IAC5B,OAAO,CAAC,eAAe,CAAC,CAAiB;IAGzC,OAAO,CAAC,iBAAiB,CAAC,CAAoB;IAC9C,OAAO,CAAC,kBAAkB,CAAC,CAAqB;IAChD,OAAO,CAAC,qBAAqB,CAAC,CAAwB;gBAE1C,MAAM,EAAE,iBAAiB;IAkB/B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAiB3B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IA0B/B;;OAEG;YACW,mBAAmB;IA8BjC;;OAEG;YACW,eAAe;IAqC7B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAgB5B;;OAEG;IACG,sBAAsB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAO7D;;OAEG;IACG,wBAAwB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAO/D;;OAEG;IACG,sBAAsB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAO7D;;OAEG;IACG,wBAAwB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAO/D;;OAEG;IACG,qBAAqB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAyB5D;;OAEG;IACG,wBAAwB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAwC/D;;OAEG;IACG,sBAAsB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAqB7D;;OAEG;IACG,4BAA4B,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAOnE;;OAEG;IACG,mBAAmB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAO1D;;OAEG;IACG,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAO3D;;OAEG;IACG,wBAAwB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAO/D;;OAEG;IACG,cAAc,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAOrD;;OAEG;IACG,yBAAyB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAgChE;;OAEG;IACG,+BAA+B,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;CAcvE"}
+{"version":3,"file":"monitor.tool.d.ts","sourceRoot":"","sources":["../../src/monitor.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAM1C,OAAO,KAAK,UAAU,MAAM,aAAa,CAAC;AAE1C,MAAM,WAAW,iBAAkB,SAAQ,OAAO,CAAC,eAAe,CAAC;IACjE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,kBAAkB,CAAC,EAAE,UAAU,CAAC,QAAQ,CAAC;CAC1C;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,WAAY,SAAQ,SAAS;IACxC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,UAAU,CAAC,CAAoB;IACvC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,UAAU,CAAU;IAC5B,OAAO,CAAC,eAAe,CAAC,CAAiB;IACzC,OAAO,CAAC,kBAAkB,CAAC,CAAsB;IAGjD,OAAO,CAAC,iBAAiB,CAAC,CAAoB;IAC9C,OAAO,CAAC,kBAAkB,CAAC,CAAqB;IAChD,OAAO,CAAC,qBAAqB,CAAC,CAAwB;gBAE1C,MAAM,EAAE,iBAAiB;IAsB/B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAiB3B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IA0B/B;;OAEG;YACW,mBAAmB;IAuDjC;;OAEG;YACW,eAAe;IAsC7B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAgB5B;;OAEG;IACG,sBAAsB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAO7D;;OAEG;IACG,wBAAwB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAO/D;;OAEG;IACG,sBAAsB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAO7D;;OAEG;IACG,wBAAwB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAO/D;;OAEG;IACG,qBAAqB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAyB5D;;OAEG;IACG,wBAAwB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAwC/D;;OAEG;IACG,sBAAsB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAqB7D;;OAEG;IACG,4BAA4B,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAOnE;;OAEG;IACG,mBAAmB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAO1D;;OAEG;IACG,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAO3D;;OAEG;IACG,wBAAwB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAO/D;;OAEG;IACG,cAAc,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAOrD;;OAEG;IACG,yBAAyB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAgChE;;OAEG;IACG,+BAA+B,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;CAcvE"}

package/dist/src/monitor.tool.js

@@ -5,6 +5,7 @@ import { MonitorHTTPServer } from './http/server.js';
 import { HeartbeatProvider } from './providers/heartbeat.provider.js';
 import { NodeHealthProvider } from './providers/node-health.provider.js';
 import { LibP2PMetricsProvider } from './providers/libp2p-metrics.provider.js';
+import * as promClient from 'prom-client';
 /**
  * MonitorTool - Comprehensive monitoring tool for Olane OS
  *
@@ -26,12 +27,15 @@ export class MonitorTool extends oLaneTool {
                 'Monitoring and observability tool for Olane OS network',
             leader: config.leader || null,
             parent: config.parent || null,
+            network: config.network,
         });
         this.metricsStore = new MetricsStore();
         this.httpPort =
             config.httpPort || parseInt(process.env.MONITOR_HTTP_PORT || '9090', 10);
         this.enableHTTP =
             config.enableHTTP ?? process.env.MONITOR_HTTP_ENABLED !== 'false';
+        // Create a Prometheus registry if not provided
+        this.prometheusRegistry = config.prometheusRegistry || new promClient.Registry();
     }
     async initialize() {
         await super.initialize();
@@ -77,23 +81,48 @@ export class MonitorTool extends oLaneTool {
             leader: this.leader,
             metricsStore: this.metricsStore,
         });
+        this.heartbeatProvider.initConnectionManager = async () => {
+            this.heartbeatProvider.connectionManager = this.connectionManager;
+        };
+        this.heartbeatProvider.hookInitializeFinished = async () => {
+            if (!this.heartbeatProvider)
+                return;
+            this.addChildNode(this.heartbeatProvider);
+        };
         await this.heartbeatProvider.start();
-        this.addChildNode(this.heartbeatProvider);
         // Node Health Provider
         this.nodeHealthProvider = new NodeHealthProvider({
             parent: this.address,
             leader: this.leader,
             metricsStore: this.metricsStore,
         });
+        this.nodeHealthProvider.initConnectionManager = async () => {
+            this.nodeHealthProvider.connectionManager = this.connectionManager;
+        };
+        this.nodeHealthProvider.hookInitializeFinished = async () => {
+            if (!this.nodeHealthProvider)
+                return;
+            this.addChildNode(this.nodeHealthProvider);
+        };
         await this.nodeHealthProvider.start();
-        this.addChildNode(this.nodeHealthProvider);
         // LibP2P Metrics Provider
         this.libp2pMetricsProvider = new LibP2PMetricsProvider({
             parent: this.address,
             leader: this.leader,
+            metricsStore: this.metricsStore,
+            prometheusRegistry: this.prometheusRegistry,
+            enablePolling: process.env.LIBP2P_METRICS_AUTO_POLL !== 'false',
+            pollingInterval: parseInt(process.env.LIBP2P_METRICS_POLLING_INTERVAL || '60000', 10),
         });
+        this.libp2pMetricsProvider.initConnectionManager = async () => {
+            this.libp2pMetricsProvider.connectionManager = this.connectionManager;
+        };
+        this.libp2pMetricsProvider.hookInitializeFinished = async () => {
+            if (!this.libp2pMetricsProvider)
+                return;
+            this.addChildNode(this.libp2pMetricsProvider);
+        };
         await this.libp2pMetricsProvider.start();
-        this.addChildNode(this.libp2pMetricsProvider);
         this.logger.debug('All provider nodes initialized');
     }
     /**
@@ -103,6 +132,7 @@ export class MonitorTool extends oLaneTool {
         this.httpServer = new MonitorHTTPServer({
             port: this.httpPort,
             metricsStore: this.metricsStore,
+            registry: this.prometheusRegistry,
             onNodeQuery: async (address) => {
                 // Query live node data
                 try {
@@ -119,7 +149,7 @@ export class MonitorTool extends oLaneTool {
             onNetworkQuery: async () => {
                 // Query network-wide data
                 try {
-                    const registry = await this.use(new oAddress('o://leader'), {
+                    const registry = await this.use(new oAddress('o://registry'), {
                         method: 'find_all',
                         params: {},
                     });
@@ -191,7 +221,7 @@ export class MonitorTool extends oLaneTool {
      */
     async _tool_collect_metrics(request) {
         // Get all registered nodes from leader
-        const registry = await this.use(new oAddress('o://leader'), {
+        const registry = await this.use(new oAddress('o://registry'), {
             method: 'find_all',
             params: {},
         });
@@ -219,7 +249,7 @@ export class MonitorTool extends oLaneTool {
         // Get registry data
         let registryData = null;
         try {
-            const registry = await this.use(new oAddress('o://leader'), {
+            const registry = await this.use(new oAddress('o://registry'), {
                 method: 'find_all',
                 params: {},
             });

package/dist/src/providers/libp2p-metrics.provider.d.ts

@@ -1,30 +1,69 @@
 import { oRequest } from '@olane/o-core';
 import { oNodeToolConfig, oNodeTool } from '@olane/o-node';
+import { MetricsStore } from '../utils/metrics-store.js';
+import type { Registry } from 'prom-client';
+export interface LibP2PMetricsProviderConfig extends oNodeToolConfig {
+    metricsStore?: MetricsStore;
+    pollingInterval?: number;
+    enablePolling?: boolean;
+    prometheusRegistry?: Registry;
+}
 /**
  * LibP2P Metrics Provider - Extracts metrics from libp2p node
  * Child node: o://monitor/libp2p
  */
 export declare class LibP2PMetricsProvider extends oNodeTool {
-    constructor(config: oNodeToolConfig);
+    private metricsStore?;
+    private pollingInterval?;
+    private pollingIntervalMs;
+    private prometheusRegistry?;
+    constructor(config: LibP2PMetricsProviderConfig);
     initialize(): Promise<void>;
+    teardown(): Promise<void>;
+    /**
+     * Collect libp2p metrics from all nodes and store in MetricsStore
+     */
+    private collectAndStoreMetrics;
+    /**
+     * Start automatic polling of libp2p metrics
+     */
+    private startPolling;
+    /**
+     * Stop automatic polling
+     */
+    private stopPolling;
+    /**
+     * Manually trigger libp2p metrics collection from all nodes
+     */
+    _tool_collect_libp2p_metrics(request: oRequest): Promise<any>;
+    /**
+     * Get stored libp2p metrics from MetricsStore
+     * @param request.params.nodeAddress - Optional: specific node address to query (defaults to all nodes)
+     */
+    _tool_get_stored_libp2p_metrics(request: oRequest): Promise<any>;
     /**
      * Get peer information from libp2p peer store
+     * @param request.params.nodeAddress - Optional: specific node to query (defaults to this monitor's node)
      */
     _tool_get_peer_info(request: oRequest): Promise<any>;
     /**
      * Get DHT (Distributed Hash Table) status
+     * @param request.params.nodeAddress - Optional: specific node to query (defaults to this monitor's node)
      */
     _tool_get_dht_status(request: oRequest): Promise<any>;
     /**
      * Get transport and connection statistics
+     * @param request.params.nodeAddress - Optional: specific node to query (defaults to this monitor's node)
      */
     _tool_get_transport_stats(request: oRequest): Promise<any>;
     /**
      * Get connection manager status
+     * @param request.params.nodeAddress - Optional: specific node to query (defaults to this monitor's node)
      */
     _tool_get_connection_manager_status(request: oRequest): Promise<any>;
     /**
      * Get all libp2p metrics in one call
+     * @param request.params.nodeAddress - Optional: specific node to query (defaults to all nodes)
      */
     _tool_get_all_libp2p_metrics(request: oRequest): Promise<any>;
     /**

package/dist/src/providers/libp2p-metrics.provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"libp2p-metrics.provider.d.ts","sourceRoot":"","sources":["../../../src/providers/libp2p-metrics.provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE3D;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,SAAS;gBACtC,MAAM,EAAE,eAAe;IAS7B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjC;;OAEG;IACG,mBAAmB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAgC1D;;OAEG;IACG,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAkC3D;;OAEG;IACG,yBAAyB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IA4ChE;;OAEG;IACG,mCAAmC,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAuC1E;;OAEG;IACG,4BAA4B,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IA2BnE;;OAEG;IACG,eAAe,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;CAiCvD"}
+{"version":3,"file":"libp2p-metrics.provider.d.ts","sourceRoot":"","sources":["../../../src/providers/libp2p-metrics.provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,MAAM,WAAW,2BAA4B,SAAQ,eAAe;IAClE,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,kBAAkB,CAAC,EAAE,QAAQ,CAAC;CAC/B;AAED;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,SAAS;IAClD,OAAO,CAAC,YAAY,CAAC,CAAe;IACpC,OAAO,CAAC,eAAe,CAAC,CAAiB;IACzC,OAAO,CAAC,iBAAiB,CAAiB;IAC1C,OAAO,CAAC,kBAAkB,CAAC,CAAW;gBAE1B,MAAM,EAAE,2BAA2B;IAgBzC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAS3B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAK/B;;OAEG;YACW,sBAAsB;IAwEpC;;OAEG;IACH,OAAO,CAAC,YAAY;IAoBpB;;OAEG;IACH,OAAO,CAAC,WAAW;IAQnB;;OAEG;IACG,4BAA4B,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IA2BnE;;;OAGG;IACG,+BAA+B,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IA8CtE;;;OAGG;IACG,mBAAmB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAgE1D;;;OAGG;IACG,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAyE3D;;;OAGG;IACG,yBAAyB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IA4EhE;;;OAGG;IACG,mCAAmC,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAsE1E;;;OAGG;IACG,4BAA4B,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAwEnE;;OAEG;IACG,eAAe,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;CAiCvD"}

package/dist/src/providers/libp2p-metrics.provider.js

@@ -12,17 +12,208 @@ export class LibP2PMetricsProvider extends oNodeTool {
             name: 'libp2p-metrics-provider',
             description: 'Extracts and exposes libp2p network metrics',
         });
+        this.pollingIntervalMs = 60000;
+        this.metricsStore = config.metricsStore;
+        this.prometheusRegistry = config.prometheusRegistry;
+        this.pollingIntervalMs =
+            config.pollingInterval ||
+                parseInt(process.env.LIBP2P_METRICS_POLLING_INTERVAL || '60000', 10);
     }
     async initialize() {
         await super.initialize();
+        const enablePolling = process.env.LIBP2P_METRICS_AUTO_POLL !== 'false';
+        if (enablePolling && this.metricsStore) {
+            this.startPolling();
+        }
+    }
+    async teardown() {
+        this.stopPolling();
+        await super.teardown();
+    }
+    /**
+     * Collect libp2p metrics from all nodes and store in MetricsStore
+     */
+    async collectAndStoreMetrics() {
+        if (!this.metricsStore)
+            return;
+        try {
+            // Get all registered nodes from the registry
+            const registry = await this.use(oAddress.registry(), {
+                method: 'find_all',
+                params: {},
+            });
+            if (!registry.result || !registry.result.data) {
+                this.logger.warn('No nodes found in registry for libp2p metrics collection');
+                return;
+            }
+            const addresses = Array.isArray(registry.result.data)
+                ? registry.result.data.map((node) => node.address)
+                : [];
+            let successCount = 0;
+            let failureCount = 0;
+            // Collect libp2p metrics from each node
+            for (const address of addresses) {
+                try {
+                    const result = await this.use(new oAddress(address), {
+                        method: 'get_libp2p_metrics',
+                        params: {},
+                    });
+                    const libp2pMetrics = result.result.data;
+                    if (libp2pMetrics && libp2pMetrics.available) {
+                        // Store per-node metrics in MetricsStore
+                        this.metricsStore.storeMetrics(this.address.toStaticAddress().toString(), {
+                            successCount: 0,
+                            errorCount: 0,
+                            activeRequests: libp2pMetrics.connectionCount || 0,
+                            libp2pMetrics,
+                        });
+                        successCount++;
+                        this.logger.debug(`Collected libp2p metrics from ${address}: ${libp2pMetrics.peerCount} peers, ${libp2pMetrics.connectionCount} connections`);
+                    }
+                    else {
+                        this.logger.debug(`libp2p not available on node ${address}: ${libp2pMetrics?.error || 'unknown reason'}`);
+                    }
+                }
+                catch (error) {
+                    this.logger.error(`Failed to collect libp2p metrics from ${address}:`, error.message);
+                    failureCount++;
+                }
+            }
+            this.logger.debug(`Libp2p metrics collection complete: ${successCount} successful, ${failureCount} failed`);
+        }
+        catch (error) {
+            this.logger.error('Error during libp2p metrics collection:', error);
+        }
+    }
+    /**
+     * Start automatic polling of libp2p metrics
+     */
+    startPolling() {
+        if (this.pollingInterval) {
+            return;
+        }
+        this.logger.info(`Starting libp2p metrics polling every ${this.pollingIntervalMs}ms`);
+        // Immediate first collection
+        this.collectAndStoreMetrics().catch((err) => this.logger.error('Error in initial metrics collection:', err));
+        // Set up interval
+        this.pollingInterval = setInterval(async () => {
+            await this.collectAndStoreMetrics();
+        }, this.pollingIntervalMs);
+    }
+    /**
+     * Stop automatic polling
+     */
+    stopPolling() {
+        if (this.pollingInterval) {
+            clearInterval(this.pollingInterval);
+            this.pollingInterval = undefined;
+            this.logger.info('Stopped libp2p metrics polling');
+        }
+    }
+    /**
+     * Manually trigger libp2p metrics collection from all nodes
+     */
+    async _tool_collect_libp2p_metrics(request) {
+        await this.collectAndStoreMetrics();
+        if (!this.metricsStore) {
+            return {
+                message: 'MetricsStore not configured',
+                timestamp: Date.now(),
+                collected: 0,
+            };
+        }
+        // Get all tracked nodes with libp2p metrics
+        const allNodes = this.metricsStore.getAllTrackedNodes();
+        const nodesWithMetrics = allNodes.filter((address) => {
+            const metrics = this.metricsStore?.getLatestMetrics(address);
+            return metrics?.libp2pMetrics?.available;
+        });
+        return {
+            message: 'libp2p metrics collected from all nodes',
+            timestamp: Date.now(),
+            nodesCollected: nodesWithMetrics.length,
+            totalNodes: allNodes.length,
+            nodes: nodesWithMetrics,
+        };
+    }
+    /**
+     * Get stored libp2p metrics from MetricsStore
+     * @param request.params.nodeAddress - Optional: specific node address to query (defaults to all nodes)
+     */
+    async _tool_get_stored_libp2p_metrics(request) {
+        if (!this.metricsStore) {
+            throw new Error('MetricsStore not configured');
+        }
+        const { nodeAddress } = request.params;
+        // If a specific node is requested, return only that node's metrics
+        if (nodeAddress) {
+            const latestMetrics = this.metricsStore.getLatestMetrics(nodeAddress);
+            const allMetrics = this.metricsStore.getAllMetrics(nodeAddress);
+            return {
+                timestamp: Date.now(),
+                nodeAddress,
+                latest: latestMetrics?.libp2pMetrics || null,
+                history: allMetrics
+                    .filter((m) => m.libp2pMetrics)
+                    .map((m) => ({
+                    timestamp: m.timestamp,
+                    metrics: m.libp2pMetrics,
+                })),
+            };
+        }
+        // Otherwise, return metrics from all nodes
+        const allNodes = this.metricsStore.getAllTrackedNodes();
+        const nodeMetrics = {};
+        for (const address of allNodes) {
+            const latestMetrics = this.metricsStore.getLatestMetrics(address);
+            if (latestMetrics?.libp2pMetrics) {
+                nodeMetrics[address] = {
+                    latest: latestMetrics.libp2pMetrics,
+                    lastUpdated: latestMetrics.timestamp,
+                };
+            }
+        }
+        return {
+            timestamp: Date.now(),
+            nodeCount: Object.keys(nodeMetrics).length,
+            nodes: nodeMetrics,
+        };
     }
     /**
      * Get peer information from libp2p peer store
+     * @param request.params.nodeAddress - Optional: specific node to query (defaults to this monitor's node)
      */
     async _tool_get_peer_info(request) {
+        const { nodeAddress } = request.params;
+        // If querying a remote node, forward the request
+        if (nodeAddress) {
+            try {
+                const result = await this.use(new oAddress(nodeAddress), {
+                    method: 'get_libp2p_metrics',
+                    params: {},
+                });
+                const metrics = result.result.data;
+                if (!metrics || !metrics.available) {
+                    throw new Error(`libp2p not available on node ${nodeAddress}`);
+                }
+                // Return peer information from the metrics
+                return {
+                    timestamp: Date.now(),
+                    nodeAddress,
+                    peerCount: metrics.peerCount,
+                    selfPeerId: metrics.selfPeerId,
+                    selfMultiaddrs: metrics.multiaddrs,
+                    protocols: metrics.protocols,
+                };
+            }
+            catch (error) {
+                throw new Error(`Failed to get peer info from ${nodeAddress}: ${error.message}`);
+            }
+        }
+        // Otherwise, query this node's libp2p instance
         const p2pNode = this.p2pNode;
         if (!p2pNode) {
-            throw new Error('libp2p node not available');
+            throw new Error('libp2p node not available on monitor');
         }
         try {
             const peers = await p2pNode.peerStore.all();
@@ -50,11 +241,37 @@ export class LibP2PMetricsProvider extends oNodeTool {
     }
     /**
      * Get DHT (Distributed Hash Table) status
+     * @param request.params.nodeAddress - Optional: specific node to query (defaults to this monitor's node)
      */
     async _tool_get_dht_status(request) {
+        const { nodeAddress } = request.params;
+        // If querying a remote node, forward the request
+        if (nodeAddress) {
+            try {
+                const result = await this.use(new oAddress(nodeAddress), {
+                    method: 'get_libp2p_metrics',
+                    params: {},
+                });
+                const metrics = result.result.data;
+                if (!metrics || !metrics.available) {
+                    throw new Error(`libp2p not available on node ${nodeAddress}`);
+                }
+                return {
+                    timestamp: Date.now(),
+                    nodeAddress,
+                    enabled: metrics.dhtEnabled,
+                    mode: metrics.dhtMode,
+                    routingTableSize: metrics.dhtRoutingTableSize,
+                };
+            }
+            catch (error) {
+                throw new Error(`Failed to get DHT status from ${nodeAddress}: ${error.message}`);
+            }
+        }
+        // Otherwise, query this node's libp2p instance
         const p2pNode = this.p2pNode;
         if (!p2pNode) {
-            throw new Error('libp2p node not available');
+            throw new Error('libp2p node not available on monitor');
         }
         try {
             // Get DHT service if available
@@ -69,11 +286,20 @@ export class LibP2PMetricsProvider extends oNodeTool {
             // Get routing table info
             const routingTable = dht?.routingTable;
             const kBuckets = routingTable?.kb || null;
+            let routingTableSize = 0;
+            if (kBuckets) {
+                if (Array.isArray(kBuckets)) {
+                    routingTableSize = kBuckets.length;
+                }
+                else if (typeof kBuckets === 'object') {
+                    routingTableSize = Object.keys(kBuckets).length;
+                }
+            }
             return {
                 timestamp: Date.now(),
                 enabled: true,
                 mode: dht.clientMode ? 'client' : 'server',
-                routingTableSize: kBuckets ? kBuckets.length : 0,
+                routingTableSize,
                 // Add more DHT-specific metrics as needed
             };
         }
@@ -83,16 +309,44 @@ export class LibP2PMetricsProvider extends oNodeTool {
     }
     /**
      * Get transport and connection statistics
+     * @param request.params.nodeAddress - Optional: specific node to query (defaults to this monitor's node)
      */
     async _tool_get_transport_stats(request) {
+        const { nodeAddress } = request.params;
+        // If querying a remote node, forward the request
+        if (nodeAddress) {
+            try {
+                const result = await this.use(new oAddress(nodeAddress), {
+                    method: 'get_libp2p_metrics',
+                    params: {},
+                });
+                const metrics = result.result.data;
+                if (!metrics || !metrics.available) {
+                    throw new Error(`libp2p not available on node ${nodeAddress}`);
+                }
+                return {
+                    timestamp: Date.now(),
+                    nodeAddress,
+                    connectionCount: metrics.connectionCount,
+                    protocols: metrics.protocols,
+                    multiaddrs: metrics.multiaddrs,
+                    inboundConnections: metrics.inboundConnections,
+                    outboundConnections: metrics.outboundConnections,
+                    streamCount: metrics.streamCount,
+                };
+            }
+            catch (error) {
+                throw new Error(`Failed to get transport stats from ${nodeAddress}: ${error.message}`);
+            }
+        }
+        // Otherwise, query this node's libp2p instance
         const p2pNode = this.p2pNode;
         if (!p2pNode) {
-            throw new Error('libp2p node not available');
+            throw new Error('libp2p node not available on monitor');
         }
         try {
             const connections = p2pNode.getConnections();
-            const dialQueue = p2pNode.services.connectionManager
-                ?.dialQueue;
+            const dialQueue = p2pNode.services.connectionManager?.dialQueue;
             const connectionStats = connections.map((conn) => ({
                 remotePeer: conn.remotePeer.toString(),
                 remoteAddr: conn.remoteAddr.toString(),
@@ -125,11 +379,38 @@ export class LibP2PMetricsProvider extends oNodeTool {
     }
     /**
      * Get connection manager status
+     * @param request.params.nodeAddress - Optional: specific node to query (defaults to this monitor's node)
      */
     async _tool_get_connection_manager_status(request) {
+        const { nodeAddress } = request.params;
+        // If querying a remote node, forward the request
+        if (nodeAddress) {
+            try {
+                const result = await this.use(new oAddress(nodeAddress), {
+                    method: 'get_libp2p_metrics',
+                    params: {},
+                });
+                const metrics = result.result.data;
+                if (!metrics || !metrics.available) {
+                    throw new Error(`libp2p not available on node ${nodeAddress}`);
+                }
+                return {
+                    timestamp: Date.now(),
+                    nodeAddress,
+                    totalConnections: metrics.connectionCount,
+                    uniquePeers: metrics.peerCount,
+                    inboundConnections: metrics.inboundConnections,
+                    outboundConnections: metrics.outboundConnections,
+                };
+            }
+            catch (error) {
+                throw new Error(`Failed to get connection manager status from ${nodeAddress}: ${error.message}`);
+            }
+        }
+        // Otherwise, query this node's libp2p instance
         const p2pNode = this.p2pNode;
         if (!p2pNode) {
-            throw new Error('libp2p node not available');
+            throw new Error('libp2p node not available on monitor');
         }
         try {
             const connections = p2pNode.getConnections();
@@ -157,25 +438,62 @@ export class LibP2PMetricsProvider extends oNodeTool {
     }
     /**
      * Get all libp2p metrics in one call
+     * @param request.params.nodeAddress - Optional: specific node to query (defaults to all nodes)
      */
     async _tool_get_all_libp2p_metrics(request) {
-        const p2pNode = this.p2pNode;
-        if (!p2pNode) {
-            throw new Error('libp2p node not available');
+        const { nodeAddress } = request.params;
+        // If querying a specific node, get all its metrics
+        if (nodeAddress) {
+            try {
+                const [peerInfoResult, dhtStatusResult, transportStatsResult, connectionManagerStatusResult,] = await Promise.all([
+                    this.use(this.address, {
+                        method: 'get_peer_info',
+                        params: { nodeAddress },
+                    }),
+                    this.use(this.address, {
+                        method: 'get_dht_status',
+                        params: { nodeAddress },
+                    }),
+                    this.use(this.address, {
+                        method: 'get_transport_stats',
+                        params: { nodeAddress },
+                    }),
+                    this.use(this.address, {
+                        method: 'get_connection_manager_status',
+                        params: { nodeAddress },
+                    }),
+                ]);
+                return {
+                    timestamp: Date.now(),
+                    nodeAddress,
+                    peerInfo: peerInfoResult.result.data,
+                    dhtStatus: dhtStatusResult.result.data,
+                    transportStats: transportStatsResult.result.data,
+                    connectionManagerStatus: connectionManagerStatusResult.result.data,
+                };
+            }
+            catch (error) {
+                throw new Error(`Failed to get all libp2p metrics from ${nodeAddress}: ${error.message}`);
+            }
+        }
+        // Otherwise, get metrics from all nodes
+        if (!this.metricsStore) {
+            throw new Error('MetricsStore not configured');
         }
         try {
-            const [peerInfo, dhtStatus, transportStats, connectionManagerStatus] = await Promise.all([
-                this._tool_get_peer_info(request),
-                this._tool_get_dht_status(request),
-                this._tool_get_transport_stats(request),
-                this._tool_get_connection_manager_status(request),
-            ]);
+            const allNodes = this.metricsStore.getAllTrackedNodes();
+            const nodeMetrics = {};
+            for (const address of allNodes) {
+                const latestMetrics = this.metricsStore.getLatestMetrics(address);
+                if (latestMetrics?.libp2pMetrics?.available) {
+                    nodeMetrics[address] = latestMetrics.libp2pMetrics;
+                }
+            }
             return {
                 timestamp: Date.now(),
-                peerInfo,
-                dhtStatus,
-                transportStats,
-                connectionManagerStatus,
+                nodeCount: Object.keys(nodeMetrics).length,
+                totalNodes: allNodes.length,
+                nodes: nodeMetrics,
             };
         }
         catch (error) {

package/dist/src/providers/node-health.provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-health.provider.d.ts","sourceRoot":"","sources":["../../../src/providers/node-health.provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD,MAAM,WAAW,wBAAyB,SAAQ,eAAe;IAC/D,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,SAAS;IAC/C,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,eAAe,CAAC,CAAiB;IACzC,OAAO,CAAC,iBAAiB,CAAiB;gBAE9B,MAAM,EAAE,wBAAwB;IAgBtC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAS3B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAK/B;;OAEG;IACG,0BAA0B,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAsDjE;;OAEG;IACG,yBAAyB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IA2ChE;;OAEG;IACG,0BAA0B,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAwCjE;;OAEG;IACG,4BAA4B,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAmDnE;;OAEG;IACH,OAAO,CAAC,YAAY;IAyCpB;;OAEG;IACH,OAAO,CAAC,WAAW;IAQnB;;OAEG;IACG,cAAc,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;CAsCtD"}
+{"version":3,"file":"node-health.provider.d.ts","sourceRoot":"","sources":["../../../src/providers/node-health.provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD,MAAM,WAAW,wBAAyB,SAAQ,eAAe;IAC/D,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,SAAS;IAC/C,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,eAAe,CAAC,CAAiB;IACzC,OAAO,CAAC,iBAAiB,CAAiB;gBAE9B,MAAM,EAAE,wBAAwB;IAgBtC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAS3B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAK/B;;OAEG;IACG,0BAA0B,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAwDjE;;OAEG;IACG,yBAAyB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IA2ChE;;OAEG;IACG,0BAA0B,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAwCjE;;OAEG;IACG,4BAA4B,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAmDnE;;OAEG;IACH,OAAO,CAAC,YAAY;IAkCpB;;OAEG;IACH,OAAO,CAAC,WAAW;IAQnB;;OAEG;IACG,cAAc,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;CA+BtD"}

package/dist/src/providers/node-health.provider.js

@@ -1,4 +1,4 @@
-import { oAddress, oRequest } from '@olane/o-core';
+import { oAddress } from '@olane/o-core';
 import { oNodeTool } from '@olane/o-node';
 /**
  * Node Health Provider - Polls nodes for health status and metrics
@@ -47,16 +47,17 @@ export class NodeHealthProvider extends oNodeTool {
                     method: 'get_metrics',
                     params: {},
                 });
+                const data = metrics.result.data;
                 // Store in metrics store
                 if (metrics.result) {
                     this.metricsStore.storeMetrics(address, {
-                        successCount: metrics.result.successCount || 0,
-                        errorCount: metrics.result.errorCount || 0,
-                        activeRequests: metrics.result.activeRequests || 0,
-                        state: metrics.result.state,
-                        uptime: metrics.result.uptime,
-                        memoryUsage: metrics.result.memoryUsage,
-                        children: metrics.result.children,
+                        successCount: data.successCount || 0,
+                        errorCount: data.errorCount || 0,
+                        activeRequests: data.activeRequests || 0,
+                        state: data.state,
+                        uptime: data.uptime,
+                        memoryUsage: data.memoryUsage,
+                        children: data.children,
                     });
                 }
                 results.push({
@@ -137,13 +138,12 @@ export class NodeHealthProvider extends oNodeTool {
                     method: 'get_metrics',
                     params: {},
                 });
-                if (metrics.result && metrics.result.children) {
+                const data = metrics.result.data;
+                if (data && data.children) {
                     hierarchyData.push({
                         address,
-                        children: metrics.result.children,
-                        childCount: Array.isArray(metrics.result.children)
-                            ? metrics.result.children.length
-                            : 0,
+                        children: data.children,
+                        childCount: Array.isArray(data.children) ? data.children.length : 0,
                     });
                 }
             }
@@ -216,7 +216,7 @@ export class NodeHealthProvider extends oNodeTool {
         this.pollingInterval = setInterval(async () => {
             try {
                 // Get all registered nodes from leader
-                const registry = await this.use(new oAddress('o://leader'), {
+                const registry = await this.use(oAddress.registry(), {
                     method: 'find_all',
                     params: {},
                 });
@@ -225,15 +225,10 @@ export class NodeHealthProvider extends oNodeTool {
                         ? registry.result.data.map((node) => node.address)
                         : [];
                     // Collect metrics from all nodes
-                    await this._tool_collect_node_metrics(new oRequest({
+                    await this.use(this.address, {
                         method: 'collect_node_metrics',
-                        params: {
-                            addresses,
-                            _connectionId: 'auto-poll',
-                            _requestMethod: 'collect_node_metrics',
-                        },
-                        id: 'auto-poll',
-                    }));
+                        params: { addresses },
+                    });
                 }
             }
             catch (error) {
@@ -256,7 +251,7 @@ export class NodeHealthProvider extends oNodeTool {
      */
     async _tool_poll_now(request) {
         try {
-            const registry = await this.use(new oAddress('o://leader'), {
+            const registry = await this.use(oAddress.registry(), {
                 method: 'find_all',
                 params: {},
             });
@@ -269,15 +264,10 @@ export class NodeHealthProvider extends oNodeTool {
             const addresses = Array.isArray(registry.result.data)
                 ? registry.result.data.map((node) => node.address)
                 : [];
-            const result = await this._tool_collect_node_metrics(new oRequest({
+            const result = await this.use(this.address, {
                 method: 'collect_node_metrics',
-                params: {
-                    addresses,
-                    _connectionId: 'manual-poll',
-                    _requestMethod: 'collect_node_metrics',
-                },
-                id: 'manual-poll',
-            }));
+                params: { addresses },
+            });
             return {
                 message: 'Polling completed',
                 ...result,

package/dist/src/utils/metrics-store.d.ts

@@ -3,6 +3,22 @@
  * Stores metrics with timestamps for each node
  */
 /// <reference types="node" />
+export interface LibP2PMetrics {
+    peerCount?: number;
+    connectionCount?: number;
+    inboundConnections?: number;
+    outboundConnections?: number;
+    streamCount?: number;
+    dhtEnabled?: boolean;
+    dhtMode?: string;
+    dhtRoutingTableSize?: number;
+    protocols?: string[];
+    selfPeerId?: string;
+    multiaddrs?: string[];
+    bytesReceived?: number;
+    bytesSent?: number;
+    [key: string]: any;
+}
 export interface MetricEntry {
     timestamp: number;
     successCount: number;
@@ -12,6 +28,7 @@ export interface MetricEntry {
     uptime?: number;
     memoryUsage?: NodeJS.MemoryUsage;
     children?: string[];
+    libp2pMetrics?: LibP2PMetrics;
     [key: string]: any;
 }
 export interface HeartbeatEntry {

package/dist/src/utils/metrics-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metrics-store.d.ts","sourceRoot":"","sources":["../../../src/utils/metrics-store.ts"],"names":[],"mappings":"AAAA;;;GAGG;;AAEH,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC,WAAW,CAAC;IACjC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,GAAG,CAAC;CACf;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,WAAW,CAAyC;IAC5D,OAAO,CAAC,UAAU,CAA0C;IAC5D,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAgB;IAClD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAiB;IAEpD;;OAEG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,WAAW,CAAC,GAAG,IAAI;IAsB5E;;OAEG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,IAAI;IAQrD;;OAEG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI;IAQrD;;OAEG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,EAAE;IAI7C;;OAEG;IACH,iBAAiB,CACf,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,WAAW,EAAE;IAOhB;;OAEG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAIxD;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAQrC;;OAEG;IACH,gBAAgB,IAAI,cAAc,EAAE;IAIpC;;OAEG;IACH,gBAAgB,IAAI,MAAM,EAAE;IAa5B;;OAEG;IACH,kBAAkB,IAAI,MAAM,EAAE;IAI9B;;OAEG;IACH,OAAO,CAAC,WAAW,GAAE,MAAgB,GAAG,IAAI;IAc5C;;OAEG;IACH,UAAU,IAAI;QACZ,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,kBAAkB,EAAE,MAAM,CAAC;KAC5B;CAuBF"}
+{"version":3,"file":"metrics-store.d.ts","sourceRoot":"","sources":["../../../src/utils/metrics-store.ts"],"names":[],"mappings":"AAAA;;;GAGG;;AAEH,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC,WAAW,CAAC;IACjC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,GAAG,CAAC;CACf;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,WAAW,CAAyC;IAC5D,OAAO,CAAC,UAAU,CAA0C;IAC5D,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAgB;IAClD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAiB;IAEpD;;OAEG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,WAAW,CAAC,GAAG,IAAI;IAsB5E;;OAEG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,IAAI;IAQrD;;OAEG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI;IAQrD;;OAEG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,EAAE;IAI7C;;OAEG;IACH,iBAAiB,CACf,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,WAAW,EAAE;IAOhB;;OAEG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAIxD;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAQrC;;OAEG;IACH,gBAAgB,IAAI,cAAc,EAAE;IAIpC;;OAEG;IACH,gBAAgB,IAAI,MAAM,EAAE;IAa5B;;OAEG;IACH,kBAAkB,IAAI,MAAM,EAAE;IAI9B;;OAEG;IACH,OAAO,CAAC,WAAW,GAAE,MAAgB,GAAG,IAAI;IAc5C;;OAEG;IACH,UAAU,IAAI;QACZ,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,kBAAkB,EAAE,MAAM,CAAC;KAC5B;CAuBF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/o-monitor",
-  "version": "0.7.12-alpha.9",
+  "version": "0.7.12",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -37,16 +37,16 @@
     "@modelcontextprotocol/sdk": "^1.18.1"
   },
   "dependencies": {
-    "@libp2p/prometheus-metrics": "^4.3.29",
-    "@olane/o-config": "0.7.12-alpha.9",
-    "@olane/o-core": "0.7.12-alpha.9",
-    "@olane/o-intelligence": "0.7.12-alpha.9",
-    "@olane/o-lane": "0.7.12-alpha.9",
-    "@olane/o-leader": "0.7.12-alpha.9",
-    "@olane/o-node": "0.7.12-alpha.9",
-    "@olane/o-protocol": "0.7.12-alpha.9",
-    "@olane/o-storage": "0.7.12-alpha.9",
-    "@olane/o-tool": "0.7.12-alpha.9",
+    "@libp2p/prometheus-metrics": "^5.0.7",
+    "@olane/o-config": "0.7.12",
+    "@olane/o-core": "0.7.12",
+    "@olane/o-intelligence": "0.7.12",
+    "@olane/o-lane": "0.7.12",
+    "@olane/o-leader": "0.7.12",
+    "@olane/o-node": "0.7.12",
+    "@olane/o-protocol": "0.7.12",
+    "@olane/o-storage": "0.7.12",
+    "@olane/o-tool": "0.7.12",
     "debug": "^4.4.1",
     "dotenv": "^16.5.0",
     "express": "^4.18.2",
@@ -74,5 +74,5 @@
     "tsx": "^4.20.3",
     "typescript": "5.4.5"
   },
-  "gitHead": "21427acbdc1d87ff9465bf19bda58cca89e8d3c7"
+  "gitHead": "3ae788ffdde8a9ea7d01245cfda5e67052ec263f"
 }