@pellux/goodvibes-sdk 0.18.3 → 0.18.12

package/dist/_internal/platform/runtime/telemetry/exporters/otlp.d.ts

@@ -0,0 +1,66 @@
+/**
+ * OTLP HTTP span exporter with fail-safe queue and retry.
+ *
+ * All exports are non-blocking — spans are enqueued immediately and
+ * exported asynchronously. Export failures are logged but never thrown.
+ * The runtime is never blocked by OTLP connectivity issues.
+ *
+ * Compatible with the OTLP/HTTP JSON format for traces (v1/traces).
+ */
+import type { ReadableSpan, SpanExporter } from '../types.js';
+import type { OtlpConfig } from './types.js';
+/**
+ * Non-blocking OTLP/HTTP span exporter.
+ *
+ * Spans are batched and exported via an internal fail-safe queue.
+ * The exporter never throws — failures are logged and retried per
+ * the configured retry policy.
+ *
+ * @example
+ * ```ts
+ * const exporter = new OtlpExporter({
+ *   endpoint: 'http://localhost:4318/v1/traces',
+ *   batchSize: 256,
+ *   timeoutMs: 8000,
+ *   headers: { 'x-api-key': 'my-token' },
+ * });
+ * ```
+ */
+export declare class OtlpExporter implements SpanExporter {
+    readonly name = "otlp";
+    private readonly _config;
+    private readonly _queue;
+    private readonly _pending;
+    constructor(config: OtlpConfig);
+    /**
+     * Accept completed spans.
+     *
+     * Spans are accumulated into the pending buffer. When the buffer
+     * reaches `batchSize`, a batch is enqueued for async export.
+     * Remaining spans are flushed on `flush()` or `shutdown()`.
+     *
+     * Never throws.
+     */
+    export(spans: ReadableSpan[]): Promise<void>;
+    /**
+     * Flush any pending (unbatched) spans and wait for queue to drain.
+     * Never throws.
+     */
+    flush(): Promise<void>;
+    /**
+     * Flush remaining spans and shut down the export queue.
+     * Best-effort — waits up to drainTimeoutMs.
+     * Never throws.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Performs the actual HTTP POST to the OTLP endpoint.
+     * Called exclusively by the ExportQueue — must not throw.
+     */
+    private _httpExport;
+    /**
+     * Result callback — logs failures without throwing.
+     */
+    private _onExportResult;
+}
+//# sourceMappingURL=otlp.d.ts.map

package/dist/_internal/platform/runtime/telemetry/exporters/otlp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otlp.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/telemetry/exporters/otlp.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAgB,MAAM,YAAY,CAAC;AAkF3D;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,YAAa,YAAW,YAAY;IAC/C,QAAQ,CAAC,IAAI,UAAU;IAEvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAEtB;IACF,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsB;gBAEnC,MAAM,EAAE,UAAU;IAyB9B;;;;;;;;OAQG;IACG,MAAM,CAAC,KAAK,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAYlD;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAY5B;;;;OAIG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAc/B;;;OAGG;YACW,WAAW;IA6BzB;;OAEG;IACH,OAAO,CAAC,eAAe;CAWxB"}

package/dist/_internal/platform/runtime/telemetry/exporters/otlp.js

