@wardx/core 0.1.0

package/src/config/ExperimentResolver.js

@@ -0,0 +1,118 @@
+import { assignmentHash, hashToUnitInterval, subjectHash } from './hash.js';
+
+export function assignVariant(experiment, subjectId) {
+  if (!experiment.enabled) return null;
+  const hash = assignmentHash(experiment.id, subjectId, experiment.salt);
+  const bucket = hashToUnitInterval(hash);
+  if (bucket >= experiment.allocation) return null;
+  const variants = experiment.variants;
+  if (!Array.isArray(variants) || variants.length === 0) {
+    throw new Error(`experiment ${experiment.id} has no variants`);
+  }
+  let totalWeight = 0;
+  for (let i = 0; i < variants.length; i++) {
+    const weight = variants[i].weight;
+    if (typeof weight !== 'number' || !Number.isFinite(weight) || weight < 0) {
+      throw new Error(`experiment ${experiment.id} has invalid variant weight`);
+    }
+    totalWeight += weight;
+  }
+  if (totalWeight <= 0) {
+    throw new Error(`experiment ${experiment.id} variant weights must sum to > 0`);
+  }
+  let threshold = 0;
+  for (let i = 0; i < variants.length; i++) {
+    threshold += (variants[i].weight / totalWeight) * experiment.allocation;
+    if (bucket < threshold) return variants[i];
+  }
+  return variants[variants.length - 1];
+}
+
+export function indexExperimentsByKey(experiments) {
+  const map = new Map();
+  if (!Array.isArray(experiments)) return map;
+  for (const experiment of experiments) {
+    if (!experiment.enabled) continue;
+    for (const variant of experiment.variants) {
+      for (const key of Object.keys(variant.values)) {
+        let list = map.get(key);
+        if (!list) {
+          list = [];
+          map.set(key, list);
+        }
+        if (!list.includes(experiment)) list.push(experiment);
+      }
+    }
+  }
+  return map;
+}
+
+export class ExperimentResolver {
+  constructor(options) {
+    this.privacySalt = options.privacySalt;
+    this.onExposure = options.onExposure;
+    this.exposureKeys = new Set();
+    this.assignmentsBySubject = new Map();
+  }
+
+  hashSubject(subjectId) {
+    return subjectHash(this.privacySalt, subjectId);
+  }
+
+  recordAssignment(subjectId, experiment, variant) {
+    let list = this.assignmentsBySubject.get(subjectId);
+    if (!list) {
+      list = [];
+      this.assignmentsBySubject.set(subjectId, list);
+    }
+    for (let i = 0; i < list.length; i++) {
+      if (list[i].experiment === experiment.id) return;
+    }
+    list.push({ experiment: experiment.id, variant: variant.key });
+  }
+
+  assignmentsFor(subjectId) {
+    return this.assignmentsBySubject.get(subjectId) || [];
+  }
+
+  resolve(key, remoteValue, subjectId, experimentsByKey) {
+    if (subjectId === undefined || subjectId === null) return remoteValue;
+    const list = experimentsByKey.get(key);
+    if (!list) return remoteValue;
+    for (const experiment of list) {
+      const variant = assignVariant(experiment, subjectId);
+      if (!variant) continue;
+      if (!Object.prototype.hasOwnProperty.call(variant.values, key)) continue;
+      this.recordAssignment(subjectId, experiment, variant);
+      this._expose(experiment, variant, subjectId);
+      return variant.values[key];
+    }
+    return remoteValue;
+  }
+
+  _expose(experiment, variant, subjectId) {
+    const hashed = this.hashSubject(subjectId);
+    const exposureKey = experiment.id + '\0' + hashed;
+    if (this.exposureKeys.has(exposureKey)) return;
+    this.exposureKeys.add(exposureKey);
+    this.onExposure({
+      experiment: experiment.id,
+      variant: variant.key,
+      subject: hashed
+    });
+  }
+
+  relevantExperiments(subjectId, experiments) {
+    const known = this.assignmentsFor(subjectId);
+    if (known.length > 0) return known;
+    const attached = [];
+    if (!Array.isArray(experiments)) return attached;
+    for (const experiment of experiments) {
+      if (!experiment.enabled) continue;
+      const variant = assignVariant(experiment, subjectId);
+      if (!variant) continue;
+      attached.push({ experiment: experiment.id, variant: variant.key });
+    }
+    return attached;
+  }
+}

