@rivetkit/traces 2.0.4-rc.1

package/dist/schemas/v1.ts

@@ -0,0 +1,653 @@
+// @generated - post-processed by compile-bare.ts
+import * as bare from "@rivetkit/bare-ts"
+
+const config = /* @__PURE__ */ bare.Config({})
+
+export type u32 = number
+export type u64 = bigint
+
+export type Cbor = ArrayBuffer
+
+export function readCbor(bc: bare.ByteCursor): Cbor {
+    return bare.readData(bc)
+}
+
+export function writeCbor(bc: bare.ByteCursor, x: Cbor): void {
+    bare.writeData(bc, x)
+}
+
+export type TraceId = ArrayBuffer
+
+export function readTraceId(bc: bare.ByteCursor): TraceId {
+    return bare.readData(bc)
+}
+
+export function writeTraceId(bc: bare.ByteCursor, x: TraceId): void {
+    bare.writeData(bc, x)
+}
+
+export type SpanId = ArrayBuffer
+
+export function readSpanId(bc: bare.ByteCursor): SpanId {
+    return bare.readData(bc)
+}
+
+export function writeSpanId(bc: bare.ByteCursor, x: SpanId): void {
+    bare.writeData(bc, x)
+}
+
+export type StringId = u32
+
+export function readStringId(bc: bare.ByteCursor): StringId {
+    return bare.readU32(bc)
+}
+
+export function writeStringId(bc: bare.ByteCursor, x: StringId): void {
+    bare.writeU32(bc, x)
+}
+
+export type KeyValue = {
+    readonly key: StringId,
+    readonly value: Cbor,
+}
+
+export function readKeyValue(bc: bare.ByteCursor): KeyValue {
+    return {
+        key: readStringId(bc),
+        value: readCbor(bc),
+    }
+}
+
+export function writeKeyValue(bc: bare.ByteCursor, x: KeyValue): void {
+    writeStringId(bc, x.key)
+    writeCbor(bc, x.value)
+}
+
+export type Attributes = readonly KeyValue[]
+
+export function readAttributes(bc: bare.ByteCursor): Attributes {
+    const len = bare.readUintSafe(bc)
+    if (len === 0) { return [] }
+    const result = [readKeyValue(bc)]
+    for (let i = 1; i < len; i++) {
+        result[i] = readKeyValue(bc)
+    }
+    return result
+}
+
+export function writeAttributes(bc: bare.ByteCursor, x: Attributes): void {
+    bare.writeUintSafe(bc, x.length)
+    for (let i = 0; i < x.length; i++) {
+        writeKeyValue(bc, x[i])
+    }
+}
+
+export enum SpanStatusCode {
+    UNSET = "UNSET",
+    OK = "OK",
+    ERROR = "ERROR",
+}
+
+export function readSpanStatusCode(bc: bare.ByteCursor): SpanStatusCode {
+    const offset = bc.offset
+    const tag = bare.readU8(bc)
+    switch (tag) {
+        case 0:
+            return SpanStatusCode.UNSET
+        case 1:
+            return SpanStatusCode.OK
+        case 2:
+            return SpanStatusCode.ERROR
+        default: {
+            bc.offset = offset
+            throw new bare.BareError(offset, "invalid tag")
+        }
+    }
+}
+
+export function writeSpanStatusCode(bc: bare.ByteCursor, x: SpanStatusCode): void {
+    switch (x) {
+        case SpanStatusCode.UNSET: {
+            bare.writeU8(bc, 0)
+            break
+        }
+        case SpanStatusCode.OK: {
+            bare.writeU8(bc, 1)
+            break
+        }
+        case SpanStatusCode.ERROR: {
+            bare.writeU8(bc, 2)
+            break
+        }
+    }
+}
+
+function read0(bc: bare.ByteCursor): string | null {
+    return bare.readBool(bc)
+        ? bare.readString(bc)
+        : null
+}
+
+function write0(bc: bare.ByteCursor, x: string | null): void {
+    bare.writeBool(bc, x !== null)
+    if (x !== null) {
+        bare.writeString(bc, x)
+    }
+}
+
+export type SpanStatus = {
+    readonly code: SpanStatusCode,
+    readonly message: string | null,
+}
+
+export function readSpanStatus(bc: bare.ByteCursor): SpanStatus {
+    return {
+        code: readSpanStatusCode(bc),
+        message: read0(bc),
+    }
+}
+
+export function writeSpanStatus(bc: bare.ByteCursor, x: SpanStatus): void {
+    writeSpanStatusCode(bc, x.code)
+    write0(bc, x.message)
+}
+
+export type SpanLink = {
+    readonly traceId: TraceId,
+    readonly spanId: SpanId,
+    readonly traceState: string | null,
+    readonly attributes: Attributes,
+    readonly droppedAttributesCount: u32,
+}
+
+export function readSpanLink(bc: bare.ByteCursor): SpanLink {
+    return {
+        traceId: readTraceId(bc),
+        spanId: readSpanId(bc),
+        traceState: read0(bc),
+        attributes: readAttributes(bc),
+        droppedAttributesCount: bare.readU32(bc),
+    }
+}
+
+export function writeSpanLink(bc: bare.ByteCursor, x: SpanLink): void {
+    writeTraceId(bc, x.traceId)
+    writeSpanId(bc, x.spanId)
+    write0(bc, x.traceState)
+    writeAttributes(bc, x.attributes)
+    bare.writeU32(bc, x.droppedAttributesCount)
+}
+
+function read1(bc: bare.ByteCursor): SpanId | null {
+    return bare.readBool(bc)
+        ? readSpanId(bc)
+        : null
+}
+
+function write1(bc: bare.ByteCursor, x: SpanId | null): void {
+    bare.writeBool(bc, x !== null)
+    if (x !== null) {
+        writeSpanId(bc, x)
+    }
+}
+
+function read2(bc: bare.ByteCursor): readonly SpanLink[] {
+    const len = bare.readUintSafe(bc)
+    if (len === 0) { return [] }
+    const result = [readSpanLink(bc)]
+    for (let i = 1; i < len; i++) {
+        result[i] = readSpanLink(bc)
+    }
+    return result
+}
+
+function write2(bc: bare.ByteCursor, x: readonly SpanLink[]): void {
+    bare.writeUintSafe(bc, x.length)
+    for (let i = 0; i < x.length; i++) {
+        writeSpanLink(bc, x[i])
+    }
+}
+
+export type SpanStart = {
+    readonly traceId: TraceId,
+    readonly spanId: SpanId,
+    readonly parentSpanId: SpanId | null,
+    readonly name: StringId,
+    readonly kind: u32,
+    readonly traceState: string | null,
+    readonly flags: u32,
+    readonly attributes: Attributes,
+    readonly droppedAttributesCount: u32,
+    readonly links: readonly SpanLink[],
+    readonly droppedLinksCount: u32,
+}
+
+export function readSpanStart(bc: bare.ByteCursor): SpanStart {
+    return {
+        traceId: readTraceId(bc),
+        spanId: readSpanId(bc),
+        parentSpanId: read1(bc),
+        name: readStringId(bc),
+        kind: bare.readU32(bc),
+        traceState: read0(bc),
+        flags: bare.readU32(bc),
+        attributes: readAttributes(bc),
+        droppedAttributesCount: bare.readU32(bc),
+        links: read2(bc),
+        droppedLinksCount: bare.readU32(bc),
+    }
+}
+
+export function writeSpanStart(bc: bare.ByteCursor, x: SpanStart): void {
+    writeTraceId(bc, x.traceId)
+    writeSpanId(bc, x.spanId)
+    write1(bc, x.parentSpanId)
+    writeStringId(bc, x.name)
+    bare.writeU32(bc, x.kind)
+    write0(bc, x.traceState)
+    bare.writeU32(bc, x.flags)
+    writeAttributes(bc, x.attributes)
+    bare.writeU32(bc, x.droppedAttributesCount)
+    write2(bc, x.links)
+    bare.writeU32(bc, x.droppedLinksCount)
+}
+
+function read3(bc: bare.ByteCursor): SpanStatus | null {
+    return bare.readBool(bc)
+        ? readSpanStatus(bc)
+        : null
+}
+
+function write3(bc: bare.ByteCursor, x: SpanStatus | null): void {
+    bare.writeBool(bc, x !== null)
+    if (x !== null) {
+        writeSpanStatus(bc, x)
+    }
+}
+
+export type SpanUpdate = {
+    readonly spanId: SpanId,
+    readonly attributes: Attributes,
+    readonly droppedAttributesCount: u32,
+    readonly status: SpanStatus | null,
+}
+
+export function readSpanUpdate(bc: bare.ByteCursor): SpanUpdate {
+    return {
+        spanId: readSpanId(bc),
+        attributes: readAttributes(bc),
+        droppedAttributesCount: bare.readU32(bc),
+        status: read3(bc),
+    }
+}
+
+export function writeSpanUpdate(bc: bare.ByteCursor, x: SpanUpdate): void {
+    writeSpanId(bc, x.spanId)
+    writeAttributes(bc, x.attributes)
+    bare.writeU32(bc, x.droppedAttributesCount)
+    write3(bc, x.status)
+}
+
+export type SpanEvent = {
+    readonly spanId: SpanId,
+    readonly name: StringId,
+    readonly attributes: Attributes,
+    readonly droppedAttributesCount: u32,
+}
+
+export function readSpanEvent(bc: bare.ByteCursor): SpanEvent {
+    return {
+        spanId: readSpanId(bc),
+        name: readStringId(bc),
+        attributes: readAttributes(bc),
+        droppedAttributesCount: bare.readU32(bc),
+    }
+}
+
+export function writeSpanEvent(bc: bare.ByteCursor, x: SpanEvent): void {
+    writeSpanId(bc, x.spanId)
+    writeStringId(bc, x.name)
+    writeAttributes(bc, x.attributes)
+    bare.writeU32(bc, x.droppedAttributesCount)
+}
+
+export type SpanEnd = {
+    readonly spanId: SpanId,
+    readonly status: SpanStatus | null,
+}
+
+export function readSpanEnd(bc: bare.ByteCursor): SpanEnd {
+    return {
+        spanId: readSpanId(bc),
+        status: read3(bc),
+    }
+}
+
+export function writeSpanEnd(bc: bare.ByteCursor, x: SpanEnd): void {
+    writeSpanId(bc, x.spanId)
+    write3(bc, x.status)
+}
+
+export type SpanSnapshot = {
+    readonly traceId: TraceId,
+    readonly spanId: SpanId,
+    readonly parentSpanId: SpanId | null,
+    readonly name: StringId,
+    readonly kind: u32,
+    readonly startTimeUnixNs: u64,
+    readonly traceState: string | null,
+    readonly flags: u32,
+    readonly attributes: Attributes,
+    readonly droppedAttributesCount: u32,
+    readonly links: readonly SpanLink[],
+    readonly droppedLinksCount: u32,
+    readonly status: SpanStatus | null,
+}
+
+export function readSpanSnapshot(bc: bare.ByteCursor): SpanSnapshot {
+    return {
+        traceId: readTraceId(bc),
+        spanId: readSpanId(bc),
+        parentSpanId: read1(bc),
+        name: readStringId(bc),
+        kind: bare.readU32(bc),
+        startTimeUnixNs: bare.readU64(bc),
+        traceState: read0(bc),
+        flags: bare.readU32(bc),
+        attributes: readAttributes(bc),
+        droppedAttributesCount: bare.readU32(bc),
+        links: read2(bc),
+        droppedLinksCount: bare.readU32(bc),
+        status: read3(bc),
+    }
+}
+
+export function writeSpanSnapshot(bc: bare.ByteCursor, x: SpanSnapshot): void {
+    writeTraceId(bc, x.traceId)
+    writeSpanId(bc, x.spanId)
+    write1(bc, x.parentSpanId)
+    writeStringId(bc, x.name)
+    bare.writeU32(bc, x.kind)
+    bare.writeU64(bc, x.startTimeUnixNs)
+    write0(bc, x.traceState)
+    bare.writeU32(bc, x.flags)
+    writeAttributes(bc, x.attributes)
+    bare.writeU32(bc, x.droppedAttributesCount)
+    write2(bc, x.links)
+    bare.writeU32(bc, x.droppedLinksCount)
+    write3(bc, x.status)
+}
+
+export type RecordBody =
+    | { readonly tag: "SpanStart", readonly val: SpanStart }
+    | { readonly tag: "SpanEvent", readonly val: SpanEvent }
+    | { readonly tag: "SpanUpdate", readonly val: SpanUpdate }
+    | { readonly tag: "SpanEnd", readonly val: SpanEnd }
+    | { readonly tag: "SpanSnapshot", readonly val: SpanSnapshot }
+
+export function readRecordBody(bc: bare.ByteCursor): RecordBody {
+    const offset = bc.offset
+    const tag = bare.readU8(bc)
+    switch (tag) {
+        case 0:
+            return { tag: "SpanStart", val: readSpanStart(bc) }
+        case 1:
+            return { tag: "SpanEvent", val: readSpanEvent(bc) }
+        case 2:
+            return { tag: "SpanUpdate", val: readSpanUpdate(bc) }
+        case 3:
+            return { tag: "SpanEnd", val: readSpanEnd(bc) }
+        case 4:
+            return { tag: "SpanSnapshot", val: readSpanSnapshot(bc) }
+        default: {
+            bc.offset = offset
+            throw new bare.BareError(offset, "invalid tag")
+        }
+    }
+}
+
+export function writeRecordBody(bc: bare.ByteCursor, x: RecordBody): void {
+    switch (x.tag) {
+        case "SpanStart": {
+            bare.writeU8(bc, 0)
+            writeSpanStart(bc, x.val)
+            break
+        }
+        case "SpanEvent": {
+            bare.writeU8(bc, 1)
+            writeSpanEvent(bc, x.val)
+            break
+        }
+        case "SpanUpdate": {
+            bare.writeU8(bc, 2)
+            writeSpanUpdate(bc, x.val)
+            break
+        }
+        case "SpanEnd": {
+            bare.writeU8(bc, 3)
+            writeSpanEnd(bc, x.val)
+            break
+        }
+        case "SpanSnapshot": {
+            bare.writeU8(bc, 4)
+            writeSpanSnapshot(bc, x.val)
+            break
+        }
+    }
+}
+
+export type Record = {
+    readonly timeOffsetNs: u64,
+    readonly body: RecordBody,
+}
+
+export function readRecord(bc: bare.ByteCursor): Record {
+    return {
+        timeOffsetNs: bare.readU64(bc),
+        body: readRecordBody(bc),
+    }
+}
+
+export function writeRecord(bc: bare.ByteCursor, x: Record): void {
+    bare.writeU64(bc, x.timeOffsetNs)
+    writeRecordBody(bc, x.body)
+}
+
+export type SpanRecordKey = {
+    readonly prefix: u32,
+    readonly bucketStartSec: u64,
+    readonly chunkId: u32,
+    readonly recordIndex: u32,
+}
+
+export function readSpanRecordKey(bc: bare.ByteCursor): SpanRecordKey {
+    return {
+        prefix: bare.readU32(bc),
+        bucketStartSec: bare.readU64(bc),
+        chunkId: bare.readU32(bc),
+        recordIndex: bare.readU32(bc),
+    }
+}
+
+export function writeSpanRecordKey(bc: bare.ByteCursor, x: SpanRecordKey): void {
+    bare.writeU32(bc, x.prefix)
+    bare.writeU64(bc, x.bucketStartSec)
+    bare.writeU32(bc, x.chunkId)
+    bare.writeU32(bc, x.recordIndex)
+}
+
+function read4(bc: bare.ByteCursor): SpanRecordKey | null {
+    return bare.readBool(bc)
+        ? readSpanRecordKey(bc)
+        : null
+}
+
+function write4(bc: bare.ByteCursor, x: SpanRecordKey | null): void {
+    bare.writeBool(bc, x !== null)
+    if (x !== null) {
+        writeSpanRecordKey(bc, x)
+    }
+}
+
+export type ActiveSpanRef = {
+    readonly spanId: SpanId,
+    readonly startKey: SpanRecordKey,
+    readonly latestSnapshotKey: SpanRecordKey | null,
+}
+
+export function readActiveSpanRef(bc: bare.ByteCursor): ActiveSpanRef {
+    return {
+        spanId: readSpanId(bc),
+        startKey: readSpanRecordKey(bc),
+        latestSnapshotKey: read4(bc),
+    }
+}
+
+export function writeActiveSpanRef(bc: bare.ByteCursor, x: ActiveSpanRef): void {
+    writeSpanId(bc, x.spanId)
+    writeSpanRecordKey(bc, x.startKey)
+    write4(bc, x.latestSnapshotKey)
+}
+
+function read5(bc: bare.ByteCursor): readonly string[] {
+    const len = bare.readUintSafe(bc)
+    if (len === 0) { return [] }
+    const result = [bare.readString(bc)]
+    for (let i = 1; i < len; i++) {
+        result[i] = bare.readString(bc)
+    }
+    return result
+}
+
+function write5(bc: bare.ByteCursor, x: readonly string[]): void {
+    bare.writeUintSafe(bc, x.length)
+    for (let i = 0; i < x.length; i++) {
+        bare.writeString(bc, x[i])
+    }
+}
+
+function read6(bc: bare.ByteCursor): readonly Record[] {
+    const len = bare.readUintSafe(bc)
+    if (len === 0) { return [] }
+    const result = [readRecord(bc)]
+    for (let i = 1; i < len; i++) {
+        result[i] = readRecord(bc)
+    }
+    return result
+}
+
+function write6(bc: bare.ByteCursor, x: readonly Record[]): void {
+    bare.writeUintSafe(bc, x.length)
+    for (let i = 0; i < x.length; i++) {
+        writeRecord(bc, x[i])
+    }
+}
+
+function read7(bc: bare.ByteCursor): readonly ActiveSpanRef[] {
+    const len = bare.readUintSafe(bc)
+    if (len === 0) { return [] }
+    const result = [readActiveSpanRef(bc)]
+    for (let i = 1; i < len; i++) {
+        result[i] = readActiveSpanRef(bc)
+    }
+    return result
+}
+
+function write7(bc: bare.ByteCursor, x: readonly ActiveSpanRef[]): void {
+    bare.writeUintSafe(bc, x.length)
+    for (let i = 0; i < x.length; i++) {
+        writeActiveSpanRef(bc, x[i])
+    }
+}
+
+export type Chunk = {
+    readonly baseUnixNs: u64,
+    readonly strings: readonly string[],
+    readonly records: readonly Record[],
+    readonly activeSpans: readonly ActiveSpanRef[],
+}
+
+export function readChunk(bc: bare.ByteCursor): Chunk {
+    return {
+        baseUnixNs: bare.readU64(bc),
+        strings: read5(bc),
+        records: read6(bc),
+        activeSpans: read7(bc),
+    }
+}
+
+export function writeChunk(bc: bare.ByteCursor, x: Chunk): void {
+    bare.writeU64(bc, x.baseUnixNs)
+    write5(bc, x.strings)
+    write6(bc, x.records)
+    write7(bc, x.activeSpans)
+}
+
+function read8(bc: bare.ByteCursor): readonly Chunk[] {
+    const len = bare.readUintSafe(bc)
+    if (len === 0) { return [] }
+    const result = [readChunk(bc)]
+    for (let i = 1; i < len; i++) {
+        result[i] = readChunk(bc)
+    }
+    return result
+}
+
+function write8(bc: bare.ByteCursor, x: readonly Chunk[]): void {
+    bare.writeUintSafe(bc, x.length)
+    for (let i = 0; i < x.length; i++) {
+        writeChunk(bc, x[i])
+    }
+}
+
+export type ReadRangeWire = {
+    readonly startTimeMs: u64,
+    readonly endTimeMs: u64,
+    readonly limit: u32,
+    readonly clamped: boolean,
+    readonly baseChunks: readonly Chunk[],
+    readonly chunks: readonly Chunk[],
+}
+
+export function readReadRangeWire(bc: bare.ByteCursor): ReadRangeWire {
+    return {
+        startTimeMs: bare.readU64(bc),
+        endTimeMs: bare.readU64(bc),
+        limit: bare.readU32(bc),
+        clamped: bare.readBool(bc),
+        baseChunks: read8(bc),
+        chunks: read8(bc),
+    }
+}
+
+export function writeReadRangeWire(bc: bare.ByteCursor, x: ReadRangeWire): void {
+    bare.writeU64(bc, x.startTimeMs)
+    bare.writeU64(bc, x.endTimeMs)
+    bare.writeU32(bc, x.limit)
+    bare.writeBool(bc, x.clamped)
+    write8(bc, x.baseChunks)
+    write8(bc, x.chunks)
+}
+
+export function encodeReadRangeWire(x: ReadRangeWire): Uint8Array {
+    const bc = new bare.ByteCursor(
+        new Uint8Array(config.initialBufferLength),
+        config
+    )
+    writeReadRangeWire(bc, x)
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset)
+}
+
+export function decodeReadRangeWire(bytes: Uint8Array): ReadRangeWire {
+    const bc = new bare.ByteCursor(bytes, config)
+    const result = readReadRangeWire(bc)
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes")
+    }
+    return result
+}
+
+
+function assert(condition: boolean, message?: string): asserts condition {
+    if (!condition) throw new Error(message ?? "Assertion failed")
+}