@@ -0,0 +1,214 @@
+import { DEFAULT_OTLP_CONFIG, DEFAULT_QUEUE_CONFIG } from './types.js';
+import { ExportQueue } from './queue.js';
+/**
+ * Serialises a ReadableSpan[] into OTLP/HTTP JSON format (simplified).
+ *
+ * This produces a minimal protobuf-JSON compatible payload understood by
+ * OTLP receivers (e.g. OpenTelemetry Collector, Tempo, Jaeger v2).
+ */
+function serialiseSpans(spans) {
+    if (spans.length === 0)
+        return JSON.stringify({ resourceSpans: [] });
+    const resourceSpans = [
+        {
+            resource: {
+                attributes: [
+                    { key: 'service.name', value: { stringValue: 'goodvibes-sdk' } },
+                ],
+            },
+            scopeSpans: [
+                {
+                    scope: { name: spans[0].instrumentationScope ?? 'goodvibes-sdk' },
+                    spans: spans.map((s) => ({
+                        traceId: s.spanContext.traceId,
+                        spanId: s.spanContext.spanId,
+                        parentSpanId: s.parentSpanId ?? '',
+                        name: s.name,
+                        kind: s.kind,
+                        startTimeUnixNano: String(s.startTimeMs * 1_000_000),
+                        endTimeUnixNano: String(s.endTimeMs * 1_000_000),
+                        attributes: Object.entries(s.attributes).map(([key, value]) => ({
+                            key,
+                            value: attributeValue(value),
+                        })),
+                        events: s.events.map((e) => ({
+                            name: e.name,
+                            timeUnixNano: String(e.timestamp * 1_000_000),
+                            attributes: Object.entries(e.attributes ?? {}).map(([k, v]) => ({
+                                key: k,
+                                value: attributeValue(v),
+                            })),
+                        })),
+                        status: { code: s.status.code, message: s.status.message ?? '' },
+                    })),
+                },
+            ],
+        },
+    ];
+    return JSON.stringify({ resourceSpans });
+}
+/** Maps an AttributeValue to an OTLP AnyValue object. */
+function attributeValue(v) {
+    if (typeof v === 'string')
+        return { stringValue: v };
+    if (typeof v === 'number')
+        return { doubleValue: v };
+    if (typeof v === 'boolean')
+        return { boolValue: v };
+    if (Array.isArray(v)) {
+        if (v.length === 0)
+            return { arrayValue: { values: [] } };
+        const first = v[0];
+        if (typeof first === 'string')
+            return {
+                arrayValue: {
+                    values: v.map((s) => ({ stringValue: s })),
+                },
+            };
+        if (typeof first === 'number')
+            return {
+                arrayValue: {
+                    values: v.map((n) => ({ doubleValue: n })),
+                },
+            };
+        return {
+            arrayValue: {
+                values: v.map((b) => ({ boolValue: b })),
+            },
+        };
+    }
+    return { stringValue: String(v) };
+}
+/**
+ * Non-blocking OTLP/HTTP span exporter.
+ *
+ * Spans are batched and exported via an internal fail-safe queue.
+ * The exporter never throws — failures are logged and retried per
+ * the configured retry policy.
+ *
+ * @example
+ * ```ts
+ * const exporter = new OtlpExporter({
+ *   endpoint: 'http://localhost:4318/v1/traces',
+ *   batchSize: 256,
+ *   timeoutMs: 8000,
+ *   headers: { 'x-api-key': 'my-token' },
+ * });
+ * ```
+ */
+export class OtlpExporter {
+    name = 'otlp';
+    _config;
+    _queue;
+    _pending = [];
+    constructor(config) {
+        this._config = {
+            endpoint: config.endpoint,
+            batchSize: config.batchSize ?? DEFAULT_OTLP_CONFIG.batchSize,
+            timeoutMs: config.timeoutMs ?? DEFAULT_OTLP_CONFIG.timeoutMs,
+            headers: config.headers ?? {},
+        };
+        const queueConfig = {
+            ...DEFAULT_QUEUE_CONFIG,
+            ...config.queue,
+            retry: {
+                ...DEFAULT_QUEUE_CONFIG.retry,
+                ...config.queue?.retry,
+                ...config.retry,
+            },
+        };
+        this._queue = new ExportQueue((batch) => this._httpExport(batch), queueConfig, (result) => this._onExportResult(result));
+    }
+    /**
+     * Accept completed spans.
+     *
+     * Spans are accumulated into the pending buffer. When the buffer
+     * reaches `batchSize`, a batch is enqueued for async export.
+     * Remaining spans are flushed on `flush()` or `shutdown()`.
+     *
+     * Never throws.
+     */
+    async export(spans) {
+        try {
+            this._pending.push(...spans);
+            while (this._pending.length >= this._config.batchSize) {
+                const batch = this._pending.splice(0, this._config.batchSize);
+                this._queue.enqueue(batch);
+            }
+        }
+        catch (err) {
+            console.error('[OtlpExporter] export() error (non-fatal):', err);
+        }
+    }
+    /**
+     * Flush any pending (unbatched) spans and wait for queue to drain.
+     * Never throws.
+     */
+    async flush() {
+        try {
+            if (this._pending.length > 0) {
+                const batch = this._pending.splice(0);
+                this._queue.enqueue(batch);
+            }
+            await this._queue.drain();
+        }
+        catch (err) {
+            console.error('[OtlpExporter] flush() error (non-fatal):', err);
+        }
+    }
+    /**
+     * Flush remaining spans and shut down the export queue.
+     * Best-effort — waits up to drainTimeoutMs.
+     * Never throws.
+     */
+    async shutdown() {
+        try {
+            if (this._pending.length > 0) {
+                const batch = this._pending.splice(0);
+                this._queue.enqueue(batch);
+            }
+            await this._queue.shutdown();
+        }
+        catch (err) {
+            console.error('[OtlpExporter] shutdown() error (non-fatal):', err);
+        }
+    }
+    // ── Private HTTP transport ────────────────────────────────────────────────
+    /**
+     * Performs the actual HTTP POST to the OTLP endpoint.
+     * Called exclusively by the ExportQueue — must not throw.
+     */
+    async _httpExport(batch) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this._config.timeoutMs);
+        try {
+            const body = serialiseSpans(batch);
+            const response = await fetch(this._config.endpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...this._config.headers,
+                },
+                body,
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`OTLP endpoint returned HTTP ${response.status}: ${response.statusText}`);
+            }
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /**
+     * Result callback — logs failures without throwing.
+     */
+    _onExportResult(result) {
+        if (result.code === 'failure') {
+            console.error(`[OtlpExporter] Export failed permanently — ${result.spanCount} span(s) lost after ${result.attempts} attempt(s): ${result.error}`);
+        }
+        else if (result.code === 'dropped') {
+            console.warn(`[OtlpExporter] Dropped ${result.spanCount} span(s) due to queue overflow`);
+        }
+    }
+}