package/src/config/hash.js

@@ -0,0 +1,27 @@
+const encoder = new TextEncoder();
+
+export const FNV_OFFSET_32 = 0x811c9dc5;
+export const FNV_PRIME_32 = 0x01000193;
+export const UINT32 = 4294967296;
+
+export function fnv1a32(input) {
+  const bytes = typeof input === 'string' ? encoder.encode(input) : input;
+  let hash = FNV_OFFSET_32;
+  for (let i = 0; i < bytes.length; i++) {
+    hash ^= bytes[i];
+    hash = Math.imul(hash, FNV_PRIME_32) >>> 0;
+  }
+  return hash;
+}
+
+export function hashToUnitInterval(hash) {
+  return hash / UINT32;
+}
+
+export function assignmentHash(experimentId, subjectId, salt) {
+  return fnv1a32(`${experimentId}:${subjectId}:${salt}`);
+}
+
+export function subjectHash(projectSalt, subjectId) {
+  return (fnv1a32(`${projectSalt}:${subjectId}`) >>> 0).toString(16).padStart(8, '0');
+}

package/src/frame/FrameBuilder.js

@@ -0,0 +1,132 @@
+import { INTERNAL } from '../protocol.js';
+import { LOG_RANK } from '../protocol.js';
+
+function measure(frame) {
+  const json = JSON.stringify(frame);
+  return { json, bytes: Buffer.byteLength(json, 'utf8') };
+}
+
+function logDropOrder(logs) {
+  return logs
+    .map((_, index) => index)
+    .sort((a, b) => {
+      const rankA = LOG_RANK[logs[a][1]];
+      const rankB = LOG_RANK[logs[b][1]];
+      const aKey = rankA === undefined ? Infinity : rankA;
+      const bKey = rankB === undefined ? Infinity : rankB;
+      if (aKey !== bKey) return aKey - bKey;
+      return a - b;
+    });
+}
+
+function logsWithoutFirstK(logs, dropOrder, k) {
+  if (k <= 0) return logs;
+  if (k >= logs.length) return [];
+  const drop = new Set(dropOrder.slice(0, k));
+  return logs.filter((_, index) => !drop.has(index));
+}
+
+function leastDrops(maxDrop, fits) {
+  if (maxDrop === 0) return 0;
+  if (!fits(maxDrop)) return maxDrop;
+  let lo = 0;
+  let hi = maxDrop;
+  while (lo < hi) {
+    const mid = (lo + hi) >> 1;
+    if (fits(mid)) hi = mid;
+    else lo = mid + 1;
+  }
+  return lo;
+}
+
+function isInternalGauge(row) {
+  return typeof row[0] === 'string' && row[0].startsWith('wardx.internal.');
+}
+
+export class FrameBuilder {
+  static build({ seq, from, to, metrics, events, logs, internal }) {
+    const counters = metrics.counters.slice();
+    const gauges = metrics.gauges.slice();
+    const histograms = metrics.histograms.slice();
+    FrameBuilder.mergeInternal(counters, gauges, internal);
+    return {
+      seq,
+      from,
+      to,
+      metrics: {
+        counters,
+        gauges,
+        histograms
+      },
+      events,
+      logs
+    };
+  }
+
+  static mergeInternal(counters, gauges, internal) {
+    if (internal.eventsDropped) counters.push([INTERNAL.eventsDropped, null, internal.eventsDropped]);
+    if (internal.logsDropped) counters.push([INTERNAL.logsDropped, null, internal.logsDropped]);
+    if (internal.cardinalityDropped) {
+      counters.push([INTERNAL.cardinalityDropped, null, internal.cardinalityDropped]);
+    }
+    if (internal.framesSent) counters.push([INTERNAL.framesSent, null, internal.framesSent]);
+    if (internal.framesFailed) counters.push([INTERNAL.framesFailed, null, internal.framesFailed]);
+    if (internal.bytesUncompressed) {
+      counters.push([INTERNAL.bytesUncompressed, null, internal.bytesUncompressed]);
+    }
+    if (internal.bytesCompressed) {
+      counters.push([INTERNAL.bytesCompressed, null, internal.bytesCompressed]);
+    }
+    gauges.push([INTERNAL.eventsBuffered, null, internal.eventsBuffered, Date.now()]);
+    gauges.push([INTERNAL.logsBuffered, null, internal.logsBuffered, Date.now()]);
+    if (internal.lastSyncMs) {
+      gauges.push([INTERNAL.lastSyncMs, null, internal.lastSyncMs, Date.now()]);
+    }
+    gauges.push([INTERNAL.configVersion, null, internal.configVersion, Date.now()]);
+    if (internal.processRssBytes) {
+      gauges.push([INTERNAL.processRssBytes, null, internal.processRssBytes, Date.now()]);
+    }
+  }
+
+  static fitToMaxBytes(frame, maxFrameBytes) {
+    let { json, bytes } = measure(frame);
+    if (bytes <= maxFrameBytes) return { frame, json, droppedLogs: 0, droppedEvents: 0 };
+
+    let droppedLogs = 0;
+    let droppedEvents = 0;
+
+    if (frame.logs.length > 0) {
+      const dropOrder = logDropOrder(frame.logs);
+      const k = leastDrops(dropOrder.length, (mid) => {
+        const probe = { ...frame, logs: logsWithoutFirstK(frame.logs, dropOrder, mid) };
+        return measure(probe).bytes <= maxFrameBytes;
+      });
+      frame.logs = logsWithoutFirstK(frame.logs, dropOrder, k);
+      droppedLogs = k;
+      ({ json, bytes } = measure(frame));
+      if (bytes <= maxFrameBytes) return { frame, json, droppedLogs, droppedEvents };
+    }
+
+    if (frame.events.length > 0) {
+      const original = frame.events;
+      const k = leastDrops(original.length, (mid) => {
+        const probe = { ...frame, events: original.slice(0, original.length - mid) };
+        return measure(probe).bytes <= maxFrameBytes;
+      });
+      frame.events = original.slice(0, original.length - k);
+      droppedEvents = k;
+      ({ json, bytes } = measure(frame));
+      if (bytes <= maxFrameBytes) return { frame, json, droppedLogs, droppedEvents };
+    }
+
+    if (bytes > maxFrameBytes && frame.metrics.histograms.length > 0) {
+      frame.metrics.histograms = [];
+      ({ json, bytes } = measure(frame));
+    }
+    if (bytes > maxFrameBytes) {
+      frame.metrics.gauges = frame.metrics.gauges.filter(isInternalGauge);
+      ({ json } = measure(frame));
+    }
+    return { frame, json, droppedLogs, droppedEvents };
+  }
+}