package/dist/tsup/chunk-2D7JND4Z.js

@@ -0,0 +1,63 @@
+// src/noop.ts
+var U32_MAX = 4294967295;
+var NOOP_SPAN = {
+  spanId: new Uint8Array(8),
+  traceId: new Uint8Array(16),
+  isActive: () => false
+};
+function createEmptyOtlpExport() {
+  return {
+    resourceSpans: [
+      {
+        scopeSpans: [{ spans: [] }]
+      }
+    ]
+  };
+}
+function createNoopTraces() {
+  return {
+    startSpan(_name, _options) {
+      return NOOP_SPAN;
+    },
+    updateSpan(_handle, _options) {
+    },
+    setAttributes(_handle, _attributes) {
+    },
+    setStatus(_handle, _status) {
+    },
+    endSpan(_handle, _options) {
+    },
+    emitEvent(_handle, _name, _options) {
+    },
+    withSpan(_handle, fn) {
+      return fn();
+    },
+    getCurrentSpan() {
+      return null;
+    },
+    async flush() {
+      return false;
+    },
+    async readRange(_options) {
+      return {
+        otlp: createEmptyOtlpExport(),
+        clamped: false
+      };
+    },
+    async readRangeWire(options) {
+      return {
+        startTimeMs: BigInt(options.startMs),
+        endTimeMs: BigInt(options.endMs),
+        limit: Math.max(0, Math.min(U32_MAX, Math.floor(options.limit))),
+        clamped: false,
+        baseChunks: [],
+        chunks: []
+      };
+    }
+  };
+}
+
+export {
+  createNoopTraces
+};
+//# sourceMappingURL=chunk-2D7JND4Z.js.map