package/dist/_internal/platform/runtime/telemetry/exporters/queue.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Fail-safe, bounded export queue with exponential-backoff retry.
+ *
+ * Guarantees:
+ * - Never blocks the caller — all export work is dequeued asynchronously.
+ * - Never throws — all errors are caught and logged.
+ * - Drops oldest entries when full (back-pressure relief).
+ * - Drains best-effort on shutdown with a configurable timeout.
+ */
+import type { ReadableSpan } from '../types.js';
+import type { ExportQueueConfig, ExportResultCallback, ExportFn } from './types.js';
+/**
+ * Bounded in-memory export queue with retry and overflow protection.
+ *
+ * @example
+ * ```ts
+ * const queue = new ExportQueue(
+ *   async (batch) => {
+ *     await fetch('http://localhost:4318/v1/traces', {
+ *       method: 'POST',
+ *       body: JSON.stringify(batch),
+ *     });
+ *   },
+ *   { maxSize: 64, drainTimeoutMs: 3000, retry: { maxRetries: 2, baseDelayMs: 50, backoffFactor: 2, maxDelayMs: 1000 } },
+ * );
+ *
+ * queue.enqueue(spans);
+ * await queue.drain();
+ * ```
+ */
+export declare class ExportQueue {
+    private readonly _config;
+    private readonly _exportFn;
+    private readonly _onResult?;
+    /** Ring buffer holding pending batches. */
+    private readonly _ring;
+    private _head;
+    private _tail;
+    private _size;
+    /** True while a drain loop is running. */
+    private _draining;
+    /** True after shutdown() is called — no new enqueues accepted. */
+    private _shutdown;
+    /**
+     * @param exportFn - The actual export implementation. Must not throw.
+     * @param config - Queue configuration. Merged with defaults.
+     * @param onResult - Optional callback invoked after each export attempt.
+     */
+    constructor(exportFn: ExportFn<ReadableSpan>, config?: Partial<ExportQueueConfig>, onResult?: ExportResultCallback);
+    /** Number of batches currently in the queue. */
+    get size(): number;
+    /** Whether the queue is currently draining. */
+    get draining(): boolean;
+    /**
+     * Enqueue a batch of spans for export.
+     *
+     * - If the queue is full, the oldest entry is dropped to make room.
+     * - Starts the drain loop if not already running.
+     * - No-op after shutdown().
+     */
+    enqueue(batch: ReadableSpan[]): void;
+    /**
+     * Drain all queued batches best-effort, honouring drainTimeoutMs.
+     * Waits until the queue is empty or the timeout elapses.
+     */
+    drain(): Promise<void>;
+    /**
+     * Stop accepting new entries and drain remaining batches.
+     * Returns after drain completes or drainTimeoutMs elapses.
+     */
+    shutdown(): Promise<void>;
+    /** Starts the async drain loop if not already running. */
+    private _startDrainLoop;
+    /** Continuously drains entries until the queue is empty. */
+    private _drainLoop;
+    /** Dequeues and returns the oldest entry, or undefined if empty. */
+    private _dequeue;
+    /**
+     * Attempts to export a single batch with retry/backoff.
+     * Never throws.
+     */
+    private _processEntry;
+    /** Safely invokes the result callback without throwing. */
+    private _emitResult;
+}
+//# sourceMappingURL=queue.d.ts.map

