@decocms/blocks 7.63.0 → 7.64.0

package/src/sdk/fetchCache.ts

@@ -1,5 +1,5 @@
 /**
- * Shared SWR in-memory fetch cache for commerce API responses.
+ * Shared SWR fetch cache for commerce API responses.
  *
  * Provides in-flight deduplication + stale-while-revalidate + stale-if-error
  * for server-side GET requests, keyed by full URL string. Ported from the
@@ -17,8 +17,8 @@
  * tests), so there is zero cost off the instrumented path.
  *
  * **Provider isolation:** every {@link createFetchCache} call owns its own
- * `store`/`inflight` Maps, so VTEX / Magento / Shopify caches never collide in
- * a shared isolate. The `provider` string rides on the `provider` metric label so
+ * bounded memory tier and in-flight Map. Shared storage keys include the
+ * provider name, so VTEX / Magento / Shopify entries never collide. The `provider` string rides on the `provider` metric label so
  * dashboards can slice hit ratio per backend.
  *
  * Note on why the SWR cache — not `createInstrumentedFetch` — must emit the
@@ -28,6 +28,7 @@
  */
 
 import { type CacheDecision, recordCacheMetric } from "../middleware/observability";
+import { cacheBackground, createCacheStore, getCacheStorageContext } from "./cacheStorage";
 
 /** Fresh-TTL (ms) by HTTP status class. See {@link FetchCacheConfig}. */
 export interface FreshTtlByStatus {
@@ -129,7 +130,7 @@ function withTimeout<T>(work: Promise<T>, ms: number, label: string): Promise<T>
 export function createFetchCache(config: FetchCacheConfig): FetchCache {
   const { provider, maxEntries, freshTtlMs, staleIfErrorMs, inflightBackstopMs } = config;
 
-  const store = new Map<string, CacheEntry>();
+  const store = createCacheStore<CacheEntry>(`fetch:${provider}`, maxEntries);
   const inflight = new Map<string, Promise<CacheEntry>>();
 
   function freshTtlForStatus(status: number): number {
@@ -139,12 +140,6 @@ export function createFetchCache(config: FetchCacheConfig): FetchCache {
     return 0;
   }
 
-  function evictIfNeeded() {
-    // ponytail: Map preserves insertion order ≈ createdAt order — holds as long
-    // as updates always re-insert via store.set(key, fresh), never mutate in-place.
-    while (store.size > maxEntries) store.delete(store.keys().next().value!);
-  }
-
   // Single attempt on purpose — the underlying fetch (resilience layer) owns
   // retries/backoff/breaker. Retrying here would multiply upstream calls and
   // re-enter the breaker too fast.
@@ -165,13 +160,16 @@ export function createFetchCache(config: FetchCacheConfig): FetchCache {
     recordCacheMetric(decision !== "MISS", undefined, decision, "swr", provider);
   }
 
-  function fetchWithCache<T>(
+  async function fetchWithCache<T>(
     cacheKey: string,
     doFetch: () => Promise<Response>,
     opts?: FetchCacheOptions,
   ): Promise<T | null> {
+    cacheKey = store.key(cacheKey);
+    const entry = getCacheStorageContext()?.storage
+      ? await store.read(cacheKey)
+      : store.get(cacheKey);
     const now = Date.now();
-    const entry = store.get(cacheKey);
 
     if (entry) {
       const maxAge = opts?.ttl ?? freshTtlForStatus(entry.status);
@@ -194,25 +192,31 @@ export function createFetchCache(config: FetchCacheConfig): FetchCache {
         if (!entry.refreshing) {
           entry.refreshing = true;
           // Background refresh: no retry — stale data is already being served.
-          withTimeout(
-            executeFetch(cacheKey, doFetch),
-            inflightBackstopMs,
-            `fetchCache stale-refresh ${cacheKey}`,
-          )
-            .then((fresh) => {
-              const ttl = opts?.ttl ?? freshTtlForStatus(fresh.status);
-              const existingWasSuccess = entry.status >= 200 && entry.status < 300;
-              const freshIsError = fresh.status >= 400;
-              const wouldDowngrade = existingWasSuccess && freshIsError;
-              if (ttl > 0 && !wouldDowngrade) {
-                store.set(cacheKey, fresh);
-              } else {
+          cacheBackground(
+            withTimeout(
+              executeFetch(cacheKey, doFetch),
+              inflightBackstopMs,
+              `fetchCache stale-refresh ${cacheKey}`,
+            )
+              .then((fresh) => {
+                const ttl = opts?.ttl ?? freshTtlForStatus(fresh.status);
+                const existingWasSuccess = entry.status >= 200 && entry.status < 300;
+                const freshIsError = fresh.status >= 400;
+                const wouldDowngrade = existingWasSuccess && freshIsError;
+                if (ttl > 0 && !wouldDowngrade) {
+                  store.set(
+                    cacheKey,
+                    fresh,
+                    fresh.createdAt + ttl + (opts?.sieMs ?? staleIfErrorMs),
+                  );
+                } else {
+                  entry.refreshing = false;
+                }
+              })
+              .catch(() => {
                 entry.refreshing = false;
-              }
-            })
-            .catch(() => {
-              entry.refreshing = false;
-            });
+              }),
+          );
         }
         // Serve last-good within the SIE window: this is the stale-while-
         // revalidate serve.
@@ -242,8 +246,7 @@ export function createFetchCache(config: FetchCacheConfig): FetchCache {
       .then((fresh) => {
         const ttl = opts?.ttl ?? freshTtlForStatus(fresh.status);
         if (ttl > 0) {
-          store.set(cacheKey, fresh);
-          evictIfNeeded();
+          store.set(cacheKey, fresh, fresh.createdAt + ttl + (opts?.sieMs ?? staleIfErrorMs));
         }
         return fresh;
       })

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,
-        },
-      });
     }
   }