@libp2p/simple-metrics 1.3.11 → 1.3.12-3528df829

package/src/index.ts

@@ -27,13 +27,35 @@ import { serviceCapabilities } from '@libp2p/interface'
 import { logger } from '@libp2p/logger'
 import each from 'it-foreach'
 import { TDigest } from 'tdigest'
-import type { Startable, MultiaddrConnection, Stream, Connection, Metric, MetricGroup, StopTimer, Metrics, CalculatedMetricOptions, MetricOptions, Counter, CounterGroup, CalculateMetric, Histogram, HistogramOptions, HistogramGroup, Summary, SummaryOptions, SummaryGroup, CalculatedHistogramOptions, CalculatedSummaryOptions } from '@libp2p/interface'
+import type { Startable, MultiaddrConnection, Stream, Connection, Metric, MetricGroup, StopTimer, Metrics, CalculatedMetricOptions, MetricOptions, Counter, CounterGroup, CalculateMetric, Histogram, HistogramOptions, HistogramGroup, Summary, SummaryOptions, SummaryGroup, CalculatedHistogramOptions, CalculatedSummaryOptions, ComponentLogger, Logger } from '@libp2p/interface'
 import type { Duplex } from 'it-stream-types'
 
 const log = logger('libp2p:simple-metrics')
 
 class DefaultMetric implements Metric {
-  public value: number = 0
+  private value: number = 0
+  private readonly calculators: CalculateMetric[]
+
+  constructor (opts: CalculatedMetricOptions) {
+    this.calculators = []
+
+    if (opts.calculate != null) {
+      this.calculators.push(opts.calculate)
+    }
+  }
+
+  async collect (): Promise<number> {
+    if (this.calculators.length) {
+      const values = await Promise.all(this.calculators.map(async calculate => calculate()))
+      return values.reduce((acc, curr) => acc + curr, 0)
+    }
+
+    return this.value
+  }
+
+  addCalculator (calculator: CalculateMetric): void {
+    this.calculators.push(calculator)
+  }
 
   update (value: number): void {
     this.value = value
@@ -61,7 +83,35 @@ class DefaultMetric implements Metric {
 }
 
 class DefaultGroupMetric implements MetricGroup {
-  public values: Record<string, number> = {}
+  private values: Record<string, number> = {}
+  private readonly calculators: CalculateMetric[]
+
+  constructor () {
+    this.calculators = []
+  }
+
+  async collect (): Promise<Record<string, number>> {
+    if (this.calculators.length) {
+      const output: Record<string, number> = {}
+
+      await Promise.all(this.calculators.map(async calculate => {
+        const values = await calculate()
+
+        Object.entries(values).forEach(([key, value]) => {
+          output[key] ??= 0
+          output[key] += value
+        })
+      }))
+
+      return output
+    }
+
+    return this.values
+  }
+
+  addCalculator (calculator: CalculateMetric): void {
+    this.calculators.push(calculator)
+  }
 
   update (values: Record<string, number>): void {
     Object.entries(values).forEach(([key, value]) => {
@@ -101,9 +151,10 @@ class DefaultGroupMetric implements MetricGroup {
 }
 
 class DefaultHistogram implements Histogram {
-  public bucketValues = new Map<number, number>()
-  public countValue: number = 0
-  public sumValue: number = 0
+  private bucketValues = new Map<number, number>()
+  private countValue: number = 0
+  private sumValue: number = 0
+  private readonly calculators: CalculateMetric[]
 
   constructor (opts: HistogramOptions) {
     const buckets = [
@@ -113,6 +164,27 @@ class DefaultHistogram implements Histogram {
     for (const bucket of buckets) {
       this.bucketValues.set(bucket, 0)
     }
+    this.calculators = []
+  }
+
+  public async collect (): Promise<{ count: number, sum: number, buckets: Record<number, number> }> {
+    if (this.calculators.length > 0) {
+      const values = await Promise.all(this.calculators.map(async calculate => calculate()))
+
+      for (const value of values) {
+        this.observe(value)
+      }
+    }
+
+    return {
+      count: this.countValue,
+      sum: this.sumValue,
+      buckets: { ...this.bucketValues }
+    }
+  }
+
+  addCalculator (calculator: CalculateMetric): void {
+    this.calculators.push(calculator)
   }
 
   observe (value: number): void {
@@ -145,9 +217,25 @@ class DefaultHistogram implements Histogram {
 
 class DefaultHistogramGroup implements HistogramGroup {
   public histograms: Record<string, DefaultHistogram> = {}
+  private readonly calculators: CalculateMetric[]
 
   constructor (opts: HistogramOptions) {
     this.histograms = {}
+    this.calculators = []
+  }
+
+  public async collect (): Promise<Record<string, { count: number, sum: number, buckets: Record<number, number> }>> {
+    const output: Record<string, { count: number, sum: number, buckets: Record<number, number> }> = {}
+
+    for (const [key, histogram] of Object.entries(this.histograms)) {
+      output[key] = await histogram.collect()
+    }
+
+    return output
+  }
+
+  addCalculator (calculator: CalculateMetric): void {
+    this.calculators.push(calculator)
   }
 
   observe (values: Partial<Record<string, number>>): void {
@@ -181,10 +269,31 @@ class DefaultSummary implements Summary {
   public percentiles: number[]
   public tdigest = new TDigest(0.01)
   private readonly compressCount: number
+  private readonly calculators: CalculateMetric[]
 
   constructor (opts: SummaryOptions) {
     this.percentiles = opts.percentiles ?? [0.01, 0.05, 0.5, 0.9, 0.95, 0.99, 0.999]
     this.compressCount = opts.compressCount ?? 1000
+    this.calculators = []
+  }
+
+  public async collect (): Promise<{ count: number, sum: number, percentiles: Record<string, number> }> {
+    if (this.calculators.length > 0) {
+      const values = await Promise.all(this.calculators.map(async calculate => calculate()))
+      for (const value of values) {
+        this.observe(value)
+      }
+    }
+
+    return {
+      count: this.countValue,
+      sum: this.sumValue,
+      percentiles: Object.fromEntries(this.percentiles.map(p => [p, this.tdigest.percentile(p)]))
+    }
+  }
+
+  addCalculator (calculator: CalculateMetric): void {
+    this.calculators.push(calculator)
   }
 
   observe (value: number): void {
@@ -216,10 +325,34 @@ class DefaultSummary implements Summary {
 class DefaultSummaryGroup implements SummaryGroup {
   public summaries: Record<string, DefaultSummary> = {}
   private readonly opts: SummaryOptions
+  private readonly calculators: CalculateMetric<Record<string, number>>[]
 
   constructor (opts: SummaryOptions) {
     this.summaries = {}
     this.opts = opts
+    this.calculators = []
+  }
+
+  public async collect (): Promise<Record<string, { count: number, sum: number, percentiles: Record<string, number> }>> {
+    if (this.calculators.length > 0) {
+      await Promise.all(this.calculators.map(async calculate => {
+        this.observe(await calculate())
+      }))
+    }
+
+    return {
+      ...Object.fromEntries(Object.entries(this.summaries).map(([key, summary]) => {
+        return [key, {
+          count: summary.countValue,
+          sum: summary.sumValue,
+          percentiles: Object.fromEntries(summary.percentiles.map(p => [p, summary.tdigest.percentile(p)]))
+        }]
+      }))
+    }
+  }
+
+  addCalculator (calculator: CalculateMetric<Record<string, number>>): void {
+    this.calculators.push(calculator)
   }
 
   observe (values: Record<string, number>): void {
@@ -261,15 +394,21 @@ export interface SimpleMetricsInit {
   onMetrics: OnMetrics
 }
 
+export interface SimpleMetricsComponents {
+  logger: ComponentLogger
+}
+
 class SimpleMetrics implements Metrics, Startable {
-  public metrics = new Map<string, DefaultMetric | DefaultGroupMetric | CalculateMetric | DefaultHistogram | DefaultHistogramGroup | DefaultSummary | DefaultSummaryGroup>()
+  public metrics = new Map<string, DefaultMetric | DefaultGroupMetric | DefaultHistogram | DefaultHistogramGroup | DefaultSummary | DefaultSummaryGroup>()
   private readonly transferStats: Map<string, number>
   private started: boolean
   private interval?: ReturnType<typeof setInterval>
   private readonly intervalMs: number
   private readonly onMetrics: OnMetrics
+  private readonly log: Logger
 
-  constructor (components: unknown, init: SimpleMetricsInit) {
+  constructor (components: SimpleMetricsComponents, init: SimpleMetricsInit) {
+    this.log = components.logger.forComponent('libp2p:simple-metrics')
     this.started = false
 
     this._emitMetrics = this._emitMetrics.bind(this)
@@ -301,6 +440,8 @@ class SimpleMetrics implements Metrics, Startable {
     this.started = false
 
     clearInterval(this.interval)
+    this.metrics.clear()
+    this.transferStats.clear()
   }
 
   private _emitMetrics (): void {
@@ -308,45 +449,7 @@ class SimpleMetrics implements Metrics, Startable {
       const output: Record<string, any> = {}
 
       for (const [name, metric] of this.metrics.entries()) {
-        if (metric instanceof DefaultMetric) {
-          output[name] = metric.value
-        } else if (metric instanceof DefaultGroupMetric) {
-          output[name] = metric.values
-        } else if (metric instanceof DefaultHistogram) {
-          output[name] = {
-            count: metric.countValue,
-            sum: metric.sumValue,
-            buckets: { ...metric.bucketValues }
-          }
-        } else if (metric instanceof DefaultHistogramGroup) {
-          output[name] = {
-            ...Object.fromEntries(Object.entries(metric.histograms).map(([key, histogram]) => {
-              return [key, {
-                count: histogram.countValue,
-                sum: histogram.sumValue,
-                buckets: { ...histogram.bucketValues }
-              }]
-            }))
-          }
-        } else if (metric instanceof DefaultSummary) {
-          output[name] = {
-            count: metric.countValue,
-            sum: metric.sumValue,
-            percentiles: Object.fromEntries(metric.percentiles.map(p => [p, metric.tdigest.percentile(p)]))
-          }
-        } else if (metric instanceof DefaultSummaryGroup) {
-          output[name] = {
-            ...Object.fromEntries(Object.entries(metric.summaries).map(([key, summary]) => {
-              return [key, {
-                count: summary.countValue,
-                sum: summary.sumValue,
-                percentiles: Object.fromEntries(summary.percentiles.map(p => [p, summary.tdigest.percentile(p)]))
-              }]
-            }))
-          }
-        } else {
-          output[name] = await metric()
-        }
+        output[name] = await metric.collect()
       }
 
       this.onMetrics(structuredClone(output))
@@ -407,13 +510,19 @@ class SimpleMetrics implements Metrics, Startable {
       throw new Error('Metric name is required')
     }
 
-    if (opts?.calculate != null) {
-      // calculated metric
-      this.metrics.set(name, opts.calculate)
-      return
+    let metric = this.metrics.get(name)
+
+    if (metric != null) {
+      this.log('reuse existing metric', name)
+
+      if (opts.calculate != null) {
+        metric.addCalculator(opts.calculate)
+      }
+
+      return this.metrics.get(name)
     }
 
-    const metric = new DefaultMetric()
+    metric = new DefaultMetric(opts)
     this.metrics.set(name, metric)
 
     return metric
@@ -445,13 +554,19 @@ class SimpleMetrics implements Metrics, Startable {
       throw new Error('Metric name is required')
     }
 
-    if (opts?.calculate != null) {
-      // calculated metric
-      this.metrics.set(name, opts.calculate)
-      return
+    let metric = this.metrics.get(name)
+
+    if (metric != null) {
+      this.log('reuse existing metric', name)
+
+      if (opts.calculate != null) {
+        metric.addCalculator(opts.calculate)
+      }
+
+      return this.metrics.get(name)
     }
 
-    const metric = new DefaultMetric()
+    metric = new DefaultMetric(opts)
     this.metrics.set(name, metric)
 
     return metric
@@ -464,13 +579,19 @@ class SimpleMetrics implements Metrics, Startable {
       throw new Error('Metric name is required')
     }
 
-    if (opts?.calculate != null) {
-      // calculated metric
-      this.metrics.set(name, opts.calculate)
-      return
+    let metric = this.metrics.get(name)
+
+    if (metric != null) {
+      this.log('reuse existing metric', name)
+
+      if (opts.calculate != null) {
+        metric.addCalculator(opts.calculate)
+      }
+
+      return this.metrics.get(name)
     }
 
-    const metric = new DefaultGroupMetric()
+    metric = new DefaultGroupMetric()
     this.metrics.set(name, metric)
 
     return metric
@@ -483,13 +604,19 @@ class SimpleMetrics implements Metrics, Startable {
       throw new Error('Metric name is required')
     }
 
-    if (opts?.calculate != null) {
-      // calculated metric
-      this.metrics.set(name, opts.calculate)
-      return
+    let metric = this.metrics.get(name)
+
+    if (metric != null) {
+      this.log('reuse existing metric', name)
+
+      if (opts.calculate != null) {
+        metric.addCalculator(opts.calculate)
+      }
+
+      return this.metrics.get(name)
     }
 
-    const metric = new DefaultHistogram(opts)
+    metric = new DefaultHistogram(opts)
     this.metrics.set(name, metric)
 
     return metric
@@ -502,13 +629,19 @@ class SimpleMetrics implements Metrics, Startable {
       throw new Error('Metric name is required')
     }
 
-    if (opts?.calculate != null) {
-      // calculated metric
-      this.metrics.set(name, opts.calculate)
-      return
+    let metric = this.metrics.get(name)
+
+    if (metric != null) {
+      this.log('reuse existing metric', name)
+
+      if (opts.calculate != null) {
+        metric.addCalculator(opts.calculate)
+      }
+
+      return this.metrics.get(name)
     }
 
-    const metric = new DefaultHistogramGroup(opts)
+    metric = new DefaultHistogramGroup(opts)
     this.metrics.set(name, metric)
 
     return metric
@@ -521,13 +654,19 @@ class SimpleMetrics implements Metrics, Startable {
       throw new Error('Metric name is required')
     }
 
-    if (opts?.calculate != null) {
-      // calculated metric
-      this.metrics.set(name, opts.calculate)
-      return
+    let metric = this.metrics.get(name)
+
+    if (metric != null) {
+      this.log('reuse existing metric', name)
+
+      if (opts.calculate != null) {
+        metric.addCalculator(opts.calculate)
+      }
+
+      return this.metrics.get(name)
     }
 
-    const metric = new DefaultSummary(opts)
+    metric = new DefaultSummary(opts)
     this.metrics.set(name, metric)
 
     return metric
@@ -540,13 +679,19 @@ class SimpleMetrics implements Metrics, Startable {
       throw new Error('Metric name is required')
     }
 
-    if (opts?.calculate != null) {
-      // calculated metric
-      this.metrics.set(name, opts.calculate)
-      return
+    let metric = this.metrics.get(name)
+
+    if (metric != null) {
+      this.log('reuse existing metric', name)
+
+      if (opts.calculate != null) {
+        metric.addCalculator(opts.calculate)
+      }
+
+      return this.metrics.get(name)
     }
 
-    const metric = new DefaultSummaryGroup(opts)
+    metric = new DefaultSummaryGroup(opts)
     this.metrics.set(name, metric)
 
     return metric
@@ -562,6 +707,6 @@ class SimpleMetrics implements Metrics, Startable {
   }
 }
 
-export function simpleMetrics (init: SimpleMetricsInit): (components: unknown) => Metrics {
-  return (components: unknown) => new SimpleMetrics(components, init)
+export function simpleMetrics (init: SimpleMetricsInit): (components: SimpleMetricsComponents) => Metrics {
+  return (components) => new SimpleMetrics(components, init)
 }

package/dist/typedoc-urls.json

@@ -1,8 +0,0 @@
-{
-  "OnMetrics": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_simple-metrics.OnMetrics.html",
-  ".:OnMetrics": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_simple-metrics.OnMetrics.html",
-  "SimpleMetricsInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_simple-metrics.SimpleMetricsInit.html",
-  ".:SimpleMetricsInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_simple-metrics.SimpleMetricsInit.html",
-  "simpleMetrics": "https://libp2p.github.io/js-libp2p/functions/_libp2p_simple-metrics.simpleMetrics.html",
-  ".:simpleMetrics": "https://libp2p.github.io/js-libp2p/functions/_libp2p_simple-metrics.simpleMetrics.html"
-}