package/dist/_internal/platform/runtime/telemetry/exporters/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/telemetry/exporters/queue.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EACV,iBAAiB,EAEjB,oBAAoB,EACpB,QAAQ,EAET,MAAM,YAAY,CAAC;AA2BpB;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAC5C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAyB;IACnD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAuB;IAElD,2CAA2C;IAC3C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgC;IACtD,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,KAAK,CAAK;IAElB,0CAA0C;IAC1C,OAAO,CAAC,SAAS,CAAS;IAC1B,kEAAkE;IAClE,OAAO,CAAC,SAAS,CAAS;IAE1B;;;;OAIG;gBAED,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC,EAChC,MAAM,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,EACnC,QAAQ,CAAC,EAAE,oBAAoB;IAYjC,gDAAgD;IAChD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,+CAA+C;IAC/C,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED;;;;;;OAMG;IACH,OAAO,CAAC,KAAK,EAAE,YAAY,EAAE,GAAG,IAAI;IA6BpC;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5B;;;OAGG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAO/B,0DAA0D;IAC1D,OAAO,CAAC,eAAe;IAOvB,4DAA4D;YAC9C,UAAU;IAgBxB,oEAAoE;IACpE,OAAO,CAAC,QAAQ;IAShB;;;OAGG;YACW,aAAa;IAyC3B,2DAA2D;IAC3D,OAAO,CAAC,WAAW;CAQpB"}

package/dist/_internal/platform/runtime/telemetry/exporters/queue.js

