lib: rewrite metrics interface

Author: Qard

benchmark/perf_hooks/metrics-aggregator-histogram.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const assert = require('assert');
+const common = require('../common.js');
+
+const { metrics } = require('perf_hooks');
+
+const bench = common.createBenchmark(main, {
+  n: [1e7, 1e8],
+  boundaryCount: [5, 10, 20, 50],
+});
+
+function main({ n, boundaryCount }) {
+  const metric = metrics.create('bench.aggregator.histogram', { unit: 'ms' });
+
+  // Generate exponential boundaries like OTel defaults
+  const boundaries = [];
+  for (let i = 0; i < boundaryCount; i++) {
+    boundaries.push(Math.pow(2, i));
+  }
+
+  const consumer = metrics.createConsumer({
+    'bench.aggregator.histogram': {
+      aggregation: 'histogram',
+      boundaries,
+    },
+  });
+
+  // Generate values that spread across buckets
+  const maxBoundary = boundaries[boundaries.length - 1];
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    // Distribute values across the range
+    const value = (i % (maxBoundary + 1));
+    metric.record(value);
+  }
+  bench.end(n);
+
+  // Cleanup and avoid deadcode elimination
+  assert.ok(consumer.collect());
+  consumer.close();
+}

benchmark/perf_hooks/metrics-aggregator-sum.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const assert = require('assert');
+const common = require('../common.js');
+
+const { metrics } = require('perf_hooks');
+
+const bench = common.createBenchmark(main, {
+  n: [1e7, 1e8],
+  monotonic: ['yes', 'no'],
+  valueType: ['number', 'bigint'],
+});
+
+function main({ n, monotonic, valueType }) {
+  const metric = metrics.create('bench.aggregator.sum', { unit: 'count' });
+
+  const consumer = metrics.createConsumer({
+    'bench.aggregator.sum': {
+      aggregation: 'sum',
+      monotonic: monotonic === 'yes',
+    },
+  });
+
+  const useBigInt = valueType === 'bigint';
+  const increment = useBigInt ? 1n : 1;
+  const decrement = useBigInt ? -1n : -1;
+
+  bench.start();
+  if (monotonic === 'yes') {
+    // Monotonic - always positive values
+    for (let i = 0; i < n; i++) {
+      metric.record(increment);
+    }
+  } else {
+    // Non-monotonic - mix of positive and negative
+    for (let i = 0; i < n; i++) {
+      metric.record(i % 2 === 0 ? increment : decrement);
+    }
+  }
+  bench.end(n);
+
+  // Cleanup and avoid deadcode elimination
+  assert.ok(consumer.collect());
+  consumer.close();
+}

benchmark/perf_hooks/metrics-aggregator-summary.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const assert = require('assert');
+const common = require('../common.js');
+
+const { metrics } = require('perf_hooks');
+
+const bench = common.createBenchmark(main, {
+  n: [1e6, 1e7],
+  quantileCount: [3, 5, 10],
+});
+
+function main({ n, quantileCount }) {
+  const metric = metrics.create('bench.aggregator.summary', { unit: 'ms' });
+
+  // Generate quantiles
+  const quantiles = [];
+  for (let i = 1; i <= quantileCount; i++) {
+    quantiles.push(i / (quantileCount + 1));
+  }
+
+  const consumer = metrics.createConsumer({
+    'bench.aggregator.summary': {
+      aggregation: 'summary',
+      quantiles,
+    },
+  });
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    // Record values that simulate realistic latency distribution (min 1)
+    metric.record(Math.random() * 999 + 1);
+  }
+  bench.end(n);
+
+  // Cleanup and avoid deadcode elimination
+  assert.ok(consumer.collect());
+  consumer.close();
+}

benchmark/perf_hooks/metrics-collect.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const assert = require('assert');
+const common = require('../common.js');
+
+const { metrics } = require('perf_hooks');
+
+const bench = common.createBenchmark(main, {
+  n: [1e5, 1e6],
+  metricsCount: [10, 100],
+  attrCardinality: [1, 10, 100],
+  aggregation: ['sum', 'histogram'],
+});
+
+function main({ n, metricsCount, attrCardinality, aggregation }) {
+  // Create multiple metrics
+  const metricsList = [];
+  const subscriptions = {};
+
+  for (let i = 0; i < metricsCount; i++) {
+    const name = `bench.collect.${i}`;
+    metricsList.push(metrics.create(name, { unit: 'count' }));
+    subscriptions[name] = { aggregation };
+  }
+
+  const consumer = metrics.createConsumer(subscriptions);
+
+  // Pre-populate data with attribute cardinality
+  for (const metric of metricsList) {
+    for (let c = 0; c < attrCardinality; c++) {
+      metric.record(1, { variant: `v${c}` });
+    }
+  }
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    consumer.collect();
+  }
+  bench.end(n);
+
+  // Cleanup and avoid deadcode elimination
+  assert.ok(consumer);
+  consumer.close();
+}