package/dist/tsup/chunk-2D7JND4Z.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/noop.ts"],"sourcesContent":["import type { OtlpExportTraceServiceRequestJson } from \"./otlp.js\";\nimport type {\n\tEndSpanOptions,\n\tEventOptions,\n\tReadRangeOptions,\n\tReadRangeResult,\n\tReadRangeWire,\n\tSpanHandle,\n\tSpanStatusInput,\n\tStartSpanOptions,\n\tTraces,\n\tUpdateSpanOptions,\n} from \"./types.js\";\n\nconst U32_MAX = 0xffff_ffff;\n\nconst NOOP_SPAN: SpanHandle = {\n\tspanId: new Uint8Array(8),\n\ttraceId: new Uint8Array(16),\n\tisActive: () => false,\n};\n\nfunction createEmptyOtlpExport(): OtlpExportTraceServiceRequestJson {\n\treturn {\n\t\tresourceSpans: [\n\t\t\t{\n\t\t\t\tscopeSpans: [{ spans: [] }],\n\t\t\t},\n\t\t],\n\t};\n}\n\n/**\n * Implements the Traces contract without persisting or exporting trace data.\n */\nexport function createNoopTraces(): Traces<OtlpExportTraceServiceRequestJson> {\n\treturn {\n\t\tstartSpan(_name: string, _options?: StartSpanOptions): SpanHandle {\n\t\t\treturn NOOP_SPAN;\n\t\t},\n\t\tupdateSpan(_handle: SpanHandle, _options: UpdateSpanOptions): void {},\n\t\tsetAttributes(\n\t\t\t_handle: SpanHandle,\n\t\t\t_attributes: Record<string, unknown>,\n\t\t): void {},\n\t\tsetStatus(_handle: SpanHandle, _status: SpanStatusInput): void {},\n\t\tendSpan(_handle: SpanHandle, _options?: EndSpanOptions): void {},\n\t\temitEvent(\n\t\t\t_handle: SpanHandle,\n\t\t\t_name: string,\n\t\t\t_options?: EventOptions,\n\t\t): void {},\n\t\twithSpan<T>(_handle: SpanHandle, fn: () => T): T {\n\t\t\treturn fn();\n\t\t},\n\t\tgetCurrentSpan(): SpanHandle | null {\n\t\t\treturn null;\n\t\t},\n\t\tasync flush(): Promise<boolean> {\n\t\t\treturn false;\n\t\t},\n\t\tasync readRange(\n\t\t\t_options: ReadRangeOptions,\n\t\t): Promise<ReadRangeResult<OtlpExportTraceServiceRequestJson>> {\n\t\t\treturn {\n\t\t\t\totlp: createEmptyOtlpExport(),\n\t\t\t\tclamped: false,\n\t\t\t};\n\t\t},\n\t\tasync readRangeWire(options: ReadRangeOptions): Promise<ReadRangeWire> {\n\t\t\treturn {\n\t\t\t\tstartTimeMs: BigInt(options.startMs),\n\t\t\t\tendTimeMs: BigInt(options.endMs),\n\t\t\t\tlimit: Math.max(0, Math.min(U32_MAX, Math.floor(options.limit))),\n\t\t\t\tclamped: false,\n\t\t\t\tbaseChunks: [],\n\t\t\t\tchunks: [],\n\t\t\t};\n\t\t},\n\t};\n}\n"],"mappings":";AAcA,IAAM,UAAU;AAEhB,IAAM,YAAwB;AAAA,EAC7B,QAAQ,IAAI,WAAW,CAAC;AAAA,EACxB,SAAS,IAAI,WAAW,EAAE;AAAA,EAC1B,UAAU,MAAM;AACjB;AAEA,SAAS,wBAA2D;AACnE,SAAO;AAAA,IACN,eAAe;AAAA,MACd;AAAA,QACC,YAAY,CAAC,EAAE,OAAO,CAAC,EAAE,CAAC;AAAA,MAC3B;AAAA,IACD;AAAA,EACD;AACD;AAKO,SAAS,mBAA8D;AAC7E,SAAO;AAAA,IACN,UAAU,OAAe,UAAyC;AACjE,aAAO;AAAA,IACR;AAAA,IACA,WAAW,SAAqB,UAAmC;AAAA,IAAC;AAAA,IACpE,cACC,SACA,aACO;AAAA,IAAC;AAAA,IACT,UAAU,SAAqB,SAAgC;AAAA,IAAC;AAAA,IAChE,QAAQ,SAAqB,UAAiC;AAAA,IAAC;AAAA,IAC/D,UACC,SACA,OACA,UACO;AAAA,IAAC;AAAA,IACT,SAAY,SAAqB,IAAgB;AAChD,aAAO,GAAG;AAAA,IACX;AAAA,IACA,iBAAoC;AACnC,aAAO;AAAA,IACR;AAAA,IACA,MAAM,QAA0B;AAC/B,aAAO;AAAA,IACR;AAAA,IACA,MAAM,UACL,UAC8D;AAC9D,aAAO;AAAA,QACN,MAAM,sBAAsB;AAAA,QAC5B,SAAS;AAAA,MACV;AAAA,IACD;AAAA,IACA,MAAM,cAAc,SAAmD;AACtE,aAAO;AAAA,QACN,aAAa,OAAO,QAAQ,OAAO;AAAA,QACnC,WAAW,OAAO,QAAQ,KAAK;AAAA,QAC/B,OAAO,KAAK,IAAI,GAAG,KAAK,IAAI,SAAS,KAAK,MAAM,QAAQ,KAAK,CAAC,CAAC;AAAA,QAC/D,SAAS;AAAA,QACT,YAAY,CAAC;AAAA,QACb,QAAQ,CAAC;AAAA,MACV;AAAA,IACD;AAAA,EACD;AACD;","names":[]}