@@ -0,0 +1,212 @@
+import { DEFAULT_QUEUE_CONFIG } from './types.js';
+import { summarizeError } from '../../../utils/error-display.js';
+/**
+ * Computes the delay in milliseconds for a given retry attempt using
+ * exponential backoff with jitter (±10%).
+ */
+function computeDelay(attempt, config) {
+    const base = config.baseDelayMs * Math.pow(config.backoffFactor, attempt);
+    const capped = Math.min(base, config.maxDelayMs);
+    // Add ±10% jitter to avoid thundering-herd
+    const jitter = capped * 0.1 * (Math.random() * 2 - 1);
+    return Math.max(0, Math.round(capped + jitter));
+}
+/** Awaitable sleep. */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Bounded in-memory export queue with retry and overflow protection.
+ *
+ * @example
+ * ```ts
+ * const queue = new ExportQueue(
+ *   async (batch) => {
+ *     await fetch('http://localhost:4318/v1/traces', {
+ *       method: 'POST',
+ *       body: JSON.stringify(batch),
+ *     });
+ *   },
+ *   { maxSize: 64, drainTimeoutMs: 3000, retry: { maxRetries: 2, baseDelayMs: 50, backoffFactor: 2, maxDelayMs: 1000 } },
+ * );
+ *
+ * queue.enqueue(spans);
+ * await queue.drain();
+ * ```
+ */
+export class ExportQueue {
+    _config;
+    _exportFn;
+    _onResult;
+    /** Ring buffer holding pending batches. */
+    _ring;
+    _head = 0;
+    _tail = 0;
+    _size = 0;
+    /** True while a drain loop is running. */
+    _draining = false;
+    /** True after shutdown() is called — no new enqueues accepted. */
+    _shutdown = false;
+    /**
+     * @param exportFn - The actual export implementation. Must not throw.
+     * @param config - Queue configuration. Merged with defaults.
+     * @param onResult - Optional callback invoked after each export attempt.
+     */
+    constructor(exportFn, config, onResult) {
+        this._config = {
+            ...DEFAULT_QUEUE_CONFIG,
+            ...config,
+            retry: { ...DEFAULT_QUEUE_CONFIG.retry, ...config?.retry },
+        };
+        this._exportFn = exportFn;
+        this._onResult = onResult;
+        this._ring = new Array(this._config.maxSize);
+    }
+    /** Number of batches currently in the queue. */
+    get size() {
+        return this._size;
+    }
+    /** Whether the queue is currently draining. */
+    get draining() {
+        return this._draining;
+    }
+    /**
+     * Enqueue a batch of spans for export.
+     *
+     * - If the queue is full, the oldest entry is dropped to make room.
+     * - Starts the drain loop if not already running.
+     * - No-op after shutdown().
+     */
+    enqueue(batch) {
+        if (this._shutdown)
+            return;
+        if (batch.length === 0)
+            return;
+        if (this._size >= this._config.maxSize) {
+            // Drop oldest — advance head
+            const dropped = this._ring[this._head];
+            this._head = (this._head + 1) % this._config.maxSize;
+            this._size--;
+            if (dropped) {
+                this._emitResult({
+                    code: 'dropped',
+                    spanCount: dropped.batch.length,
+                    attempts: 0,
+                    completedAt: Date.now(),
+                });
+            }
+            console.warn(`[ExportQueue] Queue overflow — dropped oldest batch (size=${this._config.maxSize})`);
+        }
+        this._ring[this._tail] = { batch, enqueuedAt: Date.now() };
+        this._tail = (this._tail + 1) % this._config.maxSize;
+        this._size++;
+        this._startDrainLoop();
+    }
+    /**
+     * Drain all queued batches best-effort, honouring drainTimeoutMs.
+     * Waits until the queue is empty or the timeout elapses.
+     */
+    async drain() {
+        if (this._size === 0)
+            return;
+        const deadline = Date.now() + this._config.drainTimeoutMs;
+        while (this._size > 0 && Date.now() < deadline) {
+            await sleep(10);
+        }
+    }
+    /**
+     * Stop accepting new entries and drain remaining batches.
+     * Returns after drain completes or drainTimeoutMs elapses.
+     */
+    async shutdown() {
+        this._shutdown = true;
+        await this.drain();
+    }
+    // ── Private drain loop ───────────────────────────────────────────────────
+    /** Starts the async drain loop if not already running. */
+    _startDrainLoop() {
+        if (this._draining)
+            return;
+        this._draining = true;
+        // Fire-and-forget — errors are swallowed inside _processNext
+        void this._drainLoop();
+    }
+    /** Continuously drains entries until the queue is empty. */
+    async _drainLoop() {
+        try {
+            while (this._size > 0) {
+                const entry = this._dequeue();
+                if (entry === undefined)
+                    break;
+                await this._processEntry(entry);
+            }
+        }
+        finally {
+            this._draining = false;
+            // If more entries arrived during the final iteration, restart
+            if (this._size > 0) {
+                this._startDrainLoop();
+            }
+        }
+    }
+    /** Dequeues and returns the oldest entry, or undefined if empty. */
+    _dequeue() {
+        if (this._size === 0)
+            return undefined;
+        const entry = this._ring[this._head];
+        this._ring[this._head] = undefined;
+        this._head = (this._head + 1) % this._config.maxSize;
+        this._size--;
+        return entry;
+    }
+    /**
+     * Attempts to export a single batch with retry/backoff.
+     * Never throws.
+     */
+    async _processEntry(entry) {
+        const { maxRetries } = this._config.retry;
+        let lastError;
+        let attempts = 0;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                await this._exportFn(entry.batch);
+                this._emitResult({
+                    code: 'success',
+                    spanCount: entry.batch.length,
+                    attempts,
+                    completedAt: Date.now(),
+                });
+                return;
+            }
+            catch (err) {
+                attempts++;
+                lastError = summarizeError(err);
+                if (attempt < maxRetries) {
+                    const delay = computeDelay(attempt, this._config.retry);
+                    console.warn(`[ExportQueue] Export attempt ${attempt + 1} failed — retrying in ${delay}ms: ${lastError}`);
+                    await sleep(delay);
+                }
+            }
+        }
+        // All retries exhausted
+        console.error(`[ExportQueue] Export failed after ${attempts} attempt(s) — dropping batch of ${entry.batch.length} span(s): ${lastError}`);
+        this._emitResult({
+            code: 'failure',
+            spanCount: entry.batch.length,
+            attempts,
+            error: lastError,
+            completedAt: Date.now(),
+        });
+    }
+    /** Safely invokes the result callback without throwing. */
+    _emitResult(result) {
+        if (this._onResult === undefined)
+            return;
+        try {
+            this._onResult(result);
+        }
+        catch {
+            // Result callback must not propagate
+        }
+    }
+}

package/dist/_internal/platform/runtime/telemetry/exporters/types.d.ts

