@decocms/blocks 7.63.0 → 7.63.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/blocks",
-  "version": "7.63.0",
+  "version": "7.63.1",
   "type": "module",
   "engines": {
     "node": ">=24"

package/src/middleware/observability.ts

@@ -283,8 +283,7 @@ export const MetricNames = {
   // the metric name already provides the deco.cache.* namespace.
   CACHE_REQUESTS: "deco.cache.requests",
   // Size in bytes of the values moving through a cache, dimensioned by `op`.
-  // Exponential (base-2) aggregation — see METRIC_METADATA for the scale and
-  // why an explicit-bounds histogram is the wrong shape here.
+  // Bucketed in decades of bytes — see CACHE_SIZE_BUCKET_BOUNDARIES_BYTES.
   CACHE_SIZE: "deco.cache.size",
   RESOLVE_DURATION: "deco.cms.resolve.duration",
   LOADER_DURATION: "deco.loader.duration",
@@ -327,6 +326,29 @@ export const DURATION_BUCKET_BOUNDARIES_SECONDS: readonly number[] = [
   10,
 ];
 
+/**
+ * Bucket boundaries, in BYTES, for {@link MetricNames.CACHE_SIZE}.
+ *
+ * Decades, matching the `http.server.response.body.size` histogram already
+ * flowing through the same ingestor — a size distribution is read in orders of
+ * magnitude, not in linear steps, and reusing the house convention means the
+ * two byte histograms are directly comparable.
+ *
+ * The range is bounded on both ends by the loader cache itself: entries are
+ * floored at `MIN_ENTRY_BYTES` (512 B) and the store is capped at 32 MB, which
+ * is why the last bound is the cap rather than another decade — the top bucket
+ * then reads as "single entry at/near the whole cache budget", which is the
+ * thing worth alerting on.
+ */
+export const CACHE_SIZE_BUCKET_BOUNDARIES_BYTES: readonly number[] = [
+  1_000,
+  10_000,
+  100_000,
+  1_000_000,
+  10_000_000,
+  33_554_432,
+];
+
 /**
  * Per-metric metadata emitted in the OTLP payload's `description` and
  * `unit` fields. Durations are normalized to **seconds at the source** (OTel
@@ -347,16 +369,6 @@ export const METRIC_METADATA: Record<
     description: string;
     unit: string;
     boundaries?: readonly number[];
-    /**
-     * Histogram aggregation. Omitted means `"explicit"` — bucket into
-     * `boundaries`. `"exponential"` selects an OTel base-2 exponential
-     * histogram at {@link scale}, where bucket `i` covers
-     * `(2^(2^-scale))^i .. ^(i+1)]`. Adapters that don't implement it are free
-     * to keep treating the metric as an ordinary histogram.
-     */
-    aggregation?: "explicit" | "exponential";
-    /** Exponential-histogram scale. Fixed per metric; adapters never rescale. */
-    scale?: number;
   }
 > = {
   [MetricNames.HTTP_SERVER_REQUEST_DURATION]: {
@@ -376,15 +388,7 @@ export const METRIC_METADATA: Record<
   [MetricNames.CACHE_SIZE]: {
     description: "Size in bytes of values written to / read from a cache, dimensioned by op.",
     unit: "By",
-    // Exponential rather than explicit bounds: entries span 512 B (the
-    // cachedLoader floor) to the 32 MB cap — five decades. Any fixed bound set
-    // wide enough for the top is useless at the bottom.
-    aggregation: "exponential",
-    // scale -1 => base 4, so buckets land on 512 B · 2 K · 8 K · 32 K · 128 K ·
-    // 512 K · 2 M · 8 M · 32 M: ~9 buckets over the real range, ~1.7 per
-    // decade. scale 0 (base 2) would double the series count without saying
-    // anything new about a size distribution.
-    scale: -1,
+    boundaries: CACHE_SIZE_BUCKET_BOUNDARIES_BYTES,
   },
   [MetricNames.RESOLVE_DURATION]: {
     description: "Duration of `deco.cms.resolvePage` — CMS route to block tree resolution.",

package/src/sdk/otelHttpMeter.test.ts

@@ -65,12 +65,7 @@ function buildAdapter(
     histogramBounds?: number[];
     metricMetadata?: Record<
       string,
-      {
-        description?: string;
-        unit?: string;
-        aggregation?: "explicit" | "exponential";
-        scale?: number;
-      }
+      { description?: string; unit?: string; boundaries?: readonly number[] }
     >;
   } = {},
 ) {
@@ -302,46 +297,34 @@ describe("createOtlpHttpMeterAdapter — buffer + flush", () => {
 });
 
 // ---------------------------------------------------------------------------
-// Exponential histograms (deco.cache.size)
+// Per-metric bucket boundaries
 // ---------------------------------------------------------------------------
 
-interface ExpHistogramMetric {
+interface HistoMetric {
   name: string;
   unit?: string;
-  histogram?: unknown;
-  exponentialHistogram?: {
-    aggregationTemporality: number;
+  histogram?: {
     dataPoints: Array<{
       attributes: Array<{ key: string; value: Record<string, unknown> }>;
       count: string;
       sum: number;
-      min: number;
-      max: number;
-      scale: number;
-      zeroCount: string;
-      positive: { offset: number; bucketCounts: string[] };
+      bucketCounts: string[];
+      explicitBounds: number[];
     }>;
   };
 }
 
-function metricsFrom(calls: Array<{ init?: RequestInit }>): ExpHistogramMetric[] {
+function histoMetrics(calls: Array<{ init?: RequestInit }>): HistoMetric[] {
   const payload = JSON.parse(calls[0].init!.body as string) as {
-    resourceMetrics: Array<{ scopeMetrics: Array<{ metrics: ExpHistogramMetric[] }> }>;
+    resourceMetrics: Array<{ scopeMetrics: Array<{ metrics: HistoMetric[] }> }>;
   };
   return payload.resourceMetrics[0].scopeMetrics[0].metrics;
 }
 
-const CACHE_SIZE_META = {
-  "deco.cache.size": {
-    description: "Size in bytes of values written to / read from a cache, dimensioned by op.",
-    unit: "By",
-    aggregation: "exponential" as const,
-    // base 4 — the scale the framework declares for byte sizes.
-    scale: -1,
-  },
-};
-
-describe("createOtlpHttpMeterAdapter — exponential histogram", () => {
+// Decades of bytes, mirroring CACHE_SIZE_BUCKET_BOUNDARIES_BYTES.
+const BYTE_BOUNDS = [1_000, 10_000, 100_000, 1_000_000, 10_000_000, 33_554_432];
+
+describe("createOtlpHttpMeterAdapter — per-metric bucket boundaries", () => {
   beforeEach(() => {
     vi.useFakeTimers();
     vi.setSystemTime(new Date("2026-05-18T16:00:00.000Z"));
@@ -352,114 +335,61 @@ describe("createOtlpHttpMeterAdapter — exponential histogram", () => {
     vi.restoreAllMocks();
   });
 
-  it("buckets byte sizes at scale -1 and exports OTLP exponentialHistogram", async () => {
+  it("buckets a metric against its own boundaries, not the adapter default", async () => {
     const { impl, calls } = captureFetch();
-    const meter = buildAdapter({ fetchImpl: impl, metricMetadata: CACHE_SIZE_META });
+    const meter = buildAdapter({
+      fetchImpl: impl,
+      // The ms-tuned adapter default: every byte value would saturate its
+      // overflow bucket, which is the regression this test pins.
+      histogramBounds: [5, 10, 25, 50, 75, 100, 250, 500, 1000],
+      metricMetadata: { "deco.cache.size": { unit: "By", boundaries: BYTE_BOUNDS } },
+    });
 
-    // base 4. Bucket i covers (4^i, 4^(i+1)], upper-inclusive:
-    //   512  -> index 4  (256, 1024]
-    //   1024 -> index 4  (256, 1024]  — exact power of the base stays LOW
-    //   4096 -> index 5  (1024, 4096]
     const labels = { op: "set", profile: "productList" };
-    meter.histogramRecord("deco.cache.size", 512, labels);
-    meter.histogramRecord("deco.cache.size", 1024, labels);
-    meter.histogramRecord("deco.cache.size", 4096, labels);
+    meter.histogramRecord("deco.cache.size", 512, labels); // bucket 0  (<= 1k)
+    meter.histogramRecord("deco.cache.size", 50_000, labels); // bucket 2  (<= 100k)
+    meter.histogramRecord("deco.cache.size", 50_000_000, labels); // overflow (> 32M)
 
     await meter.flush();
 
-    const m = metricsFrom(calls)[0];
-    expect(m.name).toBe("deco.cache.size");
-    expect(m.unit).toBe("By");
-    // Must NOT be serialized as an explicit-bounds histogram.
-    expect(m.histogram).toBeUndefined();
-
-    const dp = m.exponentialHistogram!.dataPoints[0];
-    expect(m.exponentialHistogram!.aggregationTemporality).toBe(2); // CUMULATIVE
-    expect(dp.scale).toBe(-1);
+    const dp = histoMetrics(calls)[0].histogram!.dataPoints[0];
+    expect(dp.explicitBounds).toEqual(BYTE_BOUNDS);
+    expect(dp.bucketCounts).toEqual(["1", "0", "1", "0", "0", "0", "1"]);
     expect(dp.count).toBe("3");
-    expect(dp.sum).toBe(512 + 1024 + 4096);
-    expect(dp.min).toBe(512);
-    expect(dp.max).toBe(4096);
-    expect(dp.zeroCount).toBe("0");
-    // offset is the index of bucketCounts[0]; two counts in bucket 4, one in 5.
-    expect(dp.positive.offset).toBe(4);
-    expect(dp.positive.bucketCounts).toEqual(["2", "1"]);
-    expect(dp.attributes.map((a) => a.key)).toEqual(["op", "profile"]);
   });
 
-  it("fills gaps between populated buckets so offset+i stays aligned", async () => {
+  it("emits the bounds the counts were filed against, per metric, in one flush", async () => {
     const { impl, calls } = captureFetch();
-    const meter = buildAdapter({ fetchImpl: impl, metricMetadata: CACHE_SIZE_META });
-
-    // 512 -> index 4, 32 MB -> index 12. Everything between must be zero-filled,
-    // otherwise the consumer reads the top bucket at the wrong boundary.
-    meter.histogramRecord("deco.cache.size", 512, { op: "set" });
-    meter.histogramRecord("deco.cache.size", 32 * 1024 * 1024, { op: "set" });
-
-    await meter.flush();
-
-    const dp = metricsFrom(calls)[0].exponentialHistogram!.dataPoints[0];
-    expect(dp.positive.offset).toBe(4);
-    expect(dp.positive.bucketCounts).toEqual(["1", "0", "0", "0", "0", "0", "0", "0", "1"]);
-  });
-
-  it("splits series per attr-key, like the explicit histogram does", async () => {
-    const { impl, calls } = captureFetch();
-    const meter = buildAdapter({ fetchImpl: impl, metricMetadata: CACHE_SIZE_META });
-
-    meter.histogramRecord("deco.cache.size", 512, { op: "set", profile: "a" });
-    meter.histogramRecord("deco.cache.size", 512, { op: "set", profile: "b" });
-
-    await meter.flush();
-
-    expect(metricsFrom(calls)[0].exponentialHistogram!.dataPoints).toHaveLength(2);
-    expect(meter.pendingDatapointCount()).toBe(2);
-  });
-
-  it("folds non-positive observations into zeroCount instead of a bucket", async () => {
-    const { impl, calls } = captureFetch();
-    const meter = buildAdapter({ fetchImpl: impl, metricMetadata: CACHE_SIZE_META });
+    const meter = buildAdapter({
+      fetchImpl: impl,
+      histogramBounds: [5, 10, 25],
+      metricMetadata: { "deco.cache.size": { unit: "By", boundaries: BYTE_BOUNDS } },
+    });
 
-    meter.histogramRecord("deco.cache.size", 0, { op: "set" });
+    // Two histograms with different units in the SAME adapter — the bug was
+    // that both serialized with one shared array.
     meter.histogramRecord("deco.cache.size", 512, { op: "set" });
+    meter.histogramRecord("deco.loader.duration", 7, { name: "x" });
 
     await meter.flush();
 
-    const dp = metricsFrom(calls)[0].exponentialHistogram!.dataPoints[0];
-    expect(dp.zeroCount).toBe("1");
-    expect(dp.count).toBe("2");
-    expect(dp.positive.bucketCounts).toEqual(["1"]);
+    const byName = Object.fromEntries(histoMetrics(calls).map((m) => [m.name, m]));
+    expect(byName["deco.cache.size"].histogram!.dataPoints[0].explicitBounds).toEqual(BYTE_BOUNDS);
+    expect(byName["deco.loader.duration"].histogram!.dataPoints[0].explicitBounds).toEqual([
+      5, 10, 25,
+    ]);
   });
 
-  it("leaves histograms without exponential metadata on the explicit-bounds path", async () => {
+  it("falls back to the adapter default when a metric declares no boundaries", async () => {
     const { impl, calls } = captureFetch();
-    const meter = buildAdapter({
-      fetchImpl: impl,
-      histogramBounds: [10, 100],
-      metricMetadata: CACHE_SIZE_META,
-    });
+    const meter = buildAdapter({ fetchImpl: impl, histogramBounds: [10, 100] });
 
     meter.histogramRecord("deco.loader.duration", 50, { name: "x" });
 
     await meter.flush();
 
-    const m = metricsFrom(calls)[0] as ExpHistogramMetric & {
-      histogram?: { dataPoints: Array<{ bucketCounts: string[]; explicitBounds: number[] }> };
-    };
-    expect(m.exponentialHistogram).toBeUndefined();
-    expect(m.histogram!.dataPoints[0].explicitBounds).toEqual([10, 100]);
-    expect(m.histogram!.dataPoints[0].bucketCounts).toEqual(["0", "1", "0"]);
-  });
-
-  it("rejects reusing an exponential-histogram name as a counter", async () => {
-    const onError = vi.fn();
-    const { impl } = captureFetch();
-    const meter = buildAdapter({ fetchImpl: impl, metricMetadata: CACHE_SIZE_META, onError });
-
-    meter.histogramRecord("deco.cache.size", 512, { op: "set" });
-    meter.counterInc("deco.cache.size", 1, { op: "set" });
-
-    expect(onError).toHaveBeenCalledWith("kind-mismatch", expect.any(Error));
-    expect(meter.pendingDatapointCount()).toBe(1);
+    const dp = histoMetrics(calls)[0].histogram!.dataPoints[0];
+    expect(dp.explicitBounds).toEqual([10, 100]);
+    expect(dp.bucketCounts).toEqual(["0", "1", "0"]);
   });
 });

package/src/sdk/otelHttpMeter.ts

@@ -85,9 +85,10 @@ export interface OtlpHttpMeterOptions {
    * record time. See `MetricNames` / `METRIC_METADATA` in
    * `middleware/observability.ts`.
    *
-   * `aggregation: "exponential"` also routes `histogramRecord` for that name
-   * to a base-2 exponential histogram at `scale` — no separate adapter method,
-   * so call sites are identical for both aggregations.
+   * `boundaries`, when present, is ALSO used to bucket that metric, overriding
+   * the adapter-wide `histogramBounds`. Without this a byte-sized histogram and
+   * a seconds-valued one would share the single ms-tuned default and both read
+   * back as a single saturated bucket.
    */
   metricMetadata?: Record<string, MetricMetadata>;
 }
@@ -95,8 +96,8 @@ export interface OtlpHttpMeterOptions {
 export interface MetricMetadata {
   description?: string;
   unit?: string;
-  aggregation?: "explicit" | "exponential";
-  scale?: number;
+  /** Explicit bucket bounds for THIS metric, in the metric's own unit. */
+  boundaries?: readonly number[];
 }
 
 export interface OtlpHttpMeter extends MeterAdapter {
@@ -114,7 +115,7 @@ export interface OtlpHttpMeter extends MeterAdapter {
 // Internal buffer shapes
 // ---------------------------------------------------------------------------
 
-type MetricKind = "counter" | "gauge" | "histogram" | "expHistogram";
+type MetricKind = "counter" | "gauge" | "histogram";
 
 interface CounterPoint {
   value: number;
@@ -136,26 +137,18 @@ interface HistogramPoint {
   startTimeUnixNano: string;
 }
 
-interface ExpHistogramPoint {
-  count: number;
-  sum: number;
-  min: number;
-  max: number;
-  zeroCount: number;
-  /** Sparse index -> count. Densified to `positive.bucketCounts` at flush. */
-  buckets: Map<number, number>;
-  attrs: Labels;
-  startTimeUnixNano: string;
-}
-
 interface MetricEntry {
   kind: MetricKind;
   counter?: Map<string, CounterPoint>;
   gauge?: Map<string, GaugePoint>;
   histogram?: Map<string, HistogramPoint>;
-  expHistogram?: Map<string, ExpHistogramPoint>;
-  /** Only set for `expHistogram`, captured from metadata at first record. */
-  scale?: number;
+  /**
+   * Bounds this metric is bucketed with — resolved once from the metric's own
+   * `boundaries` metadata, falling back to the adapter-wide default. Held on
+   * the entry so `serializeOtlp` emits the bounds the counts were actually
+   * filed against; emitting a different array silently mislabels every bucket.
+   */
+  bounds?: readonly number[];
 }
 
 // ---------------------------------------------------------------------------
@@ -169,18 +162,6 @@ const DEFAULT_HISTOGRAM_BOUNDS = [
   5, 10, 25, 50, 75, 100, 250, 500, 1000,
 ];
 
-/** Fallback scale when a metric declares `exponential` without one: base 2. */
-const DEFAULT_EXPONENTIAL_SCALE = 0;
-
-/**
- * Defensive cap on distinct buckets per exponential series. At the scales we
- * use (base 4 for byte sizes) the real range needs ~9, so hitting this means
- * the metric is being fed values it wasn't sized for. Rather than let the
- * sparse Map grow unbounded per isolate, clamp out-of-range indices into the
- * edge buckets — the distribution's tails stay visible, the memory doesn't.
- */
-const MAX_EXPONENTIAL_BUCKETS = 160;
-
 export function createOtlpHttpMeterAdapter(options: OtlpHttpMeterOptions): OtlpHttpMeter {
   const endpoint = options.endpoint;
   const resourceAttributes = options.resourceAttributes;
@@ -244,7 +225,6 @@ export function createOtlpHttpMeterAdapter(options: OtlpHttpMeterOptions): OtlpH
     const entry: MetricEntry = { kind };
     if (kind === "counter") entry.counter = new Map();
     else if (kind === "gauge") entry.gauge = new Map();
-    else if (kind === "expHistogram") entry.expHistogram = new Map();
     else entry.histogram = new Map();
     metrics.set(name, entry);
     return entry;
@@ -256,7 +236,6 @@ export function createOtlpHttpMeterAdapter(options: OtlpHttpMeterOptions): OtlpH
       if (entry.counter) n += entry.counter.size;
       if (entry.gauge) n += entry.gauge.size;
       if (entry.histogram) n += entry.histogram.size;
-      if (entry.expHistogram) n += entry.expHistogram.size;
     }
     return n;
   }
@@ -303,10 +282,6 @@ export function createOtlpHttpMeterAdapter(options: OtlpHttpMeterOptions): OtlpH
   }
 
   function histogramRecord(name: string, value: number, labels?: Labels) {
-    if (metricMetadata[name]?.aggregation === "exponential") {
-      expHistogramRecord(name, value, labels);
-      return;
-    }
     const { entry: existing, isNewName } = checkAdmissibility(name, "histogram");
     if (existing === null && !isNewName) return; // kind mismatch
     const key = attrKey(labels);
@@ -317,6 +292,8 @@ export function createOtlpHttpMeterAdapter(options: OtlpHttpMeterOptions): OtlpH
     }
     const entry = existing ?? materializeEntry(name, "histogram");
     if (!entry.histogram) return;
+    const bounds = entry.bounds ?? metricMetadata[name]?.boundaries ?? histogramBounds;
+    entry.bounds = bounds;
     let point = entry.histogram.get(key);
     if (!point) {
       point = {
@@ -324,7 +301,7 @@ export function createOtlpHttpMeterAdapter(options: OtlpHttpMeterOptions): OtlpH
         sum: 0,
         min: Number.POSITIVE_INFINITY,
         max: Number.NEGATIVE_INFINITY,
-        bucketCounts: new Array(histogramBounds.length + 1).fill(0),
+        bucketCounts: new Array(bounds.length + 1).fill(0),
         attrs: labels ? { ...labels } : {},
         startTimeUnixNano: msToNs(isolateStartMs),
       };
@@ -334,10 +311,10 @@ export function createOtlpHttpMeterAdapter(options: OtlpHttpMeterOptions): OtlpH
     point.sum += value;
     if (value < point.min) point.min = value;
     if (value > point.max) point.max = value;
-    // Locate bucket. histogramBounds is small (<=20); linear scan is fine.
-    let bucketIdx = histogramBounds.length;
-    for (let i = 0; i < histogramBounds.length; i++) {
-      if (value <= histogramBounds[i]) {
+    // Locate bucket. bounds is small (<=20); linear scan is fine.
+    let bucketIdx = bounds.length;
+    for (let i = 0; i < bounds.length; i++) {
+      if (value <= bounds[i]) {
         bucketIdx = i;
         break;
       }
@@ -345,61 +322,6 @@ export function createOtlpHttpMeterAdapter(options: OtlpHttpMeterOptions): OtlpH
     point.bucketCounts[bucketIdx] += 1;
   }
 
-  function expHistogramRecord(name: string, value: number, labels?: Labels) {
-    const { entry: existing, isNewName } = checkAdmissibility(name, "expHistogram");
-    if (existing === null && !isNewName) return; // kind mismatch
-    const key = attrKey(labels);
-    const isNewDatapoint = !existing?.expHistogram?.has(key);
-    if (isNewDatapoint && pendingDatapointCount() >= maxBuffer) {
-      onError?.("overflow", new Error(`metric buffer at cap (${maxBuffer}) — dropping "${name}"`));
-      return;
-    }
-    const entry = existing ?? materializeEntry(name, "expHistogram");
-    if (!entry.expHistogram) return;
-    const scale = metricMetadata[name]?.scale ?? DEFAULT_EXPONENTIAL_SCALE;
-    entry.scale = scale;
-    let point = entry.expHistogram.get(key);
-    if (!point) {
-      point = {
-        count: 0,
-        sum: 0,
-        min: Number.POSITIVE_INFINITY,
-        max: Number.NEGATIVE_INFINITY,
-        zeroCount: 0,
-        buckets: new Map(),
-        attrs: labels ? { ...labels } : {},
-        startTimeUnixNano: msToNs(isolateStartMs),
-      };
-      entry.expHistogram.set(key, point);
-    }
-    point.count += 1;
-    point.sum += value;
-    if (value < point.min) point.min = value;
-    if (value > point.max) point.max = value;
-
-    // Non-positive values have no base-2 bucket. Per the OTel spec zero goes to
-    // `zeroCount`; we send negatives there too rather than emit a `negative`
-    // range no metric of ours can produce.
-    if (value <= 0) {
-      point.zeroCount += 1;
-      return;
-    }
-
-    // Spec mapping for base 2^(2^-scale): bucket `i` covers (base^i, base^(i+1)],
-    // i.e. upper-inclusive, so an exact power of the base lands in the LOWER
-    // bucket. Hence ceil(...) - 1 and not floor(...).
-    let index = Math.ceil(Math.log2(value) * 2 ** scale) - 1;
-    // Clamp into the existing range once the series is at its bucket budget —
-    // see MAX_EXPONENTIAL_BUCKETS.
-    if (!point.buckets.has(index) && point.buckets.size >= MAX_EXPONENTIAL_BUCKETS) {
-      const indices = [...point.buckets.keys()];
-      const lo = Math.min(...indices);
-      const hi = Math.max(...indices);
-      index = index < lo ? lo : hi;
-    }
-    point.buckets.set(index, (point.buckets.get(index) ?? 0) + 1);
-  }
-
   async function doFlush(): Promise<void> {
     if (metrics.size === 0) return;
 
@@ -569,7 +491,9 @@ function serializeOtlp(
           min: point.min === Number.POSITIVE_INFINITY ? 0 : point.min,
           max: point.max === Number.NEGATIVE_INFINITY ? 0 : point.max,
           bucketCounts: point.bucketCounts.map((c) => String(c)),
-          explicitBounds: opts.histogramBounds,
+          // Must be the array the counts were bucketed against, not the
+          // adapter-wide default — see MetricEntry.bounds.
+          explicitBounds: entry.bounds ?? opts.histogramBounds,
         });
       }
       otlpMetrics.push({
@@ -581,44 +505,6 @@ function serializeOtlp(
           dataPoints,
         },
       });
-    } else if (entry.kind === "expHistogram" && entry.expHistogram) {
-      const dataPoints: unknown[] = [];
-      for (const point of entry.expHistogram.values()) {
-        // Densify the sparse index->count map into OTLP's
-        // `positive: { offset, bucketCounts }`: counts run contiguously from
-        // `offset`, so gaps between populated indices must be filled with 0.
-        const indices = [...point.buckets.keys()].sort((a, b) => a - b);
-        const lo = indices[0] ?? 0;
-        const hi = indices[indices.length - 1] ?? -1;
-        const bucketCounts: string[] = [];
-        for (let i = lo; i <= hi; i++) bucketCounts.push(String(point.buckets.get(i) ?? 0));
-        dataPoints.push({
-          attributes: attrsToOtlp(point.attrs),
-          startTimeUnixNano: point.startTimeUnixNano,
-          timeUnixNano: opts.flushAtNs,
-          count: String(point.count),
-          sum: point.sum,
-          min: point.min === Number.POSITIVE_INFINITY ? 0 : point.min,
-          max: point.max === Number.NEGATIVE_INFINITY ? 0 : point.max,
-          scale: entry.scale ?? 0,
-          zeroCount: String(point.zeroCount),
-          // OTLP: bucketCounts[i] counts values in
-          // (base^(offset+i), base^(offset+i+1)] — the same half-open interval
-          // our record-time index uses, so offset is the first index as-is.
-          positive: { offset: lo, bucketCounts },
-          // No `negative` range: every metric on this path is non-negative,
-          // and sub-zero observations are folded into zeroCount at record time.
-        });
-      }
-      otlpMetrics.push({
-        name,
-        description,
-        unit,
-        exponentialHistogram: {
-          aggregationTemporality: 2, // CUMULATIVE
-          dataPoints,
-        },
-      });
     }
   }