@provide-io/telemetry 0.2.2

package/dist/logger.js

@@ -0,0 +1,254 @@
+// SPDX-FileCopyrightText: Copyright (c) 2025-2026 provide.io llc. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Structured logger — wraps pino with:
+ *   - browser.write hook in actual browsers; custom stream in Node.js/Vitest
+ *   - window.__pinoLogs capture for Playwright/devtools inspection
+ *   - Automatic context binding (from bindContext())
+ *   - Automatic OTEL trace_id/span_id injection
+ *   - PII sanitization
+ *   - msg fallback: if msg is empty, defaults to obj.event
+ *
+ * Mirrors Python provide.telemetry get_logger().
+ */
+import pino from 'pino';
+import { getConfig } from './config';
+import { getContext } from './context';
+import { computeErrorFingerprint } from './fingerprint';
+import { formatPretty, supportsColor } from './pretty';
+import { emitLogRecord } from './otel-logs';
+import { sanitizePayload } from './pii';
+import { sanitize } from './sanitize';
+import { EventSchemaError, validateEventName, validateRequiredKeys } from './schema';
+import { getActiveTraceIds } from './tracing';
+/** Pino level number → console method name. */
+const LEVEL_MAP = {
+    10: 'trace',
+    20: 'debug',
+    30: 'log',
+    40: 'warn',
+    50: 'error',
+    60: 'error',
+};
+// Pino root instance — lazily created so config is read after setupTelemetry().
+let _root = null;
+/**
+ * Build the write hook that enriches, sanitizes, captures, and optionally
+ * emits each log record.  Config is read dynamically on every invocation so
+ * that resetTelemetryState() + setupTelemetry() changes take effect without
+ * needing to rebuild the hook closure.
+ */
+export function makeWriteHook() {
+    // pino's WriteFn signature uses `object`; we cast internally for safe property access.
+    return (obj) => {
+        // Read config dynamically — avoids stale-capture bug after _resetConfig().
+        const cfg = getConfig();
+        const o = obj;
+        // Inject OTEL trace/span IDs if an active span exists.
+        const ids = getActiveTraceIds();
+        if (ids.trace_id)
+            o['trace_id'] = ids.trace_id;
+        if (ids.span_id)
+            o['span_id'] = ids.span_id;
+        // Merge module-level context bindings.
+        Object.assign(o, getContext());
+        // Ensure msg is always non-empty — pino sets msg='' when no string arg is passed.
+        if (!o['msg'])
+            o['msg'] = o['event'] ?? '';
+        // Caller info injection — intentionally expensive (creates Error per call).
+        // Stryker disable all
+        if (cfg.logIncludeCaller) {
+            const err = new Error();
+            const stack = err.stack?.split('\n');
+            /* v8 ignore next -- stack is always defined in V8 */
+            if (stack) {
+                for (const frame of stack.slice(1)) {
+                    if (!frame.includes('logger.ts') &&
+                        !frame.includes('node_modules') &&
+                        !frame.includes('pino')) {
+                        const match = frame.match(/\((.+):(\d+):\d+\)/) ?? frame.match(/at (.+):(\d+):\d+/);
+                        /* v8 ignore next -- match always succeeds for V8 stack frames */
+                        if (match) {
+                            o['caller_file'] = match[1].replace(/^.*\//, ''); // basename only
+                            o['caller_line'] = Number(match[2]);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        // Stryker enable all
+        // Error fingerprinting — stable hash from error name + stack.
+        const errObj = o['err'];
+        const excName = (o['exc_name'] ?? o['exception'] ?? errObj?.['type'] ?? errObj?.['name']);
+        if (excName) {
+            const stack = (errObj?.['stack'] ?? o['stack']);
+            o['error_fingerprint'] = computeErrorFingerprint(String(excName), stack);
+        }
+        // PII sanitization: blocked keys + secret detection + custom PII rules.
+        if (cfg.logSanitize) {
+            sanitize(o, cfg.sanitizeFields);
+            sanitizePayload(o, [], { maxDepth: cfg.piiMaxDepth });
+        }
+        // Strip timestamp when configured off.
+        if (!cfg.logIncludeTimestamp) {
+            delete o['time'];
+        }
+        // Schema validation — drop records that violate strict schema rules.
+        /* v8 ignore next -- V8 cannot fully attribute all ?? branches in a single expression */
+        if (cfg.strictSchema) {
+            const event = String(o['event'] ?? o['msg'] ?? '');
+            if (event) {
+                try {
+                    validateEventName(event);
+                }
+                catch (e) {
+                    if (e instanceof EventSchemaError)
+                        return;
+                    throw e;
+                }
+            }
+            if (cfg.requiredLogKeys.length > 0) {
+                try {
+                    validateRequiredKeys(o, cfg.requiredLogKeys);
+                }
+                catch (e) {
+                    if (e instanceof EventSchemaError)
+                        return;
+                    throw e;
+                }
+            }
+        }
+        // Export to OTLP when a log provider is registered (noop otherwise).
+        emitLogRecord(o);
+        // Capture to window.__pinoLogs for Playwright and devtools inspection.
+        // Check is done inline (not at module load) so it works when loaded in Node.js
+        // test environments that later gain a jsdom window.
+        if (typeof window !== 'undefined' && cfg.captureToWindow) {
+            if (!('__pinoLogs' in window)) {
+                window['__pinoLogs'] = [];
+            }
+            window['__pinoLogs'].push(o);
+        }
+        // Emit to console only when explicitly enabled (opt-in).
+        if (cfg.consoleOutput) {
+            const method = LEVEL_MAP[o['level']] ?? 'log';
+            if (cfg.logFormat === 'pretty') {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                console[method](formatPretty(o, supportsColor()));
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                console[method](o);
+            }
+        }
+    };
+}
+function getRootLogger() {
+    // Stryker disable next-line ConditionalExpression
+    if (_root)
+        return _root;
+    const cfg = getConfig();
+    const hook = makeWriteHook();
+    // pino only invokes browser.write when process.version is absent (real browser).
+    // In Node.js / Vitest, we use a custom destination stream that forwards every
+    // serialised log line back through the write hook.
+    // Stryker disable all
+    const isNodeEnv = typeof process !== 'undefined' && typeof process.version === 'string';
+    /* c8 ignore else */
+    if (isNodeEnv) {
+        const stream = {
+            write(msg) {
+                try {
+                    hook(JSON.parse(msg.trimEnd()));
+                }
+                catch {
+                    // Ignore malformed lines (e.g. pino flush sentinels).
+                }
+            },
+        };
+        _root = pino({
+            base: { service: cfg.serviceName, env: cfg.environment, version: cfg.version },
+            level: cfg.logLevel,
+        }, stream);
+    }
+    else {
+        /* c8 ignore next 8 */
+        _root = pino({
+            base: { service: cfg.serviceName, env: cfg.environment, version: cfg.version },
+            level: cfg.logLevel,
+            browser: {
+                write: hook,
+            },
+        });
+    }
+    // Stryker enable all
+    return _root;
+}
+function adaptPino(pinoLogger) {
+    // Stryker disable all
+    return {
+        trace: (obj, msg) => pinoLogger.trace(obj, msg ?? ''),
+        debug: (obj, msg) => pinoLogger.debug(obj, msg ?? ''),
+        info: (obj, msg) => pinoLogger.info(obj, msg ?? ''),
+        warn: (obj, msg) => pinoLogger.warn(obj, msg ?? ''),
+        error: (obj, msg) => pinoLogger.error(obj, msg ?? ''),
+        child: (bindings) => adaptPino(pinoLogger.child(bindings)),
+    };
+    // Stryker enable all
+}
+/**
+ * Find the longest-prefix match in logModuleLevels for the given logger name.
+ * Returns the matched level string, or undefined if no match.
+ * Mirrors Python _LevelFilter longest-prefix matching.
+ */
+function findModuleLevel(name, moduleLevels) {
+    let bestMatch;
+    let bestLen = -1;
+    for (const prefix of Object.keys(moduleLevels)) {
+        if ((prefix === '' || name === prefix || name.startsWith(prefix + '.')) &&
+            prefix.length > bestLen) {
+            bestMatch = prefix;
+            bestLen = prefix.length;
+        }
+    }
+    return bestMatch !== undefined ? moduleLevels[bestMatch] : undefined;
+}
+/**
+ * Return a logger for the given name.
+ * Name appears as the `name` field in every log record.
+ * Mirrors Python: get_logger(name)
+ */
+export function getLogger(name) {
+    const root = getRootLogger();
+    // Stryker disable next-line ObjectLiteral
+    const pinoLogger = name ? root.child({ name }) : root;
+    // Apply per-module level overrides (longest-prefix match).
+    if (name) {
+        const cfg = getConfig();
+        const moduleLevels = cfg.logModuleLevels;
+        if (Object.keys(moduleLevels).length > 0) {
+            const level = findModuleLevel(name, moduleLevels);
+            if (level) {
+                pinoLogger.level = level.toLowerCase();
+            }
+        }
+    }
+    return adaptPino(pinoLogger);
+}
+/** Reset the root logger (forces re-creation with current config on next call). */
+// Stryker disable next-line BlockStatement
+export function _resetRootLogger() {
+    _root = null;
+}
+/** Module-level lazy singleton logger. Mirrors Python: logger = get_logger('default'). */
+// Stryker disable all
+export const logger = {
+    trace: (obj, msg) => getLogger('default').trace(obj, msg),
+    debug: (obj, msg) => getLogger('default').debug(obj, msg),
+    info: (obj, msg) => getLogger('default').info(obj, msg),
+    warn: (obj, msg) => getLogger('default').warn(obj, msg),
+    error: (obj, msg) => getLogger('default').error(obj, msg),
+    child: (bindings) => getLogger('default').child(bindings),
+};
+// Stryker enable all

package/dist/metrics.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Metric instruments — mirrors Python provide.telemetry counter/gauge/histogram.
+ *
+ * Backed by @opentelemetry/api which provides no-op instruments when no SDK is registered.
+ * Safe to call in any environment; instruments are always callable without setup.
+ *
+ * Wrapper classes gate every `.add()`/`.record()` call through sampling + backpressure,
+ * matching the Python fallback.py pattern.
+ */
+import { type Attributes, type Counter, type Histogram, type Meter, type UpDownCounter } from '@opentelemetry/api';
+export type { Counter, Histogram, Meter, UpDownCounter };
+export interface MetricOptions {
+    description?: string;
+    unit?: string;
+}
+/**
+ * Wrapper around OTel Counter that gates add() through sampling + backpressure.
+ */
+export declare class CounterInstrument {
+    readonly name: string;
+    private readonly _inner;
+    private _value;
+    constructor(name: string, inner: Counter);
+    /** Cumulative counter value (in-process; useful for testing and health checks). */
+    get value(): number;
+    add(value: number, attributes?: Attributes): void;
+}
+/**
+ * Wrapper around OTel UpDownCounter with set semantics.
+ * Gates add()/set() through sampling + backpressure.
+ */
+export declare class GaugeInstrument {
+    readonly name: string;
+    private readonly _inner;
+    private readonly _values;
+    private _lastValue;
+    constructor(name: string, inner: UpDownCounter);
+    /** Most recent value set or accumulated via add() (in-process; useful for testing and health checks). */
+    get value(): number;
+    add(value: number, attributes?: Attributes): void;
+    set(value: number, attributes?: Attributes): void;
+}
+/**
+ * Wrapper around OTel Histogram that gates record() through sampling + backpressure.
+ */
+export declare class HistogramInstrument {
+    readonly name: string;
+    private readonly _inner;
+    private _count;
+    private _total;
+    constructor(name: string, inner: Histogram);
+    /** Number of values recorded (in-process; useful for testing and health checks). */
+    get count(): number;
+    /** Sum of all recorded values (in-process; useful for testing and health checks). */
+    get total(): number;
+    record(value: number, attributes?: Attributes): void;
+}
+/**
+ * Create a monotonically increasing counter.
+ * Mirrors Python: counter(name, description, unit)
+ */
+export declare function counter(name: string, options?: MetricOptions): CounterInstrument;
+/**
+ * Create an up-down counter (gauge — can increase or decrease).
+ * Mirrors Python: gauge(name, description, unit)
+ */
+export declare function gauge(name: string, options?: MetricOptions): GaugeInstrument;
+/**
+ * Create a histogram for recording distributions (latencies, sizes).
+ * Mirrors Python: histogram(name, description, unit)
+ */
+export declare function histogram(name: string, options?: MetricOptions): HistogramInstrument;
+/**
+ * Return an OTEL Meter from the global meter provider.
+ * Mirrors Python: get_meter(name)
+ */
+export declare function getMeter(name?: string): Meter;
+//# sourceMappingURL=metrics.d.ts.map

package/dist/metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../src/metrics.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AAEH,OAAO,EACL,KAAK,UAAU,EACf,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,KAAK,EACV,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAC;AAM5B,YAAY,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,aAAa,EAAE,CAAC;AAKzD,MAAM,WAAW,aAAa;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,qBAAa,iBAAiB;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAU;IACjC,OAAO,CAAC,MAAM,CAAK;gBAEP,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;IAKxC,mFAAmF;IACnF,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,UAAU,GAAG,IAAI;CAiBlD;AAED;;;GAGG;AACH,qBAAa,eAAe;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAC1D,OAAO,CAAC,UAAU,CAAK;gBAEX,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa;IAK9C,yGAAyG;IACzG,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,UAAU,GAAG,IAAI;IAajD,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,UAAU,GAAG,IAAI;CAiBlD;AAED;;GAEG;AACH,qBAAa,mBAAmB;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAY;IACnC,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,MAAM,CAAK;gBAEP,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS;IAK1C,oFAAoF;IACpF,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,qFAAqF;IACrF,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,UAAU,GAAG,IAAI;CAkBrD;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,iBAAiB,CAGhF;AAED;;;GAGG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,eAAe,CAG5E;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,mBAAmB,CAGpF;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,CAG7C"}

package/dist/metrics.js

@@ -0,0 +1,238 @@
+// SPDX-FileCopyrightText: Copyright (c) 2025-2026 provide.io llc. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Metric instruments — mirrors Python provide.telemetry counter/gauge/histogram.
+ *
+ * Backed by @opentelemetry/api which provides no-op instruments when no SDK is registered.
+ * Safe to call in any environment; instruments are always callable without setup.
+ *
+ * Wrapper classes gate every `.add()`/`.record()` call through sampling + backpressure,
+ * matching the Python fallback.py pattern.
+ */
+import { metrics, } from '@opentelemetry/api';
+import { shouldSample } from './sampling';
+import { tryAcquire, release } from './backpressure';
+import { getActiveTraceIds } from './tracing';
+import { getConfig } from './config';
+// Stryker disable next-line StringLiteral: meter name not observable with no-op OTEL SDK in tests
+const METER_NAME = '@provide-io/telemetry';
+/**
+ * Wrapper around OTel Counter that gates add() through sampling + backpressure.
+ */
+export class CounterInstrument {
+    constructor(name, inner) {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_inner", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        this.name = name;
+        this._inner = inner;
+    }
+    /** Cumulative counter value (in-process; useful for testing and health checks). */
+    get value() {
+        return this._value;
+    }
+    add(value, attributes) {
+        if (!getConfig().metricsEnabled)
+            return;
+        if (!shouldSample('metrics', this.name))
+            return;
+        const ticket = tryAcquire('metrics');
+        if (!ticket)
+            return;
+        try {
+            const ids = getActiveTraceIds();
+            const enriched = ids.trace_id && ids.span_id
+                ? { ...attributes, trace_id: ids.trace_id, span_id: ids.span_id }
+                : attributes;
+            this._inner.add(value, enriched);
+            this._value += value;
+        }
+        finally {
+            release(ticket);
+        }
+    }
+}
+/**
+ * Wrapper around OTel UpDownCounter with set semantics.
+ * Gates add()/set() through sampling + backpressure.
+ */
+export class GaugeInstrument {
+    constructor(name, inner) {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_inner", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_values", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "_lastValue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        this.name = name;
+        this._inner = inner;
+    }
+    /** Most recent value set or accumulated via add() (in-process; useful for testing and health checks). */
+    get value() {
+        return this._lastValue;
+    }
+    add(value, attributes) {
+        if (!getConfig().metricsEnabled)
+            return;
+        if (!shouldSample('metrics', this.name))
+            return;
+        const ticket = tryAcquire('metrics');
+        if (!ticket)
+            return;
+        try {
+            this._inner.add(value, attributes);
+            this._lastValue += value;
+        }
+        finally {
+            release(ticket);
+        }
+    }
+    set(value, attributes) {
+        if (!getConfig().metricsEnabled)
+            return;
+        if (!shouldSample('metrics', this.name))
+            return;
+        const ticket = tryAcquire('metrics');
+        if (!ticket)
+            return;
+        try {
+            // Stryker disable next-line StringLiteral: empty string fallback for no-attributes key — functionally equivalent to any constant
+            const key = attributes ? JSON.stringify(attributes) : '';
+            const prev = this._values.get(key) ?? 0;
+            const delta = value - prev;
+            this._values.set(key, value);
+            this._inner.add(delta, attributes);
+            this._lastValue = value;
+        }
+        finally {
+            release(ticket);
+        }
+    }
+}
+/**
+ * Wrapper around OTel Histogram that gates record() through sampling + backpressure.
+ */
+export class HistogramInstrument {
+    constructor(name, inner) {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_inner", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_count", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "_total", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        this.name = name;
+        this._inner = inner;
+    }
+    /** Number of values recorded (in-process; useful for testing and health checks). */
+    get count() {
+        return this._count;
+    }
+    /** Sum of all recorded values (in-process; useful for testing and health checks). */
+    get total() {
+        return this._total;
+    }
+    record(value, attributes) {
+        if (!getConfig().metricsEnabled)
+            return;
+        if (!shouldSample('metrics', this.name))
+            return;
+        const ticket = tryAcquire('metrics');
+        if (!ticket)
+            return;
+        try {
+            const ids = getActiveTraceIds();
+            const enriched = ids.trace_id && ids.span_id
+                ? { ...attributes, trace_id: ids.trace_id, span_id: ids.span_id }
+                : attributes;
+            this._inner.record(value, enriched);
+            this._count += 1;
+            this._total += value;
+        }
+        finally {
+            release(ticket);
+        }
+    }
+}
+/**
+ * Create a monotonically increasing counter.
+ * Mirrors Python: counter(name, description, unit)
+ */
+export function counter(name, options) {
+    const inner = metrics.getMeter(METER_NAME).createCounter(name, options);
+    return new CounterInstrument(name, inner);
+}
+/**
+ * Create an up-down counter (gauge — can increase or decrease).
+ * Mirrors Python: gauge(name, description, unit)
+ */
+export function gauge(name, options) {
+    const inner = metrics.getMeter(METER_NAME).createUpDownCounter(name, options);
+    return new GaugeInstrument(name, inner);
+}
+/**
+ * Create a histogram for recording distributions (latencies, sizes).
+ * Mirrors Python: histogram(name, description, unit)
+ */
+export function histogram(name, options) {
+    const inner = metrics.getMeter(METER_NAME).createHistogram(name, options);
+    return new HistogramInstrument(name, inner);
+}
+/**
+ * Return an OTEL Meter from the global meter provider.
+ * Mirrors Python: get_meter(name)
+ */
+export function getMeter(name) {
+    // Stryker disable next-line LogicalOperator: getMeter(undefined) behaves identically to getMeter(name) with no-op OTEL API
+    return metrics.getMeter(name ?? METER_NAME);
+}

package/dist/otel-logs.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Optional OTEL SDK log wiring — activated when registerOtelProviders() runs.
+ *
+ * Peer deps required:
+ *   @opentelemetry/sdk-logs                  — LoggerProvider, BatchLogRecordProcessor
+ *   @opentelemetry/exporter-logs-otlp-http   — OTLPLogExporter
+ *   @opentelemetry/api-logs                  — logs global, SeverityNumber
+ *
+ * Mirrors Python provide.telemetry.logger.core OTLPLogExporter wiring.
+ */
+import type { TelemetryConfig } from './config';
+import type { ShutdownableProvider } from './runtime';
+/**
+ * Construct an OTLPLogExporter + LoggerProvider and register it globally.
+ * Returns a ShutdownableProvider so the caller can flush/shutdown it.
+ * Throws if any peer dep is missing (caught by the caller in otel.ts).
+ */
+export declare function setupOtelLogProvider(cfg: TelemetryConfig): Promise<ShutdownableProvider>;
+/**
+ * Emit a pino log record to the OTel LoggerProvider.
+ * Called from makeWriteHook() on every log line after enrichment and sanitization.
+ * No-op when no provider is registered (graceful degradation).
+ */
+export declare function emitLogRecord(o: Record<string, unknown>): void;
+/** Exposed for tests and resetTelemetryState(). */
+export declare function _resetOtelLogProviderForTests(): void;
+/** Exposed for integration tests to inspect state. */
+export declare function _getOtelLogProvider(): any;
+//# sourceMappingURL=otel-logs.d.ts.map

package/dist/otel-logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel-logs.d.ts","sourceRoot":"","sources":["../src/otel-logs.ts"],"names":[],"mappings":"AAOA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AA2BtD;;;;GAIG;AACH,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAmC9F;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAsD9D;AAED,mDAAmD;AACnD,wBAAgB,6BAA6B,IAAI,IAAI,CAGpD;AAED,sDAAsD;AAEtD,wBAAgB,mBAAmB,IAAI,GAAG,CAEzC"}