package/src/ids.js

@@ -0,0 +1,30 @@
+import { randomBytes } from 'node:crypto';
+
+const ENCODING = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+
+export function ulid(now = Date.now()) {
+  const chars = new Array(26);
+  let time = now;
+  for (let i = 9; i >= 0; i--) {
+    chars[i] = ENCODING[time & 31];
+    time = Math.floor(time / 32);
+  }
+  const rand = randomBytes(10);
+  chars[10] = ENCODING[(rand[0] & 224) >> 5];
+  chars[11] = ENCODING[rand[0] & 31];
+  chars[12] = ENCODING[(rand[1] & 248) >> 3];
+  chars[13] = ENCODING[((rand[1] & 7) << 2) | ((rand[2] & 192) >> 6)];
+  chars[14] = ENCODING[(rand[2] & 62) >> 1];
+  chars[15] = ENCODING[((rand[2] & 1) << 4) | ((rand[3] & 240) >> 4)];
+  chars[16] = ENCODING[((rand[3] & 15) << 1) | ((rand[4] & 128) >> 7)];
+  chars[17] = ENCODING[(rand[4] & 124) >> 2];
+  chars[18] = ENCODING[((rand[4] & 3) << 3) | ((rand[5] & 224) >> 5)];
+  chars[19] = ENCODING[rand[5] & 31];
+  chars[20] = ENCODING[(rand[6] & 248) >> 3];
+  chars[21] = ENCODING[((rand[6] & 7) << 2) | ((rand[7] & 192) >> 6)];
+  chars[22] = ENCODING[(rand[7] & 62) >> 1];
+  chars[23] = ENCODING[((rand[7] & 1) << 4) | ((rand[8] & 240) >> 4)];
+  chars[24] = ENCODING[((rand[8] & 15) << 1) | ((rand[9] & 128) >> 7)];
+  chars[25] = ENCODING[(rand[9] & 124) >> 2];
+  return chars.join('');
+}