benchmark/perf_hooks/metrics-dc-consumer.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const assert = require('assert');
+const common = require('../common.js');
+const dc = require('diagnostics_channel');
+
+const { metrics } = require('perf_hooks');
+
+const bench = common.createBenchmark(main, {
+  n: [1e7, 1e8],
+  hasSubscribers: ['yes', 'no'],
+});
+
+function main({ n, hasSubscribers }) {
+  const metric = metrics.create('bench.dc', { unit: 'count' });
+
+  // Create DC consumer
+  const dcConsumer = metrics.createDiagnosticsChannelConsumer();
+
+  // Optionally subscribe to the channel
+  let received = 0;
+  if (hasSubscribers === 'yes') {
+    dc.subscribe('metrics:bench.dc', () => {
+      received++;
+    });
+  }
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    metric.record(i);
+  }
+  bench.end(n);
+
+  // Cleanup and avoid deadcode elimination
+  assert.ok(dcConsumer);
+  if (hasSubscribers === 'yes') {
+    assert.strictEqual(received, n);
+  }
+  dcConsumer.close();
+}

benchmark/perf_hooks/metrics-observable.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const assert = require('assert');
+const common = require('../common.js');
+
+const { metrics } = require('perf_hooks');
+
+const bench = common.createBenchmark(main, {
+  n: [1e5, 1e6],
+  observableCount: [1, 10, 100],
+});
+
+function main({ n, observableCount }) {
+  // Create observable metrics
+  const subscriptions = {};
+  let counter = 0;
+
+  for (let i = 0; i < observableCount; i++) {
+    const name = `bench.observable.${i}`;
+    metrics.create(name, {
+      unit: 'count',
+      observable: (m) => { m.record(counter++); },
+    });
+    subscriptions[name] = { aggregation: 'lastValue' };
+  }
+
+  const consumer = metrics.createConsumer(subscriptions);
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    consumer.collect();
+  }
+  bench.end(n);
+
+  // Cleanup and avoid deadcode elimination
+  assert.ok(counter > 0);
+  consumer.close();
+}

benchmark/perf_hooks/metrics-record-attrs.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const assert = require('assert');
+const common = require('../common.js');
+
+const { metrics } = require('perf_hooks');
+
+const bench = common.createBenchmark(main, {
+  n: [1e7, 1e8],
+  attrCount: [0, 1, 5, 10],
+  attrCardinality: [1, 10, 100],
+});
+
+function main({ n, attrCount, attrCardinality }) {
+  const metric = metrics.create('bench.record.attrs', { unit: 'count' });
+
+  const consumer = metrics.createConsumer({
+    'bench.record.attrs': { aggregation: 'sum' },
+  });
+
+  // Pre-generate attribute objects with specified cardinality
+  const attributeSets = [];
+  for (let c = 0; c < attrCardinality; c++) {
+    const attrs = {};
+    for (let a = 0; a < attrCount; a++) {
+      attrs[`attr${a}`] = `value${c}`;
+    }
+    attributeSets.push(attrs);
+  }
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    const attrs = attrCount > 0 ? attributeSets[i % attrCardinality] : undefined;
+    metric.record(i, attrs);
+  }
+  bench.end(n);
+
+  // Cleanup and avoid deadcode elimination
+  assert.ok(consumer.collect());
+  consumer.close();
+}

benchmark/perf_hooks/metrics-record.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const assert = require('assert');
+const common = require('../common.js');
+
+const { metrics } = require('perf_hooks');
+
+const bench = common.createBenchmark(main, {
+  n: [1e7, 1e8],
+  consumerCount: [1, 5, 10],
+  aggregation: ['sum', 'lastValue', 'histogram'],
+});
+
+function main({ n, consumerCount, aggregation }) {
+  const metric = metrics.create('bench.record', { unit: 'count' });
+
+  // Create consumers with the specified aggregation
+  const consumers = [];
+  for (let i = 0; i < consumerCount; i++) {
+    consumers.push(metrics.createConsumer({
+      'bench.record': { aggregation },
+    }));
+  }
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    metric.record(i);
+  }
+  bench.end(n);
+
+  // Cleanup and avoid deadcode elimination
+  for (const consumer of consumers) {
+    assert.ok(consumer.collect());
+    consumer.close();
+  }
+}

benchmark/perf_hooks/metrics-timer.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const assert = require('assert');
+const common = require('../common.js');
+
+const { metrics } = require('perf_hooks');
+
+const bench = common.createBenchmark(main, {
+  n: [1e6, 1e7],
+  method: ['startStop', 'using'],
+  consumerCount: [1, 5],
+});
+
+function main({ n, method, consumerCount }) {
+  const metric = metrics.create('bench.timer', { unit: 'ms' });
+
+  // Create consumers
+  const consumers = [];
+  for (let i = 0; i < consumerCount; i++) {
+    consumers.push(metrics.createConsumer({
+      'bench.timer': { aggregation: 'sum' },
+    }));
+  }
+
+  bench.start();
+  if (method === 'startStop') {
+    // Manual start/stop
+    for (let i = 0; i < n; i++) {
+      const timer = metric.startTimer();
+      timer.stop();
+    }
+  } else {
+    // Using Symbol.dispose
+    for (let i = 0; i < n; i++) {
+      // eslint-disable-next-line no-unused-vars
+      using timer = metric.startTimer();
+    }
+  }
+  bench.end(n);
+
+  // Cleanup and avoid deadcode elimination
+  for (const consumer of consumers) {
+    assert.ok(consumer.collect());
+    consumer.close();
+  }
+}