@@ -0,0 +1,92 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * Type definitions for the fail-safe OTel export pipeline.
+ *
+ * These types are self-contained and do not depend on @opentelemetry packages.
+ * They cover the export queue, retry configuration, and OTLP exporter settings.
+ */
+/** Exponential backoff configuration for export retry. */
+export interface RetryConfig {
+    /** Maximum number of retry attempts after an initial failure. Default: 3. */
+    readonly maxRetries: number;
+    /** Base delay in milliseconds before the first retry. Default: 100. */
+    readonly baseDelayMs: number;
+    /** Multiplier applied to delay after each failure. Default: 2. */
+    readonly backoffFactor: number;
+    /** Maximum delay in milliseconds between retries. Default: 5000. */
+    readonly maxDelayMs: number;
+}
+/** Default retry configuration. */
+export declare const DEFAULT_RETRY_CONFIG: RetryConfig;
+/** Configuration for the fail-safe ExportQueue. */
+export interface ExportQueueConfig {
+    /**
+     * Maximum number of span batches held in the queue.
+     * When full, oldest entries are dropped. Default: 128.
+     */
+    readonly maxSize: number;
+    /** Retry configuration for failed exports. */
+    readonly retry: RetryConfig;
+    /**
+     * Maximum time in milliseconds to wait for a drain during shutdown.
+     * Default: 5000.
+     */
+    readonly drainTimeoutMs: number;
+}
+/** Default export queue configuration. */
+export declare const DEFAULT_QUEUE_CONFIG: ExportQueueConfig;
+/** Result of a single export attempt. */
+export type ExportResultCode = 'success' | 'failure' | 'dropped';
+/** Outcome of an export attempt. */
+export interface ExportResult {
+    /** Whether the export succeeded, failed, or was dropped. */
+    readonly code: ExportResultCode;
+    /** Number of spans in the batch. */
+    readonly spanCount: number;
+    /** Number of retry attempts made (0 = first attempt succeeded). */
+    readonly attempts: number;
+    /** Error message if the export failed after all retries. */
+    readonly error?: string;
+    /** Epoch ms when the export completed. */
+    readonly completedAt: number;
+}
+/** Configuration for the OtlpExporter. */
+export interface OtlpConfig {
+    /**
+     * OTLP HTTP endpoint URL.
+     * Example: 'http://localhost:4318/v1/traces'
+     */
+    readonly endpoint: string;
+    /**
+     * Maximum number of spans per export batch.
+     * Default: 512.
+     */
+    readonly batchSize: number;
+    /**
+     * Timeout in milliseconds for each HTTP export attempt.
+     * Default: 10000.
+     */
+    readonly timeoutMs: number;
+    /**
+     * Optional HTTP headers to include in OTLP requests
+     * (e.g. authentication tokens).
+     */
+    readonly headers?: Record<string, string>;
+    /** Export queue configuration. Defaults to DEFAULT_QUEUE_CONFIG. */
+    readonly queue?: Partial<ExportQueueConfig>;
+    /** Retry configuration. Overrides queue.retry when provided. */
+    readonly retry?: Partial<RetryConfig>;
+}
+/** Default OTLP exporter configuration. */
+export declare const DEFAULT_OTLP_CONFIG: {
+    readonly batchSize: 512;
+    readonly timeoutMs: 10000;
+};
+/**
+ * A function that performs the actual export of a span batch.
+ * Must not throw — all errors must be caught internally.
+ */
+export type ExportFn<T> = (batch: T[]) => Promise<void>;
+/** Callback invoked after each export attempt (for observability). */
+export type ExportResultCallback = (result: ExportResult) => void;
+//# sourceMappingURL=types.d.ts.map

package/dist/_internal/platform/runtime/telemetry/exporters/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/telemetry/exporters/types.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF;;;;;GAKG;AAIH,0DAA0D;AAC1D,MAAM,WAAW,WAAW;IAC1B,6EAA6E;IAC7E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,uEAAuE;IACvE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,kEAAkE;IAClE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,oEAAoE;IACpE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,mCAAmC;AACnC,eAAO,MAAM,oBAAoB,EAAE,WAKzB,CAAC;AAIX,mDAAmD;AACnD,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,8CAA8C;IAC9C,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAED,0CAA0C;AAC1C,eAAO,MAAM,oBAAoB,EAAE,iBAIzB,CAAC;AAIX,yCAAyC;AACzC,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAEjE,oCAAoC;AACpC,MAAM,WAAW,YAAY;IAC3B,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,oCAAoC;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,mEAAmE;IACnE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,4DAA4D;IAC5D,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,0CAA0C;IAC1C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAID,0CAA0C;AAC1C,MAAM,WAAW,UAAU;IACzB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,oEAAoE;IACpE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAC5C,gEAAgE;IAChE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;CACvC;AAED,2CAA2C;AAC3C,eAAO,MAAM,mBAAmB;;;CAGtB,CAAC;AAIX;;;GAGG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAExD,sEAAsE;AACtE,MAAM,MAAM,oBAAoB,GAAG,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC"}