@rivetkit/traces 2.1.0-rc.1

package/dist/tsup/index.cjs

@@ -0,0 +1,921 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkDXS2HLRNcjs = require('./chunk-DXS2HLRN.cjs');
+
+
+
+var _chunkZTVH74GCcjs = require('./chunk-ZTVH74GC.cjs');
+
+
+
+
+var _chunkQOSSO6CNcjs = require('./chunk-QOSSO6CN.cjs');
+
+// src/traces.ts
+var _async_hooks = require('async_hooks');
+var _buffer = require('buffer');
+var _crypto = require('crypto');
+var _perf_hooks = require('perf_hooks');
+var _cborx = require('cbor-x');
+var _fdbtuple = require('fdb-tuple');
+var KEY_PREFIX = {
+  DATA: 1
+};
+var AFTER_MAX_CHUNK_ID = 4294967296;
+var DEFAULT_BUCKET_SIZE_SEC = 3600;
+var DEFAULT_TARGET_CHUNK_BYTES = 512 * 1024;
+var DEFAULT_MAX_CHUNK_BYTES = 1024 * 1024;
+var DEFAULT_MAX_CHUNK_AGE_MS = 5e3;
+var DEFAULT_SNAPSHOT_INTERVAL_MS = 3e5;
+var DEFAULT_SNAPSHOT_BYTES_THRESHOLD = 256 * 1024;
+var DEFAULT_MAX_READ_LIMIT = 1e4;
+var DEFAULT_MAX_ACTIVE_SPANS = 1e4;
+var SPAN_ID_BYTES = 8;
+var TRACE_ID_BYTES = 16;
+var spanContext = new (0, _async_hooks.AsyncLocalStorage)();
+function spanKey(spanId) {
+  return _chunkZTVH74GCcjs.hexFromBytes.call(void 0, normalizeBytes(spanId));
+}
+function toArrayBuffer(bytes) {
+  const copy = new Uint8Array(bytes.byteLength);
+  copy.set(bytes);
+  return copy.buffer;
+}
+function toUint8Array(buffer) {
+  return new Uint8Array(buffer);
+}
+function normalizeBytes(input) {
+  return input instanceof Uint8Array ? input : new Uint8Array(input);
+}
+function createTraces(options) {
+  const driver = options.driver;
+  const bucketSizeSec = _nullishCoalesce(options.bucketSizeSec, () => ( DEFAULT_BUCKET_SIZE_SEC));
+  const maxChunkBytes = _nullishCoalesce(options.maxChunkBytes, () => ( DEFAULT_MAX_CHUNK_BYTES));
+  const targetChunkBytes = Math.min(
+    _nullishCoalesce(options.targetChunkBytes, () => ( DEFAULT_TARGET_CHUNK_BYTES)),
+    maxChunkBytes
+  );
+  const maxChunkAgeMs = _nullishCoalesce(options.maxChunkAgeMs, () => ( DEFAULT_MAX_CHUNK_AGE_MS));
+  const snapshotIntervalMs = _nullishCoalesce(options.snapshotIntervalMs, () => ( DEFAULT_SNAPSHOT_INTERVAL_MS));
+  const snapshotBytesThreshold = _nullishCoalesce(options.snapshotBytesThreshold, () => ( DEFAULT_SNAPSHOT_BYTES_THRESHOLD));
+  const maxActiveSpans = _nullishCoalesce(options.maxActiveSpans, () => ( DEFAULT_MAX_ACTIVE_SPANS));
+  const maxReadLimit = _nullishCoalesce(options.maxReadLimit, () => ( DEFAULT_MAX_READ_LIMIT));
+  const resource = options.resource;
+  const timeAnchor = {
+    unixMs: Date.now(),
+    monoMs: _perf_hooks.performance.now()
+  };
+  const activeSpans = /* @__PURE__ */ new Map();
+  const activeSpanRefs = /* @__PURE__ */ new Map();
+  const pendingChunks = [];
+  let writeChain = Promise.resolve();
+  const bucketChunkCounters = /* @__PURE__ */ new Map();
+  function nowUnixMs() {
+    return timeAnchor.unixMs + (_perf_hooks.performance.now() - timeAnchor.monoMs);
+  }
+  function nowUnixNs(anchor) {
+    const unixMs = anchor.unixMs + (_perf_hooks.performance.now() - anchor.monoMs);
+    const wholeMs = Math.floor(unixMs);
+    const fracMs = unixMs - wholeMs;
+    return BigInt(wholeMs) * 1000000n + BigInt(Math.floor(fracMs * 1e6));
+  }
+  function createChunkState(bucketStartSec) {
+    return {
+      bucketStartSec,
+      chunkId: nextChunkId(bucketStartSec),
+      baseUnixNs: BigInt(bucketStartSec) * 1000000000n,
+      strings: [],
+      stringIds: /* @__PURE__ */ new Map(),
+      records: [],
+      sizeBytes: 0,
+      createdAtMonoMs: _perf_hooks.performance.now()
+    };
+  }
+  function nextChunkId(bucketStartSec) {
+    const current = _nullishCoalesce(bucketChunkCounters.get(bucketStartSec), () => ( 0));
+    bucketChunkCounters.set(bucketStartSec, current + 1);
+    return current;
+  }
+  const currentChunk = createChunkState(
+    computeBucketStartSec(nowUnixNs(timeAnchor), bucketSizeSec)
+  );
+  function computeBucketStartSec(absoluteUnixNs, bucketSize) {
+    const sec = absoluteUnixNs / 1000000000n;
+    const bucket = sec / BigInt(bucketSize);
+    return Number(bucket * BigInt(bucketSize));
+  }
+  function internString(value) {
+    const existing = currentChunk.stringIds.get(value);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const id = currentChunk.strings.length;
+    currentChunk.strings.push(value);
+    currentChunk.stringIds.set(value, id);
+    return id;
+  }
+  function encodeAttributes(attributes) {
+    const list = [];
+    let dropped = 0;
+    if (!attributes) {
+      return { attributes: list, dropped };
+    }
+    for (const [key, value] of Object.entries(attributes)) {
+      const sanitized = sanitizeAttributeValue(value);
+      if (sanitized === void 0) {
+        dropped++;
+        continue;
+      }
+      try {
+        const encoded = _cborx.encode.call(void 0, sanitized);
+        list.push({ key: internString(key), value: toArrayBuffer(encoded) });
+      } catch (e) {
+        dropped++;
+      }
+    }
+    return { attributes: list, dropped };
+  }
+  function sanitizeAttributeValue(value) {
+    if (value === void 0 || typeof value === "function") {
+      return void 0;
+    }
+    if (typeof value === "symbol") {
+      return void 0;
+    }
+    if (value instanceof Map) {
+      const obj = {};
+      for (const [key, mapValue] of value.entries()) {
+        if (typeof key !== "string") {
+          return void 0;
+        }
+        const sanitized = sanitizeAttributeValue(mapValue);
+        if (sanitized !== void 0) {
+          obj[key] = sanitized;
+        }
+      }
+      return obj;
+    }
+    if (Array.isArray(value)) {
+      return value.map((entry) => sanitizeAttributeValue(entry)).filter((entry) => entry !== void 0);
+    }
+    return value;
+  }
+  function encodeLinks(links) {
+    const result = [];
+    let dropped = 0;
+    if (!links) {
+      return { links: result, dropped };
+    }
+    for (const link of links) {
+      const { attributes, dropped: droppedAttributes } = encodeAttributes(
+        link.attributes
+      );
+      result.push({
+        traceId: toArrayBuffer(link.traceId),
+        spanId: toArrayBuffer(link.spanId),
+        traceState: _nullishCoalesce(link.traceState, () => ( null)),
+        attributes,
+        droppedAttributesCount: droppedAttributes
+      });
+    }
+    return { links: result, dropped };
+  }
+  function createSpanStartRecord(spanId, traceId, name, options2, parentSpanId) {
+    const { attributes, dropped } = encodeAttributes(options2 == null ? void 0 : options2.attributes);
+    const { links, dropped: droppedLinks } = encodeLinks(options2 == null ? void 0 : options2.links);
+    return {
+      traceId,
+      spanId,
+      parentSpanId,
+      name: internString(name),
+      kind: _nullishCoalesce((options2 == null ? void 0 : options2.kind), () => ( 0)),
+      traceState: _nullishCoalesce((options2 == null ? void 0 : options2.traceState), () => ( null)),
+      flags: _nullishCoalesce((options2 == null ? void 0 : options2.flags), () => ( 0)),
+      attributes,
+      droppedAttributesCount: dropped,
+      links,
+      droppedLinksCount: droppedLinks
+    };
+  }
+  function createSpanUpdateRecord(spanId, options2) {
+    const { attributes, dropped } = encodeAttributes(options2.attributes);
+    return {
+      spanId,
+      attributes,
+      droppedAttributesCount: dropped,
+      status: options2.status ? toBareStatus(options2.status) : null
+    };
+  }
+  function createSpanEventRecord(spanId, name, options2) {
+    const { attributes, dropped } = encodeAttributes(options2 == null ? void 0 : options2.attributes);
+    return {
+      spanId,
+      name: internString(name),
+      attributes,
+      droppedAttributesCount: dropped
+    };
+  }
+  function createSpanEndRecord(spanId, options2) {
+    return {
+      spanId,
+      status: (options2 == null ? void 0 : options2.status) ? toBareStatus(options2.status) : null
+    };
+  }
+  function createSpanSnapshotRecord(state) {
+    const { attributes, dropped } = encodeAttributeMap(state.attributes);
+    const { links, dropped: droppedLinks } = encodeLinkState(state.links);
+    return {
+      traceId: state.traceId,
+      spanId: state.spanId,
+      parentSpanId: state.parentSpanId,
+      name: internString(state.name),
+      kind: state.kind,
+      startTimeUnixNs: state.startTimeUnixNs,
+      traceState: state.traceState,
+      flags: state.flags,
+      attributes,
+      droppedAttributesCount: state.droppedAttributesCount + dropped,
+      links,
+      droppedLinksCount: state.droppedLinksCount + droppedLinks,
+      status: state.status
+    };
+  }
+  function encodeAttributeMap(attributes) {
+    const list = [];
+    let dropped = 0;
+    for (const [key, value] of attributes.entries()) {
+      const sanitized = sanitizeAttributeValue(value);
+      if (sanitized === void 0) {
+        dropped++;
+        continue;
+      }
+      try {
+        const encoded = _cborx.encode.call(void 0, sanitized);
+        list.push({ key: internString(key), value: toArrayBuffer(encoded) });
+      } catch (e2) {
+        dropped++;
+      }
+    }
+    return { attributes: list, dropped };
+  }
+  function buildAttributeMapFromInput(attributes) {
+    const map = /* @__PURE__ */ new Map();
+    if (!attributes) {
+      return map;
+    }
+    for (const [key, value] of Object.entries(attributes)) {
+      const sanitized = sanitizeAttributeValue(value);
+      if (sanitized !== void 0) {
+        map.set(key, sanitized);
+      }
+    }
+    return map;
+  }
+  function decodeAttributeList(attributes, strings) {
+    const map = /* @__PURE__ */ new Map();
+    for (const kv of attributes) {
+      const key = _nullishCoalesce(strings[kv.key], () => ( ""));
+      try {
+        map.set(key, _cborx.decode.call(void 0, toUint8Array(kv.value)));
+      } catch (e3) {
+        continue;
+      }
+    }
+    return map;
+  }
+  function decodeLinks(links, strings) {
+    return links.map((link) => ({
+      traceId: link.traceId,
+      spanId: link.spanId,
+      traceState: link.traceState,
+      attributes: decodeAttributeList(link.attributes, strings),
+      droppedAttributesCount: link.droppedAttributesCount
+    }));
+  }
+  function encodeLinkState(links) {
+    const result = [];
+    let dropped = 0;
+    for (const link of links) {
+      const { attributes, dropped: droppedAttributes } = encodeAttributeMap(
+        link.attributes
+      );
+      result.push({
+        traceId: link.traceId,
+        spanId: link.spanId,
+        traceState: link.traceState,
+        attributes,
+        droppedAttributesCount: droppedAttributes
+      });
+    }
+    return { links: result, dropped };
+  }
+  function appendRecord(buildBody, providedTimeUnixMs) {
+    const absoluteUnixNs = providedTimeUnixMs !== void 0 ? BigInt(Math.floor(providedTimeUnixMs)) * 1000000n : nowUnixNs(timeAnchor);
+    const recordBucketStart = computeBucketStartSec(
+      absoluteUnixNs,
+      bucketSizeSec
+    );
+    if (recordBucketStart !== currentChunk.bucketStartSec) {
+      flushChunk();
+      resetChunkState(recordBucketStart);
+    }
+    if (_perf_hooks.performance.now() - currentChunk.createdAtMonoMs >= maxChunkAgeMs) {
+      flushChunk();
+      resetChunkState(recordBucketStart);
+    }
+    let body = buildBody();
+    const timeOffsetNs = absoluteUnixNs - currentChunk.baseUnixNs;
+    let record = { timeOffsetNs, body };
+    let encodedRecord = _chunkQOSSO6CNcjs.encodeRecord.call(void 0, record);
+    if (encodedRecord.length > maxChunkBytes) {
+      throw new Error("Record exceeds maxChunkBytes");
+    }
+    if (currentChunk.sizeBytes + encodedRecord.length > targetChunkBytes) {
+      flushChunk();
+      resetChunkState(recordBucketStart);
+      body = buildBody();
+      record = { timeOffsetNs, body };
+      encodedRecord = _chunkQOSSO6CNcjs.encodeRecord.call(void 0, record);
+      if (encodedRecord.length > maxChunkBytes) {
+        throw new Error("Record exceeds maxChunkBytes");
+      }
+    }
+    currentChunk.records.push(record);
+    currentChunk.sizeBytes += encodedRecord.length;
+    const recordIndex = currentChunk.records.length - 1;
+    return { recordIndex, encodedBytes: encodedRecord.length, body };
+  }
+  function flushChunk() {
+    if (currentChunk.records.length === 0) {
+      return false;
+    }
+    const chunk = {
+      baseUnixNs: currentChunk.baseUnixNs,
+      strings: currentChunk.strings,
+      records: currentChunk.records,
+      activeSpans: Array.from(activeSpanRefs.values())
+    };
+    const bytes = _chunkQOSSO6CNcjs.CHUNK_VERSIONED.serializeWithEmbeddedVersion(
+      chunk,
+      _chunkQOSSO6CNcjs.CURRENT_VERSION
+    );
+    const key = buildChunkKey(currentChunk.bucketStartSec, currentChunk.chunkId);
+    const maxRecordNs = chunk.records.length > 0 ? chunk.baseUnixNs + chunk.records[chunk.records.length - 1].timeOffsetNs : chunk.baseUnixNs;
+    const pending = {
+      key,
+      bucketStartSec: currentChunk.bucketStartSec,
+      chunkId: currentChunk.chunkId,
+      chunk,
+      bytes,
+      maxRecordNs
+    };
+    pendingChunks.push(pending);
+    enqueueWrite(pending);
+    return true;
+  }
+  function enqueueWrite(pending) {
+    writeChain = writeChain.then(async () => {
+      await driver.set(pending.key, pending.bytes);
+      const index = pendingChunks.indexOf(pending);
+      if (index !== -1) {
+        pendingChunks.splice(index, 1);
+      }
+    });
+  }
+  function resetChunkState(bucketStartSec) {
+    currentChunk.bucketStartSec = bucketStartSec;
+    currentChunk.chunkId = nextChunkId(bucketStartSec);
+    currentChunk.baseUnixNs = BigInt(bucketStartSec) * 1000000000n;
+    currentChunk.strings = [];
+    currentChunk.stringIds = /* @__PURE__ */ new Map();
+    currentChunk.records = [];
+    currentChunk.sizeBytes = 0;
+    currentChunk.createdAtMonoMs = _perf_hooks.performance.now();
+  }
+  function enforceMaxActiveSpans() {
+    if (activeSpans.size <= maxActiveSpans) {
+      return;
+    }
+    const candidates = Array.from(activeSpans.values()).sort((a, b) => {
+      if (a.depth !== b.depth) {
+        return b.depth - a.depth;
+      }
+      if (a.startTimeUnixNs > b.startTimeUnixNs) {
+        return -1;
+      }
+      if (a.startTimeUnixNs < b.startTimeUnixNs) {
+        return 1;
+      }
+      return 0;
+    });
+    for (const span of candidates) {
+      dropSpan(span.spanId);
+      if (activeSpans.size <= maxActiveSpans) {
+        break;
+      }
+    }
+  }
+  function dropSpan(spanId) {
+    const key = spanKey(spanId);
+    activeSpans.delete(key);
+    activeSpanRefs.delete(key);
+  }
+  function assertActive(handle) {
+    if (!isActive(handle)) {
+      throw new Error("Span handle is not active");
+    }
+  }
+  function isActive(handle) {
+    return activeSpans.has(spanKey(handle.spanId));
+  }
+  function startSpan(name, options2) {
+    const parent = _nullishCoalesce((options2 == null ? void 0 : options2.parent), () => ( getCurrentSpan()));
+    if (parent) {
+      assertActive(parent);
+    }
+    const spanIdBytes = _crypto.randomBytes.call(void 0, SPAN_ID_BYTES);
+    const traceIdBytes = parent ? parent.traceId : _crypto.randomBytes.call(void 0, TRACE_ID_BYTES);
+    const spanId = toArrayBuffer(spanIdBytes);
+    const traceId = toArrayBuffer(traceIdBytes);
+    const parentSpanId = parent ? toArrayBuffer(parent.spanId) : null;
+    const { recordIndex, encodedBytes, body } = appendRecord(() => ({
+      tag: "SpanStart",
+      val: createSpanStartRecord(
+        spanId,
+        traceId,
+        name,
+        options2,
+        parentSpanId
+      )
+    }));
+    const spanStart = body.val;
+    const key = spanKey(spanId);
+    const startKey = {
+      prefix: KEY_PREFIX.DATA,
+      bucketStartSec: BigInt(currentChunk.bucketStartSec),
+      chunkId: currentChunk.chunkId,
+      recordIndex
+    };
+    activeSpanRefs.set(key, {
+      spanId,
+      startKey,
+      latestSnapshotKey: null
+    });
+    const depth = computeSpanDepth(parentSpanId);
+    activeSpans.set(key, {
+      spanId,
+      traceId,
+      parentSpanId,
+      name,
+      kind: _nullishCoalesce((options2 == null ? void 0 : options2.kind), () => ( 0)),
+      traceState: _nullishCoalesce((options2 == null ? void 0 : options2.traceState), () => ( null)),
+      flags: _nullishCoalesce((options2 == null ? void 0 : options2.flags), () => ( 0)),
+      attributes: buildAttributeMapFromInput(options2 == null ? void 0 : options2.attributes),
+      droppedAttributesCount: spanStart.droppedAttributesCount,
+      links: decodeLinks(spanStart.links, currentChunk.strings),
+      droppedLinksCount: spanStart.droppedLinksCount,
+      status: null,
+      startTimeUnixNs: currentChunk.baseUnixNs + currentChunk.records[recordIndex].timeOffsetNs,
+      depth,
+      bytesSinceSnapshot: encodedBytes,
+      lastSnapshotMonoMs: _perf_hooks.performance.now()
+    });
+    enforceMaxActiveSpans();
+    return {
+      spanId: spanIdBytes,
+      traceId: traceIdBytes,
+      isActive: () => activeSpans.has(key)
+    };
+  }
+  function updateSpan(handle, options2) {
+    if (!options2.attributes && !options2.status) {
+      return;
+    }
+    assertActive(handle);
+    const { encodedBytes, body } = appendRecord(() => ({
+      tag: "SpanUpdate",
+      val: createSpanUpdateRecord(toArrayBuffer(handle.spanId), options2)
+    }));
+    const spanUpdate = body.val;
+    const state = activeSpans.get(spanKey(handle.spanId));
+    if (!state) {
+      return;
+    }
+    if (options2.attributes) {
+      const updates = buildAttributeMapFromInput(options2.attributes);
+      for (const [key, value] of updates.entries()) {
+        state.attributes.set(key, value);
+      }
+    }
+    state.droppedAttributesCount += spanUpdate.droppedAttributesCount;
+    if (options2.status) {
+      state.status = toBareStatus(options2.status);
+    }
+    state.bytesSinceSnapshot += encodedBytes;
+    maybeSnapshot(handle.spanId, state);
+  }
+  function setAttributes(handle, attributes) {
+    updateSpan(handle, { attributes });
+  }
+  function setStatus(handle, status) {
+    updateSpan(handle, { status });
+  }
+  function emitEvent(handle, name, options2) {
+    assertActive(handle);
+    const { encodedBytes } = appendRecord(
+      () => ({
+        tag: "SpanEvent",
+        val: createSpanEventRecord(toArrayBuffer(handle.spanId), name, options2)
+      }),
+      options2 == null ? void 0 : options2.timeUnixMs
+    );
+    const state = activeSpans.get(spanKey(handle.spanId));
+    if (state) {
+      state.bytesSinceSnapshot += encodedBytes;
+      maybeSnapshot(handle.spanId, state);
+    }
+  }
+  function endSpan(handle, options2) {
+    assertActive(handle);
+    appendRecord(() => ({
+      tag: "SpanEnd",
+      val: createSpanEndRecord(toArrayBuffer(handle.spanId), options2)
+    }));
+    dropSpan(handle.spanId);
+  }
+  function maybeSnapshot(spanId, state) {
+    if (state.bytesSinceSnapshot < snapshotBytesThreshold && _perf_hooks.performance.now() - state.lastSnapshotMonoMs < snapshotIntervalMs) {
+      return;
+    }
+    const { recordIndex } = appendRecord(() => ({
+      tag: "SpanSnapshot",
+      val: createSpanSnapshotRecord(state)
+    }));
+    const key = spanKey(spanId);
+    const ref = activeSpanRefs.get(key);
+    if (ref) {
+      activeSpanRefs.set(key, {
+        ...ref,
+        latestSnapshotKey: {
+          prefix: KEY_PREFIX.DATA,
+          bucketStartSec: BigInt(currentChunk.bucketStartSec),
+          chunkId: currentChunk.chunkId,
+          recordIndex
+        }
+      });
+    }
+    state.bytesSinceSnapshot = 0;
+    state.lastSnapshotMonoMs = _perf_hooks.performance.now();
+  }
+  async function flush() {
+    const didFlush = flushChunk();
+    if (didFlush) {
+      resetChunkState(currentChunk.bucketStartSec);
+    }
+    await writeChain;
+    return didFlush;
+  }
+  function withSpan(handle, fn) {
+    return spanContext.run(handle, fn);
+  }
+  function getCurrentSpan() {
+    const handle = _nullishCoalesce(spanContext.getStore(), () => ( null));
+    if (!handle) {
+      return null;
+    }
+    return isActive(handle) ? handle : null;
+  }
+  async function readRangeWire(options2) {
+    const startMs = Math.floor(options2.startMs);
+    const endMs = Math.floor(options2.endMs);
+    if (options2.limit <= 0 || endMs <= startMs) {
+      return {
+        startTimeMs: BigInt(startMs),
+        endTimeMs: BigInt(endMs),
+        limit: 0,
+        clamped: false,
+        baseChunks: [],
+        chunks: []
+      };
+    }
+    const limitWasClamped = options2.limit > maxReadLimit;
+    const limit = Math.min(options2.limit, maxReadLimit);
+    const startNs = BigInt(startMs) * 1000000n;
+    const endNs = BigInt(endMs) * 1000000n;
+    const previousChunk = await findPreviousChunk(startNs, bucketSizeSec);
+    const activeRefs = _nullishCoalesce((previousChunk == null ? void 0 : previousChunk.activeSpans), () => ( []));
+    const baseChunks = [];
+    for (const ref of activeRefs) {
+      const baseRecord = await loadBaseRecord(ref);
+      if (!baseRecord) {
+        continue;
+      }
+      const baseUnixNs = baseRecord.absNs - baseRecord.record.timeOffsetNs;
+      baseChunks.push({
+        baseUnixNs,
+        strings: baseRecord.strings,
+        records: [baseRecord.record],
+        activeSpans: []
+      });
+    }
+    const chunks = [];
+    const diskChunks = await listRangeChunks(startNs, endNs, bucketSizeSec);
+    for (const chunk of diskChunks) {
+      const filtered = filterChunkRecords(chunk.chunk, startNs, endNs);
+      if (filtered) {
+        chunks.push(filtered);
+      }
+    }
+    for (const pending of pendingChunks) {
+      const filtered = filterChunkRecords(pending.chunk, startNs, endNs);
+      if (filtered) {
+        chunks.push(filtered);
+      }
+    }
+    const currentFiltered = filterChunkRecords(
+      currentChunkAsChunk(),
+      startNs,
+      endNs
+    );
+    if (currentFiltered) {
+      chunks.push(currentFiltered);
+    }
+    const reachedSpanLimit = countUniqueSpanIds(chunks, limit);
+    return {
+      startTimeMs: BigInt(startMs),
+      endTimeMs: BigInt(endMs),
+      limit,
+      clamped: limitWasClamped || reachedSpanLimit,
+      baseChunks,
+      chunks
+    };
+  }
+  async function readRange(options2) {
+    const wire = await readRangeWire(options2);
+    return _chunkZTVH74GCcjs.readRangeWireToOtlp.call(void 0, wire, resource);
+  }
+  function filterChunkRecords(chunk, startNs, endNs) {
+    const filtered = [];
+    for (const record of chunk.records) {
+      const absNs = chunk.baseUnixNs + record.timeOffsetNs;
+      if (absNs < startNs || absNs >= endNs) {
+        continue;
+      }
+      filtered.push(record);
+    }
+    if (filtered.length === 0) {
+      return null;
+    }
+    return {
+      baseUnixNs: chunk.baseUnixNs,
+      strings: chunk.strings,
+      records: filtered,
+      activeSpans: chunk.activeSpans
+    };
+  }
+  function countUniqueSpanIds(chunks, limit) {
+    if (limit <= 0) {
+      return true;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const chunk of chunks) {
+      for (const record of chunk.records) {
+        const key = spanKey(recordSpanId(record.body));
+        if (seen.has(key)) {
+          continue;
+        }
+        if (seen.size >= limit) {
+          return true;
+        }
+        seen.add(key);
+      }
+    }
+    return false;
+  }
+  function recordSpanId(body) {
+    switch (body.tag) {
+      case "SpanStart":
+        return body.val.spanId;
+      case "SpanEvent":
+        return body.val.spanId;
+      case "SpanUpdate":
+        return body.val.spanId;
+      case "SpanEnd":
+        return body.val.spanId;
+      case "SpanSnapshot":
+        return body.val.spanId;
+    }
+  }
+  function currentChunkAsChunk() {
+    return {
+      baseUnixNs: currentChunk.baseUnixNs,
+      strings: currentChunk.strings,
+      records: currentChunk.records,
+      activeSpans: Array.from(activeSpanRefs.values())
+    };
+  }
+  async function listRangeChunks(startNs, endNs, bucketSize) {
+    const startBucket = computeBucketStartSec(startNs, bucketSize);
+    const endBucket = computeBucketStartSec(endNs, bucketSize);
+    const startKey = buildChunkKey(startBucket, 0);
+    const endKey = buildChunkKey(endBucket + bucketSize, 0);
+    const entries = await driver.listRange(startKey, endKey);
+    const output = [];
+    for (const entry of entries) {
+      const chunk = deserializeChunkSafe(entry.value);
+      if (!chunk) {
+        continue;
+      }
+      output.push({ key: entry.key, chunk });
+    }
+    return output;
+  }
+  async function findPreviousChunk(startNs, bucketSize) {
+    const startBucket = computeBucketStartSec(startNs, bucketSize);
+    let cursor = {
+      bucketStartSec: startBucket,
+      chunkId: AFTER_MAX_CHUNK_ID
+    };
+    while (true) {
+      const pendingCandidate = findLatestPendingBefore(cursor);
+      const diskCandidate = await findLatestDiskBefore(cursor);
+      const candidate = selectLatestCandidate(
+        pendingCandidate,
+        diskCandidate
+      );
+      if (!candidate) {
+        return null;
+      }
+      if (candidate.maxRecordNs < startNs) {
+        return candidate.chunk;
+      }
+      cursor = {
+        bucketStartSec: candidate.bucketStartSec,
+        chunkId: candidate.chunkId
+      };
+    }
+  }
+  function findLatestPendingBefore(cursor) {
+    let best = null;
+    for (const pending of pendingChunks) {
+      if (compareChunkKey(pending, cursor) >= 0) {
+        continue;
+      }
+      if (!best || compareChunkKey(pending, best) > 0) {
+        best = pending;
+      }
+    }
+    return best;
+  }
+  async function findLatestDiskBefore(cursor) {
+    const startKey = buildChunkKey(0, 0);
+    let endKey = buildChunkKey(cursor.bucketStartSec, cursor.chunkId);
+    while (true) {
+      const entries = await driver.listRange(startKey, endKey, {
+        reverse: true,
+        limit: 10
+      });
+      if (entries.length === 0) {
+        return null;
+      }
+      for (const entry of entries) {
+        const chunk = deserializeChunkSafe(entry.value);
+        if (!chunk) {
+          endKey = entry.key;
+          continue;
+        }
+        const { bucketStartSec, chunkId } = decodeChunkKey(entry.key);
+        const maxRecordNs = chunk.records.length > 0 ? chunk.baseUnixNs + chunk.records[chunk.records.length - 1].timeOffsetNs : chunk.baseUnixNs;
+        return {
+          key: entry.key,
+          bucketStartSec,
+          chunkId,
+          chunk,
+          bytes: entry.value,
+          maxRecordNs
+        };
+      }
+    }
+  }
+  function selectLatestCandidate(pending, disk) {
+    if (pending && disk) {
+      return compareChunkKey(pending, disk) >= 0 ? pending : disk;
+    }
+    return _nullishCoalesce(pending, () => ( disk));
+  }
+  function compareChunkKey(a, b) {
+    if (a.bucketStartSec !== b.bucketStartSec) {
+      return a.bucketStartSec - b.bucketStartSec;
+    }
+    return a.chunkId - b.chunkId;
+  }
+  function decodeChunkKey(key) {
+    const tuple = _fdbtuple.unpack.call(void 0, _buffer.Buffer.from(key));
+    return { bucketStartSec: tuple[1], chunkId: tuple[2] };
+  }
+  function buildChunkKey(bucketStartSec, chunkId) {
+    return _fdbtuple.pack.call(void 0, [KEY_PREFIX.DATA, bucketStartSec, chunkId]);
+  }
+  function deserializeChunkSafe(bytes) {
+    try {
+      return _chunkQOSSO6CNcjs.CHUNK_VERSIONED.deserializeWithEmbeddedVersion(bytes);
+    } catch (e4) {
+      return null;
+    }
+  }
+  async function loadBaseRecord(ref) {
+    const key = _nullishCoalesce(ref.latestSnapshotKey, () => ( ref.startKey));
+    const bucketStartSec = toNumber(key.bucketStartSec);
+    const fromMemory = findChunkInMemory(bucketStartSec, key.chunkId);
+    if (fromMemory) {
+      const record2 = fromMemory.records[key.recordIndex];
+      if (!record2) {
+        return null;
+      }
+      const absNs2 = fromMemory.baseUnixNs + record2.timeOffsetNs;
+      return { record: record2, strings: fromMemory.strings, absNs: absNs2 };
+    }
+    const chunkKey = buildChunkKey(bucketStartSec, key.chunkId);
+    const bytes = await driver.get(chunkKey);
+    if (!bytes) {
+      return null;
+    }
+    const chunk = deserializeChunkSafe(bytes);
+    if (!chunk) {
+      return null;
+    }
+    const record = chunk.records[key.recordIndex];
+    if (!record) {
+      return null;
+    }
+    const absNs = chunk.baseUnixNs + record.timeOffsetNs;
+    return { record, strings: chunk.strings, absNs };
+  }
+  function findChunkInMemory(bucketStartSec, chunkId) {
+    if (currentChunk.bucketStartSec === bucketStartSec && currentChunk.chunkId === chunkId) {
+      return currentChunkAsChunk();
+    }
+    const pending = pendingChunks.find(
+      (candidate) => candidate.bucketStartSec === bucketStartSec && candidate.chunkId === chunkId
+    );
+    return _nullishCoalesce((pending == null ? void 0 : pending.chunk), () => ( null));
+  }
+  function toNumber(value) {
+    const asNumber = Number(value);
+    if (!Number.isSafeInteger(asNumber)) {
+      throw new Error("Value exceeds safe integer range");
+    }
+    return asNumber;
+  }
+  function computeSpanDepth(parentSpanId) {
+    if (!parentSpanId) {
+      return 0;
+    }
+    const parent = activeSpans.get(spanKey(parentSpanId));
+    if (!parent) {
+      return 0;
+    }
+    return parent.depth + 1;
+  }
+  function randomSpanId() {
+    return toArrayBuffer(_crypto.randomBytes.call(void 0, SPAN_ID_BYTES));
+  }
+  function randomTraceId() {
+    return toArrayBuffer(_crypto.randomBytes.call(void 0, TRACE_ID_BYTES));
+  }
+  function toBareStatus(status) {
+    return {
+      code: toBareStatusCode(status.code),
+      message: _nullishCoalesce(status.message, () => ( null))
+    };
+  }
+  function toBareStatusCode(code) {
+    switch (code) {
+      case "OK":
+        return "OK" /* OK */;
+      case "ERROR":
+        return "ERROR" /* ERROR */;
+      case "UNSET":
+      default:
+        return "UNSET" /* UNSET */;
+    }
+  }
+  return {
+    startSpan,
+    updateSpan,
+    setAttributes,
+    setStatus,
+    endSpan,
+    emitEvent,
+    withSpan,
+    getCurrentSpan,
+    flush,
+    readRange,
+    readRangeWire
+  };
+}
+
+
+
+exports.createNoopTraces = _chunkDXS2HLRNcjs.createNoopTraces; exports.createTraces = createTraces;
+//# sourceMappingURL=index.cjs.map