@pellux/goodvibes-sdk 0.30.3 → 0.33.0

package/dist/platform/runtime/telemetry/api.js

@@ -1,8 +1,11 @@
 import { VERSION } from '../../version.js';
-import { sseSubscribers, telemetryBufferFill } from '../metrics.js';
+import { telemetryBufferFill } from '../metrics.js';
 import { normalizeError } from '../../utils/error-display.js';
 import { SpanKind as SpanKinds, SpanStatusCode } from './types.js';
-import { ALL_DOMAINS, appendBounded, buildAttributes, buildListResponse, buildOtlpLogDocumentFromRecords, buildOtlpMetricDocumentFromState, buildOtlpTraceDocumentFromSpans, buildRecordId, buildSpanCursor, buildSpanId, clampLimit, DEFAULT_ERROR_LIMIT, DEFAULT_EVENT_LIMIT, DEFAULT_SPAN_LIMIT, extractErrorCandidate, extractProvider, extractRecordSequence, inferErrorSource, inferSeverity, isErrorEventType, normalizePayload, normalizeTraceId, sanitizeRecord, sanitizeSpan, SERVICE_NAME, summarizePayload, toAttributeValue, toObjectMap, } from './api-helpers.js';
+import { ALL_DOMAINS, appendBounded, buildAttributes, buildListResponse, buildOtlpLogDocumentFromRecords, buildOtlpMetricDocumentFromState, buildOtlpTraceDocumentFromSpans, buildRecordId, buildSpanId, clampLimit, DEFAULT_ERROR_LIMIT, DEFAULT_EVENT_LIMIT, DEFAULT_SPAN_LIMIT, extractErrorCandidate, extractProvider, inferErrorSource, inferSeverity, isErrorEventType, normalizePayload, normalizeTraceId, SERVICE_NAME, summarizePayload, toAttributeValue, toObjectMap, } from './api-helpers.js';
+import { applyTelemetryRecordFilter, applyTelemetrySpanFilter, } from './api-query.js';
+import { createTelemetryEventStream } from './api-stream.js';
+import { ingestExternalTelemetryLogs, ingestExternalTelemetryMetrics, ingestExternalTelemetryTraces, } from './api-ingest.js';
 export class TelemetryApiService {
     runtimeBus;
     runtimeStore;
@@ -136,80 +139,28 @@ export class TelemetryApiService {
         return this.listSpanPage(filter, view, view === 'raw').items;
     }
     listEventPage(filter = {}, view = filter.view ?? 'safe', rawAccessible = view === 'raw') {
-        const { items, pageInfo } = this.applyRecordFilter(this.records, filter, view);
+        const { items, pageInfo } = applyTelemetryRecordFilter(this.records, filter, view);
         return buildListResponse(items, view, rawAccessible, pageInfo);
     }
     listErrorPage(filter = {}, view = filter.view ?? 'safe', rawAccessible = view === 'raw') {
-        const { items, pageInfo } = this.applyRecordFilter(this.errors, filter, view);
+        const { items, pageInfo } = applyTelemetryRecordFilter(this.errors, filter, view);
         return buildListResponse(items, view, rawAccessible, pageInfo);
     }
     listSpanPage(filter = {}, view = filter.view ?? 'safe', rawAccessible = view === 'raw') {
-        const { items, pageInfo } = this.applySpanFilter(filter, view);
+        const { items, pageInfo } = applyTelemetrySpanFilter(this.spans, filter, view);
         return buildListResponse(items, view, rawAccessible, pageInfo);
     }
     createStream(request, filter = {}, view = filter.view ?? 'safe', rawAccessible = view === 'raw') {
-        const encoder = new TextEncoder();
-        let unsub = () => { };
-        const requestedCursor = request.headers.get('last-event-id')?.trim() || filter.cursor;
-        if (requestedCursor) {
-            this.resolveCursor(this.records, requestedCursor);
-        }
-        // Shared teardown closure — called from both abort and cancel paths (PERF-04).
-        let teardown = () => { };
-        const stream = new ReadableStream({
-            start: (controller) => {
-                if (requestedCursor) {
-                    const replay = this.listEventPage({
-                        ...filter,
-                        cursor: requestedCursor,
-                        limit: clampLimit(filter.limit, 100),
-                    }, view, rawAccessible);
-                    for (const record of [...replay.items].reverse()) {
-                        controller.enqueue(encoder.encode(`id: ${record.id}\nevent: telemetry\ndata: ${JSON.stringify(record)}\n\n`));
-                    }
-                }
-                unsub = this.subscribe((record) => {
-                    if (!this.recordMatches(record, filter))
-                        return;
-                    const projected = sanitizeRecord(record, view);
-                    controller.enqueue(encoder.encode(`id: ${projected.id}\nevent: telemetry\ndata: ${JSON.stringify(projected)}\n\n`));
-                });
-                // C-1: update SSE subscriber gauge on open
-                sseSubscribers.set(this.subscribers.size, { stream_type: 'telemetry' });
-                const heartbeat = setInterval(() => {
-                    controller.enqueue(encoder.encode(': heartbeat\n\n'));
-                }, 15_000);
-                // Don't block clean process exit (PERF-07).
-                heartbeat.unref?.();
-                teardown = () => {
-                    clearInterval(heartbeat);
-                    unsub();
-                    // C-1: update SSE subscriber gauge on close
-                    sseSubscribers.set(this.subscribers.size, { stream_type: 'telemetry' });
-                };
-                request.signal.addEventListener('abort', () => {
-                    teardown();
-                    controller.close();
-                }, { once: true });
-                controller.enqueue(encoder.encode(`event: ready\ndata: ${JSON.stringify({
-                    version: 1,
-                    capabilities: this.getCapabilities(),
-                    view,
-                    rawAccessible,
-                    ...(requestedCursor ? { resumedFrom: requestedCursor } : {}),
-                })}\n\n`));
-            },
-            cancel: () => {
-                // PERF-04: cancel() path must also clear the heartbeat interval.
-                teardown();
-            },
-        });
-        return new Response(stream, {
-            headers: {
-                'content-type': 'text/event-stream',
-                'cache-control': 'no-cache',
-                connection: 'keep-alive',
-            },
+        return createTelemetryEventStream({
+            request,
+            filter,
+            view,
+            rawAccessible,
+            records: this.records,
+            listEventPage: (nextFilter, nextView, nextRawAccessible) => this.listEventPage(nextFilter, nextView, nextRawAccessible),
+            subscribe: (listener) => this.subscribe(listener),
+            getCapabilities: () => this.getCapabilities(),
+            getSubscriberCount: () => this.subscribers.size,
         });
     }
     buildOtlpTraceDocument(filter = {}, view = filter.view ?? 'safe') {
@@ -245,11 +196,11 @@ export class TelemetryApiService {
             timestamp: envelope.ts,
             severity: inferSeverity(envelope.type, normalizedError),
             traceId: normalizeTraceId(envelope.traceId),
-            sessionId: envelope.sessionId,
+            sessionId: envelope.sessionId ?? '',
             ...(envelope.turnId ? { turnId: envelope.turnId } : {}),
             ...(envelope.agentId ? { agentId: envelope.agentId } : {}),
             ...(envelope.taskId ? { taskId: envelope.taskId } : {}),
-            source: envelope.source,
+            source: envelope.source ?? '',
             message: summarizePayload(envelope.type, payload),
             payload,
             attributes,
@@ -262,7 +213,6 @@ export class TelemetryApiService {
             appendBounded(this.errors, record, this.errorLimit);
             this.errorCountsByCategory.set(normalizedError.category, (this.errorCountsByCategory.get(normalizedError.category) ?? 0) + 1);
         }
-        // C-1: update telemetry buffer fill gauge
         telemetryBufferFill.set(this.records.length / this.eventLimit);
         this.captureSyntheticSpan(record);
         this.notify(record);
@@ -442,101 +392,6 @@ export class TelemetryApiService {
         }
         return attributes;
     }
-    applyRecordFilter(records, filter, view) {
-        const filtered = records.filter((record) => this.recordMatches(record, filter));
-        filtered.sort((left, right) => {
-            const timestampDelta = right.timestamp - left.timestamp;
-            if (timestampDelta !== 0)
-                return timestampDelta;
-            return extractRecordSequence(right) - extractRecordSequence(left);
-        });
-        const limit = clampLimit(filter.limit, 100);
-        const startIndex = filter.cursor ? this.resolveCursor(filtered, filter.cursor) + 1 : 0;
-        const page = filtered.slice(startIndex, startIndex + limit);
-        const next = filtered[startIndex + limit];
-        return {
-            items: page.map((record) => sanitizeRecord(record, view)),
-            pageInfo: {
-                limit,
-                returned: page.length,
-                hasMore: Boolean(next),
-                ...(filter.cursor ? { cursor: filter.cursor } : {}),
-                ...(next ? { nextCursor: next.id } : {}),
-            },
-        };
-    }
-    applySpanFilter(filter, view) {
-        const normalizedTraceId = filter.traceId ? normalizeTraceId(filter.traceId) : undefined;
-        const filtered = this.spans.filter((span) => {
-            if (filter.since !== undefined && span.startTimeMs < filter.since)
-                return false;
-            if (filter.until !== undefined && span.endTimeMs > filter.until)
-                return false;
-            if (normalizedTraceId && span.spanContext.traceId !== normalizedTraceId)
-                return false;
-            if (filter.turnId !== undefined && span.attributes.turnId !== filter.turnId)
-                return false;
-            if (filter.agentId !== undefined && span.attributes.agentId !== filter.agentId)
-                return false;
-            if (filter.taskId !== undefined && span.attributes.taskId !== filter.taskId)
-                return false;
-            if (filter.eventTypes && filter.eventTypes.length > 0) {
-                const startEventType = typeof span.attributes.startEventType === 'string' ? span.attributes.startEventType : '';
-                if (!filter.eventTypes.includes(startEventType))
-                    return false;
-            }
-            return true;
-        }).sort((left, right) => right.endTimeMs - left.endTimeMs);
-        const limit = clampLimit(filter.limit, 100);
-        const startIndex = filter.cursor ? this.resolveSpanCursor(filtered, filter.cursor) + 1 : 0;
-        const page = filtered.slice(startIndex, startIndex + limit);
-        const next = filtered[startIndex + limit];
-        return {
-            items: page.map((span) => sanitizeSpan(span, view)),
-            pageInfo: {
-                limit,
-                returned: page.length,
-                hasMore: Boolean(next),
-                ...(filter.cursor ? { cursor: filter.cursor } : {}),
-                ...(next ? { nextCursor: buildSpanCursor(next) } : {}),
-            },
-        };
-    }
-    recordMatches(record, filter) {
-        if (filter.since !== undefined && record.timestamp < filter.since)
-            return false;
-        if (filter.until !== undefined && record.timestamp > filter.until)
-            return false;
-        if (filter.domains && filter.domains.length > 0 && !filter.domains.includes(record.domain))
-            return false;
-        if (filter.eventTypes && filter.eventTypes.length > 0 && !filter.eventTypes.includes(record.type))
-            return false;
-        if (filter.severity && record.severity !== filter.severity)
-            return false;
-        if (filter.traceId && record.traceId !== normalizeTraceId(filter.traceId))
-            return false;
-        if (filter.sessionId && record.sessionId !== filter.sessionId)
-            return false;
-        if (filter.turnId && record.turnId !== filter.turnId)
-            return false;
-        if (filter.agentId && record.agentId !== filter.agentId)
-            return false;
-        if (filter.taskId && record.taskId !== filter.taskId)
-            return false;
-        return true;
-    }
-    resolveCursor(records, cursor) {
-        const index = records.findIndex((record) => record.id === cursor);
-        if (index >= 0)
-            return index;
-        throw new Error(`Invalid telemetry cursor: ${cursor}`);
-    }
-    resolveSpanCursor(spans, cursor) {
-        const index = spans.findIndex((span) => buildSpanCursor(span) === cursor);
-        if (index >= 0)
-            return index;
-        throw new Error(`Invalid telemetry cursor: ${cursor}`);
-    }
     /**
      * Implement TelemetryIngestSink.ingestLogs — delegates to ingestExternalLogs.
      * Satisfies the interface expected by DaemonHttpRouterContext.ingestSink.
@@ -564,25 +419,13 @@ export class TelemetryApiService {
      * Call is synchronous and never throws.
      */
     ingestExternalLogs(payload) {
-        const resourceLogs = Array.isArray(payload['resourceLogs']) ? payload['resourceLogs'] : [];
-        for (const resource of resourceLogs) {
-            const scopeLogs = typeof resource === 'object' && resource !== null && Array.isArray(resource['scopeLogs'])
-                ? resource['scopeLogs']
-                : [];
-            for (const scope of scopeLogs) {
-                const logRecords = typeof scope === 'object' && scope !== null && Array.isArray(scope['logRecords'])
-                    ? scope['logRecords']
-                    : [];
-                for (const lr of logRecords) {
-                    const entry = typeof lr === 'object' && lr !== null ? lr : {};
-                    const record = this.buildIngestedRecord('OTLP_LOG_INGEST', entry);
-                    appendBounded(this.records, record, this.eventLimit);
-                    this.eventCountsByDomain.set('ops', (this.eventCountsByDomain.get('ops') ?? 0) + 1);
-                    this.eventCountsByType.set('OTLP_LOG_INGEST', (this.eventCountsByType.get('OTLP_LOG_INGEST') ?? 0) + 1);
-                    this.notify(record);
-                }
-            }
-        }
+        ingestExternalTelemetryLogs({
+            payload,
+            eventLimit: this.eventLimit,
+            records: this.records,
+            recordEvent: (type, record) => this.recordIngestedEvent(type, record),
+            nextSequence: () => this.seq++,
+        });
     }
     /**
      * Ingest an externally-received OTLP trace payload into this service's span
@@ -590,50 +433,16 @@ export class TelemetryApiService {
      * to a ReadableSpan and appended to `this.spans`, bounded by spanLimit.
      */
     ingestExternalTraces(payload) {
-        const resourceSpans = Array.isArray(payload['resourceSpans']) ? payload['resourceSpans'] : [];
-        let spansAppended = 0;
-        for (const resource of resourceSpans) {
-            const scopeSpans = typeof resource === 'object' && resource !== null && Array.isArray(resource['scopeSpans'])
-                ? resource['scopeSpans']
-                : [];
-            for (const scope of scopeSpans) {
-                const spans = typeof scope === 'object' && scope !== null && Array.isArray(scope['spans'])
-                    ? scope['spans']
-                    : [];
-                for (const sp of spans) {
-                    const entry = typeof sp === 'object' && sp !== null ? sp : {};
-                    const traceId = typeof entry['traceId'] === 'string' ? entry['traceId'] : normalizeTraceId(undefined);
-                    const spanId = typeof entry['spanId'] === 'string' ? entry['spanId'] : buildSpanId(`otlp:${this.seq}`);
-                    const name = typeof entry['name'] === 'string' ? entry['name'] : 'otlp.span';
-                    const startMs = typeof entry['startTimeUnixNano'] === 'number' ? Math.floor(entry['startTimeUnixNano'] / 1_000_000) : Date.now();
-                    const endMs = typeof entry['endTimeUnixNano'] === 'number' ? Math.floor(entry['endTimeUnixNano'] / 1_000_000) : startMs;
-                    const span = {
-                        name,
-                        kind: SpanKinds.INTERNAL,
-                        spanContext: { traceId, spanId, isValid: true },
-                        startTimeMs: startMs,
-                        endTimeMs: endMs,
-                        durationMs: endMs - startMs,
-                        attributes: {},
-                        events: [],
-                        status: { code: SpanStatusCode.UNSET },
-                        instrumentationScope: 'otlp-ingest',
-                    };
-                    appendBounded(this.spans, span, this.spanLimit);
-                    spansAppended++;
-                }
-            }
-        }
-        // Push a sentinel record into the event buffer only when at least one span
-        // was appended — empty payloads must not produce false-positive observability
-        // events on GET /api/v1/telemetry/events.
-        if (spansAppended === 0)
-            return;
-        const record = this.buildIngestedRecord('OTLP_TRACE_INGEST', payload);
-        appendBounded(this.records, record, this.eventLimit);
-        this.eventCountsByDomain.set('ops', (this.eventCountsByDomain.get('ops') ?? 0) + 1);
-        this.eventCountsByType.set('OTLP_TRACE_INGEST', (this.eventCountsByType.get('OTLP_TRACE_INGEST') ?? 0) + 1);
-        this.notify(record);
+        ingestExternalTelemetryTraces({
+            payload,
+            eventLimit: this.eventLimit,
+            records: this.records,
+            spanLimit: this.spanLimit,
+            spans: this.spans,
+            recordEvent: (type, record) => this.recordIngestedEvent(type, record),
+            nextSequence: () => this.seq++,
+            peekSequence: () => this.seq,
+        });
     }
     /**
      * Ingest an externally-received OTLP metrics payload. Creates a synthetic
@@ -642,65 +451,19 @@ export class TelemetryApiService {
      * Sentinel is only emitted when at least one metric datapoint is present.
      */
     ingestExternalMetrics(payload) {
-        // Count datapoints across all resourceMetrics -> scopeMetrics -> metrics -> dataPoints.
-        const resourceMetrics = Array.isArray(payload['resourceMetrics']) ? payload['resourceMetrics'] : [];
-        let datapointsFound = 0;
-        for (const resource of resourceMetrics) {
-            const scopeMetrics = typeof resource === 'object' && resource !== null && Array.isArray(resource['scopeMetrics'])
-                ? resource['scopeMetrics']
-                : [];
-            for (const scope of scopeMetrics) {
-                const metrics = typeof scope === 'object' && scope !== null && Array.isArray(scope['metrics'])
-                    ? scope['metrics']
-                    : [];
-                for (const metric of metrics) {
-                    if (typeof metric !== 'object' || metric === null)
-                        continue;
-                    const m = metric;
-                    // Datapoints may live under sum, gauge, histogram, exponentialHistogram, or summary.
-                    for (const signalKey of ['sum', 'gauge', 'histogram', 'exponentialHistogram', 'summary']) {
-                        const signal = m[signalKey];
-                        if (typeof signal === 'object' && signal !== null) {
-                            const dp = signal['dataPoints'];
-                            if (Array.isArray(dp))
-                                datapointsFound += dp.length;
-                        }
-                    }
-                }
-            }
-        }
-        // Emit sentinel only when at least one datapoint was present — empty
-        // payloads must not produce false-positive observability events.
-        if (datapointsFound === 0)
-            return;
-        const record = this.buildIngestedRecord('OTLP_METRICS_INGEST', payload);
-        appendBounded(this.records, record, this.eventLimit);
+        ingestExternalTelemetryMetrics({
+            payload,
+            eventLimit: this.eventLimit,
+            records: this.records,
+            recordEvent: (type, record) => this.recordIngestedEvent(type, record),
+            nextSequence: () => this.seq++,
+        });
+    }
+    recordIngestedEvent(type, record) {
         this.eventCountsByDomain.set('ops', (this.eventCountsByDomain.get('ops') ?? 0) + 1);
-        this.eventCountsByType.set('OTLP_METRICS_INGEST', (this.eventCountsByType.get('OTLP_METRICS_INGEST') ?? 0) + 1);
+        this.eventCountsByType.set(type, (this.eventCountsByType.get(type) ?? 0) + 1);
         this.notify(record);
     }
-    /**
-     * Build a synthetic TelemetryRecord for an externally-ingested OTLP payload.
-     * Domain is always 'telemetry'; source is 'otlp-ingest'.
-     */
-    buildIngestedRecord(type, payload) {
-        const domain = 'ops';
-        const now = Date.now();
-        const seq = this.seq++;
-        return {
-            id: `${domain}:${type}:${now}:${seq}`,
-            domain,
-            type,
-            timestamp: now,
-            severity: 'info',
-            traceId: normalizeTraceId(undefined),
-            sessionId: '',
-            source: 'otlp-ingest',
-            message: `OTLP ingest: ${type}`,
-            payload,
-            attributes: {},
-        };
-    }
     notify(record) {
         for (const subscriber of this.subscribers) {
             try {

package/dist/platform/runtime/telemetry/exporters/console.d.ts

@@ -15,7 +15,7 @@ export interface ConsoleExporterConfig {
      * - `standard` — adds attributes (default).
      * - `verbose` — adds events and full attribute values.
      */
-    readonly verbosity?: ConsoleVerbosity;
+    readonly verbosity?: ConsoleVerbosity | undefined;
 }
 /**
  * ConsoleExporter — prints span data to stderr for development.
@@ -31,11 +31,12 @@ export declare class ConsoleExporter implements SpanExporter {
     constructor(config?: ConsoleExporterConfig);
     /** Export spans by printing formatted summaries to stderr. */
     export(spans: ReadableSpan[]): Promise<void>;
-    /** Flush is a no-op for synchronous stderr writes. */
+    /** Flush is a no-op because this exporter does not own buffering. */
     flush(): Promise<void>;
     /** Shutdown is a no-op. */
     shutdown(): Promise<void>;
     /** Format a single span for console output. */
     private _format;
+    private _logSpanFailure;
 }
 //# sourceMappingURL=console.d.ts.map

package/dist/platform/runtime/telemetry/exporters/console.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/telemetry/exporters/console.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG9D,0CAA0C;AAC1C,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,CAAC;AAElE,yCAAyC;AACzC,MAAM,WAAW,qBAAqB;IACpC;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,gBAAgB,CAAC;CACvC;AAED;;;;;;;GAOG;AACH,qBAAa,eAAgB,YAAW,YAAY;IAClD,QAAQ,CAAC,IAAI,aAAa;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmB;gBAEjC,MAAM,GAAE,qBAA0B;IAI9C,8DAA8D;IACxD,MAAM,CAAC,KAAK,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAUlD,sDAAsD;IAChD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,2BAA2B;IACrB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAI/B,+CAA+C;IAC/C,OAAO,CAAC,OAAO;CAoDhB"}
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/telemetry/exporters/console.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAK9D,0CAA0C;AAC1C,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,CAAC;AAElE,yCAAyC;AACzC,MAAM,WAAW,qBAAqB;IACpC;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;CACnD;AAED;;;;;;;GAOG;AACH,qBAAa,eAAgB,YAAW,YAAY;IAClD,QAAQ,CAAC,IAAI,aAAa;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmB;gBAEjC,MAAM,GAAE,qBAA0B;IAI9C,8DAA8D;IACxD,MAAM,CAAC,KAAK,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBlD,qEAAqE;IAC/D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,2BAA2B;IACrB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAI/B,+CAA+C;IAC/C,OAAO,CAAC,OAAO;IAqDf,OAAO,CAAC,eAAe;CAQxB"}

package/dist/platform/runtime/telemetry/exporters/console.js

@@ -1,4 +1,6 @@
 import { SpanStatusCode } from '../types.js';
+import { summarizeError } from '../../../utils/error-display.js';
+import { logger } from '../../../utils/logger.js';
 /**
  * ConsoleExporter — prints span data to stderr for development.
  *
@@ -16,15 +18,27 @@ export class ConsoleExporter {
     /** Export spans by printing formatted summaries to stderr. */
     async export(spans) {
         for (const span of spans) {
+            let line;
             try {
-                process.stderr.write(this._format(span) + '\n');
+                line = this._format(span);
             }
-            catch {
-                // Writing to stderr should not throw but swallow any OS-level errors.
+            catch (err) {
+                this._logSpanFailure('[ConsoleExporter] span formatting failed', span, err);
+                continue;
+            }
+            try {
+                process.stderr.write(line + '\n', (err) => {
+                    if (err) {
+                        this._logSpanFailure('[ConsoleExporter] stderr write failed', span, err);
+                    }
+                });
+            }
+            catch (err) {
+                this._logSpanFailure('[ConsoleExporter] stderr write failed', span, err);
             }
         }
     }
-    /** Flush is a no-op for synchronous stderr writes. */
+    /** Flush is a no-op because this exporter does not own buffering. */
     async flush() {
         // Nothing buffered.
     }
@@ -73,4 +87,12 @@ export class ConsoleExporter {
         }
         return base + attrStr + eventsStr;
     }
+    _logSpanFailure(message, span, error) {
+        logger.warn(message, {
+            error: summarizeError(error),
+            spanName: span.name,
+            traceId: span.spanContext.traceId,
+            spanId: span.spanContext.spanId,
+        });
+    }
 }

package/dist/platform/runtime/telemetry/exporters/local-ledger.d.ts

@@ -10,13 +10,13 @@ export interface LocalLedgerConfig {
      * When the file exceeds this size, it is renamed to `<filePath>.1` and a
      * fresh file is started. Defaults to 10 MB.
      */
-    readonly maxFileSizeBytes?: number;
+    readonly maxFileSizeBytes?: number | undefined;
     /**
      * Optional path for the typed event ledger file.
      * When provided, `recordEvent()` appends `LedgerEntry` lines here.
      * Defaults to `<filePath>.ledger.jsonl`.
      */
-    readonly ledgerFilePath?: string;
+    readonly ledgerFilePath?: string | undefined;
 }
 /**
  * A single typed event entry in the replay ledger.
@@ -56,17 +56,17 @@ export declare class LocalLedgerExporter implements SpanExporter {
     private readonly ledgerFilePath;
     constructor(config: LocalLedgerConfig);
     /**
-     * Export a batch of spans as JSON lines (fire-and-forget).
+     * Export a batch of spans as JSON lines.
      *
-     * Intentionally not awaited by the tracer — failures are swallowed here
-     * and logged to avoid any runtime impact.
+     * Failures are logged and isolated from callers so exporter I/O cannot break
+     * runtime work.
      */
     export(spans: ReadableSpan[]): Promise<void>;
     /**
-     * Record a typed event entry to the ledger file (fire-and-forget).
+     * Record a typed event entry to the ledger file.
      *
      * Used by the deterministic replay engine to build a per-run event log.
-     * Failures are logged but never thrown.
+     * Failures are logged and isolated from callers.
      *
      * @param entry - The ledger entry to append.
      *

package/dist/platform/runtime/telemetry/exporters/local-ledger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"local-ledger.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/telemetry/exporters/local-ledger.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG9D,6CAA6C;AAC7C,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC;;;;OAIG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC1B,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,8EAA8E;IAC9E,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,uDAAuD;IACvD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,6CAA6C;IAC7C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,mEAAmE;IACnE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAID;;;;;;;;;;GAUG;AACH,qBAAa,mBAAoB,YAAW,YAAY;IACtD,QAAQ,CAAC,IAAI,kBAAkB;IAC/B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;gBAE5B,MAAM,EAAE,iBAAiB;IAMrC;;;;;OAKG;IACG,MAAM,CAAC,KAAK,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BlD;;;;;;;;;;;;;;OAcG;IACH,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAUrC;;;;;;;;OAQG;IACH,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,EAAE;IA4B5C;;OAEG;IACH,UAAU,IAAI,MAAM,EAAE;IA0BtB,2DAA2D;IACrD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,kDAAkD;IAC5C,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAI/B;;;OAGG;IACH,OAAO,CAAC,eAAe;CAYxB"}
+{"version":3,"file":"local-ledger.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/telemetry/exporters/local-ledger.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG9D,6CAA6C;AAC7C,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/C;;;;OAIG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9C;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC1B,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,8EAA8E;IAC9E,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,uDAAuD;IACvD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,6CAA6C;IAC7C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,mEAAmE;IACnE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAID;;;;;;;;;;GAUG;AACH,qBAAa,mBAAoB,YAAW,YAAY;IACtD,QAAQ,CAAC,IAAI,kBAAkB;IAC/B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;gBAE5B,MAAM,EAAE,iBAAiB;IAMrC;;;;;OAKG;IACG,MAAM,CAAC,KAAK,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA8ClD;;;;;;;;;;;;;;OAcG;IACH,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAerC;;;;;;;;OAQG;IACH,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,EAAE;IAgC5C;;OAEG;IACH,UAAU,IAAI,MAAM,EAAE;IA6BtB,2DAA2D;IACrD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,kDAAkD;IAC5C,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAI/B;;;OAGG;IACH,OAAO,CAAC,eAAe;CAkBxB"}