package/src/index.js

@@ -0,0 +1,14 @@
+export { PROTOCOL_VERSION, SDK_NAME, PLATFORM, INTERNAL } from './protocol.js';
+export { fnv1a32, assignmentHash, hashToUnitInterval, subjectHash } from './config/hash.js';
+export { assignVariant, ExperimentResolver } from './config/ExperimentResolver.js';
+export { ConfigStore } from './config/ConfigStore.js';
+export { Counter } from './metrics/Counter.js';
+export { Gauge } from './metrics/Gauge.js';
+export { Histogram } from './metrics/Histogram.js';
+export { MetricsRegistry } from './metrics/MetricsRegistry.js';
+export { EventBuffer } from './buffers/EventBuffer.js';
+export { LogBuffer } from './buffers/LogBuffer.js';
+export { FrameBuilder } from './frame/FrameBuilder.js';
+export { WardxCore } from './WardxCore.js';
+export { resolveSettings, loadSdkDefaults, nextSyncDelayMs } from './settings.js';
+export { ulid } from './ids.js';

package/src/internal/InternalMetrics.js

@@ -0,0 +1,53 @@
+export class InternalMetrics {
+  constructor() {
+    this.eventsDropped = 0;
+    this.logsDropped = 0;
+    this.cardinalityDropped = 0;
+    this.framesSent = 0;
+    this.framesFailed = 0;
+    this.bytesUncompressed = 0;
+    this.bytesCompressed = 0;
+    this.eventsBuffered = 0;
+    this.logsBuffered = 0;
+    this.lastSyncMs = 0;
+    this.configVersion = 0;
+    this.processRssBytes = 0;
+  }
+
+  hasCounterActivity() {
+    return (
+      this.eventsDropped !== 0 ||
+      this.logsDropped !== 0 ||
+      this.cardinalityDropped !== 0 ||
+      this.framesSent !== 0 ||
+      this.framesFailed !== 0 ||
+      this.bytesUncompressed !== 0 ||
+      this.bytesCompressed !== 0
+    );
+  }
+
+  snapshotAndReset() {
+    const snap = {
+      eventsDropped: this.eventsDropped,
+      logsDropped: this.logsDropped,
+      cardinalityDropped: this.cardinalityDropped,
+      framesSent: this.framesSent,
+      framesFailed: this.framesFailed,
+      bytesUncompressed: this.bytesUncompressed,
+      bytesCompressed: this.bytesCompressed,
+      eventsBuffered: this.eventsBuffered,
+      logsBuffered: this.logsBuffered,
+      lastSyncMs: this.lastSyncMs,
+      configVersion: this.configVersion,
+      processRssBytes: this.processRssBytes
+    };
+    this.eventsDropped = 0;
+    this.logsDropped = 0;
+    this.cardinalityDropped = 0;
+    this.framesSent = 0;
+    this.framesFailed = 0;
+    this.bytesUncompressed = 0;
+    this.bytesCompressed = 0;
+    return snap;
+  }
+}

package/src/metrics/Counter.js

@@ -0,0 +1,23 @@
+export class Counter {
+  constructor(name, dims) {
+    this.name = name;
+    this.dims = dims;
+    this.value = 0;
+  }
+
+  inc() {
+    this.value += 1;
+  }
+
+  add(n) {
+    if (typeof n !== 'number' || !Number.isFinite(n)) {
+      throw new Error('counter.add requires a finite number');
+    }
+    this.value += n;
+  }
+}
+
+export const NOOP_COUNTER = {
+  inc() {},
+  add() {}
+};

package/src/metrics/Gauge.js

@@ -0,0 +1,22 @@
+export class Gauge {
+  constructor(name, dims) {
+    this.name = name;
+    this.dims = dims;
+    this.value = 0;
+    this.timestamp = 0;
+    this.dirty = false;
+  }
+
+  set(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+      throw new Error('gauge.set requires a finite number');
+    }
+    this.value = value;
+    this.timestamp = Date.now();
+    this.dirty = true;
+  }
+}
+
+export const NOOP_GAUGE = {
+  set() {}
+};

package/src/metrics/Histogram.js

@@ -0,0 +1,85 @@
+import { validateDimensions } from './dimensions.js';
+
+export class Histogram {
+  constructor(name, dims, bounds, limits) {
+    this.name = name;
+    this.dims = dims;
+    this.bounds = bounds;
+    this.maxDimensionKeys = limits ? limits.maxDimensionKeys : null;
+    this.maxDimensionValueLength = limits ? limits.maxDimensionValueLength : null;
+    this.counts = new Array(bounds.length).fill(0);
+    this.count = 0;
+    this.sum = 0;
+    this.min = Infinity;
+    this.max = -Infinity;
+    this.exemplar = null;
+  }
+
+  observe(value, attrs) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+      throw new Error('histogram.observe requires a finite number');
+    }
+    const isMax = value >= this.max;
+    this.count += 1;
+    this.sum += value;
+    if (value < this.min) this.min = value;
+    if (isMax) {
+      this.max = value;
+      this.exemplar = this._exemplarFrom(value, attrs);
+    }
+    const bounds = this.bounds;
+    const counts = this.counts;
+    for (let i = 0; i < bounds.length; i++) {
+      if (value <= bounds[i]) {
+        counts[i] += 1;
+        return;
+      }
+    }
+  }
+
+  _exemplarFrom(value, attrs) {
+    if (attrs == null) return null;
+    if (
+      !Number.isInteger(this.maxDimensionKeys) ||
+      !Number.isInteger(this.maxDimensionValueLength)
+    ) {
+      throw new Error('histogram.observe attrs require dimension limits');
+    }
+    const checked = validateDimensions(
+      attrs,
+      this.maxDimensionKeys,
+      this.maxDimensionValueLength
+    );
+    if (!checked.ok || checked.dims == null) return null;
+    return { value, attrs: { ...checked.dims } };
+  }
+
+  snapshot() {
+    const buckets = new Array(this.bounds.length);
+    for (let i = 0; i < this.bounds.length; i++) {
+      buckets[i] = [this.bounds[i], this.counts[i]];
+    }
+    const body = {
+      count: this.count,
+      sum: this.sum,
+      min: this.min,
+      max: this.max,
+      buckets
+    };
+    if (this.exemplar) body.exemplar = this.exemplar;
+    return body;
+  }
+
+  reset() {
+    this.counts.fill(0);
+    this.count = 0;
+    this.sum = 0;
+    this.min = Infinity;
+    this.max = -Infinity;
+    this.exemplar = null;
+  }
+}
+
+export const NOOP_HISTOGRAM = {
+  observe() {}
+};

package/src/metrics/MetricsRegistry.js

@@ -0,0 +1,172 @@
+import { Counter, NOOP_COUNTER } from './Counter.js';
+import { Gauge, NOOP_GAUGE } from './Gauge.js';
+import { Histogram, NOOP_HISTOGRAM } from './Histogram.js';
+import { startTimer } from './Timer.js';
+import { assertMetricName, dimKey, validateDimensions } from './dimensions.js';
+
+function boundsEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+
+function parseHistogramArgs(a, b, defaultBuckets) {
+  let buckets = defaultBuckets;
+  let dims = null;
+  if (a != null) {
+    if (Object.prototype.hasOwnProperty.call(a, 'buckets')) {
+      buckets = a.buckets;
+      const rest = { ...a };
+      delete rest.buckets;
+      dims = Object.keys(rest).length > 0 ? rest : null;
+      if (b != null) dims = dims ? { ...dims, ...b } : b;
+    } else {
+      dims = a;
+      if (b != null && Object.prototype.hasOwnProperty.call(b, 'buckets')) {
+        buckets = b.buckets;
+      }
+    }
+  }
+  if (!Array.isArray(buckets) || buckets.length === 0) {
+    throw new Error('histogram buckets must be a non-empty array');
+  }
+  let prev = -Infinity;
+  for (const bound of buckets) {
+    if (typeof bound !== 'number' || !Number.isFinite(bound) || bound <= prev) {
+      throw new Error('histogram buckets must be strictly increasing finite numbers');
+    }
+    prev = bound;
+  }
+  return { buckets, dims };
+}
+
+export class MetricsRegistry {
+  constructor(options) {
+    this.maxSeriesPerMetric = options.maxSeriesPerMetric;
+    this.maxDimensionKeys = options.maxDimensionKeys;
+    this.maxDimensionValueLength = options.maxDimensionValueLength;
+    this.defaultHistogramBuckets = options.defaultHistogramBuckets;
+    this.onCardinalityDropped = options.onCardinalityDropped;
+    this.countersByName = new Map();
+    this.gaugesByName = new Map();
+    this.histogramsByName = new Map();
+    this.rejected = new Set();
+  }
+
+  _series(kindMap, Ctor, name, dims, extra) {
+    assertMetricName(name);
+    const kindPrefix = kindMap === this.histogramsByName ? 'h' : kindMap === this.gaugesByName ? 'g' : 'c';
+    const checked = validateDimensions(dims, this.maxDimensionKeys, this.maxDimensionValueLength);
+    const key = dimKey(checked.ok ? checked.dims : dims);
+    const rejectKey = kindPrefix + '\0' + name + '\0' + key;
+    if (this.rejected.has(rejectKey)) return null;
+    if (!checked.ok) {
+      this.rejected.add(rejectKey);
+      this.onCardinalityDropped();
+      return null;
+    }
+    let byKey = kindMap.get(name);
+    if (!byKey) {
+      byKey = new Map();
+      kindMap.set(name, byKey);
+    }
+    let series = byKey.get(key);
+    if (series) return series;
+    if (byKey.size >= this.maxSeriesPerMetric) {
+      this.rejected.add(rejectKey);
+      this.onCardinalityDropped();
+      return null;
+    }
+    series = extra ? extra(checked.dims) : new Ctor(name, checked.dims);
+    byKey.set(key, series);
+    return series;
+  }
+
+  counter(name, dims) {
+    const series = this._series(this.countersByName, Counter, name, dims);
+    return series || NOOP_COUNTER;
+  }
+
+  gauge(name, dims) {
+    const series = this._series(this.gaugesByName, Gauge, name, dims);
+    return series || NOOP_GAUGE;
+  }
+
+  histogram(name, a, b) {
+    const { buckets, dims } = parseHistogramArgs(a, b, this.defaultHistogramBuckets);
+    const series = this._series(this.histogramsByName, Histogram, name, dims, (resolvedDims) => {
+      return new Histogram(name, resolvedDims, buckets, {
+        maxDimensionKeys: this.maxDimensionKeys,
+        maxDimensionValueLength: this.maxDimensionValueLength
+      });
+    });
+    if (!series) return NOOP_HISTOGRAM;
+    if (!boundsEqual(series.bounds, buckets)) {
+      throw new Error(`histogram ${name} buckets cannot change for an existing series`);
+    }
+    return series;
+  }
+
+  timer(name, dims) {
+    const histogram = this.histogram(name, dims);
+    return startTimer((duration, endDims) => {
+      if (endDims) {
+        this.histogram(name, { ...(dims || {}), ...endDims }).observe(duration);
+        return;
+      }
+      histogram.observe(duration);
+    });
+  }
+
+  snapshotAndReset() {
+    const counters = [];
+    for (const byKey of this.countersByName.values()) {
+      for (const series of byKey.values()) {
+        if (series.value !== 0) {
+          counters.push([series.name, series.dims, series.value]);
+          series.value = 0;
+        }
+      }
+    }
+    const gauges = [];
+    for (const byKey of this.gaugesByName.values()) {
+      for (const series of byKey.values()) {
+        if (series.dirty) {
+          gauges.push([series.name, series.dims, series.value, series.timestamp]);
+          series.dirty = false;
+        }
+      }
+    }
+    const histograms = [];
+    for (const byKey of this.histogramsByName.values()) {
+      for (const series of byKey.values()) {
+        if (series.count > 0) {
+          histograms.push([series.name, series.dims, series.snapshot()]);
+          series.reset();
+        }
+      }
+    }
+    return { counters, gauges, histograms };
+  }
+
+  isDirty() {
+    for (const byKey of this.countersByName.values()) {
+      for (const series of byKey.values()) {
+        if (series.value !== 0) return true;
+      }
+    }
+    for (const byKey of this.gaugesByName.values()) {
+      for (const series of byKey.values()) {
+        if (series.dirty) return true;
+      }
+    }
+    for (const byKey of this.histogramsByName.values()) {
+      for (const series of byKey.values()) {
+        if (series.count > 0) return true;
+      }
+    }
+    return false;
+  }
+}

package/src/metrics/Timer.js

@@ -0,0 +1,6 @@
+export function startTimer(observe) {
+  const start = performance.now();
+  return function endTimer(dims) {
+    observe(performance.now() - start, dims);
+  };
+}