@cursor/july 0.1.41 → 0.1.43

package/dist/internal/otel/collector.js

@@ -0,0 +1,564 @@
+/**
+ * Maps the durable session event stream onto OTel traces / metrics / logs.
+ *
+ * Attribute names reuse Cursor enterprise wire keys where they overlap
+ * (`cursor.conversation.id`, `cursor.token.*`, `cursor.tool.*`,
+ * `cursor.cost.usage`, `cursor.model.name`) so Agent SDK traces join org
+ * metrics/logs in the same collector. Agent-SDK-only fields use `agent_sdk.*`.
+ */
+import { context, SpanKind, SpanStatusCode, trace, } from "@opentelemetry/api";
+import { SeverityNumber } from "@opentelemetry/api-logs";
+import { attrs } from "./attrs.js";
+const CONTENT_MAX = 2048;
+export function createOtelCollector(runtime, agentName, log) {
+    const sessions = new Map();
+    const metrics = runtime.meter ? buildMetrics(runtime.meter) : undefined;
+    const logOpts = runtime.config.logs === false ? undefined : runtime.config.logs;
+    return {
+        onEvent(event, session) {
+            try {
+                handle(event, session);
+            }
+            catch (error) {
+                log(`[agent-sdk:otel] collector failed on ${event.type}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+        close() {
+            for (const [sessionId, state] of sessions) {
+                state.span.setStatus({ code: SpanStatusCode.UNSET });
+                state.span.end();
+                sessions.delete(sessionId);
+            }
+        },
+    };
+    function handle(event, session) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        var _p, _q;
+        const at = Date.parse(event.at);
+        const startTime = Number.isFinite(at) ? at : undefined;
+        switch (event.type) {
+            case "session.started": {
+                openSession({
+                    sessionId: event.sessionId,
+                    session,
+                    channelId: event.data.channelId,
+                    startTime,
+                    restored: false,
+                });
+                return;
+            }
+            case "agent.bound": {
+                const state = ensureSession(event, session, startTime);
+                if (state === undefined) {
+                    return;
+                }
+                state.span.setAttribute("agent_sdk.sdk_agent_id", event.data.sdkAgentId);
+                // URL can identify a deployment; keep it off spans unless opted in.
+                if ((logOpts === null || logOpts === void 0 ? void 0 : logOpts.toolContent) === true && event.data.url !== undefined) {
+                    state.span.setAttribute("agent_sdk.sdk_agent_url", event.data.url);
+                }
+                return;
+            }
+            case "message.received": {
+                const state = ensureSession(event, session, startTime);
+                if (state === undefined) {
+                    return;
+                }
+                state.span.addEvent("message.received", attrs({
+                    "agent_sdk.event": "message.received",
+                    "agent_sdk.user_prompt": (logOpts === null || logOpts === void 0 ? void 0 : logOpts.userPrompts) === true
+                        ? truncate(event.data.text)
+                        : undefined,
+                }), startTime);
+                emitLog("message.received", SeverityNumber.INFO, attrs(Object.assign(Object.assign({}, baseLog(event, session)), { "agent_sdk.user_prompt": (logOpts === null || logOpts === void 0 ? void 0 : logOpts.userPrompts) === true
+                        ? truncate(event.data.text)
+                        : undefined })));
+                return;
+            }
+            case "turn.queued": {
+                (_a = ensureSession(event, session, startTime)) === null || _a === void 0 ? void 0 : _a.span.addEvent("turn.queued", attrs({
+                    "agent_sdk.turn_id": event.turnId,
+                    "agent_sdk.queue_position": event.data.position,
+                    "agent_sdk.max_running_turns": event.data.maxRunningTurns,
+                }), startTime);
+                return;
+            }
+            case "turn.started": {
+                if (event.turnId === undefined) {
+                    return;
+                }
+                const state = ensureSession(event, session, startTime);
+                if (state === undefined) {
+                    return;
+                }
+                openTurn({
+                    state,
+                    sessionId: event.sessionId,
+                    turnId: event.turnId,
+                    session,
+                    startTime,
+                    synthetic: false,
+                });
+                return;
+            }
+            case "step.started":
+            case "step.completed": {
+                (_b = ensureTurn(event, session, startTime)) === null || _b === void 0 ? void 0 : _b.span.addEvent(event.type, attrs({
+                    "agent_sdk.step_id": event.data.stepId,
+                    "agent_sdk.duration_ms": event.type === "step.completed"
+                        ? event.data.durationMs
+                        : undefined,
+                }), startTime);
+                return;
+            }
+            case "reasoning.completed": {
+                (_c = ensureTurn(event, session, startTime)) === null || _c === void 0 ? void 0 : _c.span.addEvent("reasoning.completed", attrs({
+                    "agent_sdk.duration_ms": event.data.durationMs,
+                    "agent_sdk.parent_call_id": event.data.parentCallId,
+                }), startTime);
+                return;
+            }
+            case "message.completed": {
+                (_d = ensureTurn(event, session, startTime)) === null || _d === void 0 ? void 0 : _d.span.addEvent("message.completed", attrs({
+                    "agent_sdk.finish_reason": event.data.finishReason,
+                    "agent_sdk.parent_call_id": event.data.parentCallId,
+                }), startTime);
+                return;
+            }
+            case "actions.requested": {
+                const turn = ensureTurn(event, session, startTime);
+                if (turn === undefined) {
+                    return;
+                }
+                for (const call of event.data.calls) {
+                    const parentCtx = parentCtxFor(turn, (_p = event.data.parentCallId) !== null && _p !== void 0 ? _p : call.parentCallId);
+                    const span = runtime.tracer.startSpan("agent_sdk.tool", {
+                        kind: SpanKind.INTERNAL,
+                        startTime,
+                        attributes: attrs({
+                            "cursor.conversation.id": event.sessionId,
+                            "cursor.tool.name": call.toolName,
+                            "cursor.tool.kind": "builtin",
+                            "agent_sdk.agent": agentName,
+                            "agent_sdk.turn_id": event.turnId,
+                            "agent_sdk.call_id": call.callId,
+                            "agent_sdk.parent_call_id": call.parentCallId,
+                            "agent_sdk.tool_args": (logOpts === null || logOpts === void 0 ? void 0 : logOpts.toolContent) === true && call.args !== undefined
+                                ? truncate(json(call.args))
+                                : undefined,
+                        }),
+                    }, parentCtx);
+                    turn.tools.set(call.callId, span);
+                }
+                return;
+            }
+            case "action.approval_requested": {
+                (_f = (_e = ensureTurn(event, session, startTime)) === null || _e === void 0 ? void 0 : _e.tools.get(event.data.callId)) === null || _f === void 0 ? void 0 : _f.addEvent("approval_requested", undefined, startTime);
+                emitLog("action.approval_requested", SeverityNumber.INFO, attrs(Object.assign(Object.assign({}, baseLog(event, session)), { "cursor.tool.name": event.data.toolName, "agent_sdk.call_id": event.data.callId })));
+                return;
+            }
+            case "action.approval_resolved": {
+                (_h = (_g = ensureTurn(event, session, startTime)) === null || _g === void 0 ? void 0 : _g.tools.get(event.data.callId)) === null || _h === void 0 ? void 0 : _h.addEvent("approval_resolved", attrs({
+                    "agent_sdk.decision": event.data.decision,
+                    "agent_sdk.decision_by": event.data.by,
+                }), startTime);
+                return;
+            }
+            case "action.result": {
+                const turn = ensureTurn(event, session, startTime);
+                const span = turn === null || turn === void 0 ? void 0 : turn.tools.get(event.data.callId);
+                const status = event.data.isError ? "failure" : "success";
+                if (span !== undefined) {
+                    span.setAttribute("cursor.tool.status", status);
+                    if ((logOpts === null || logOpts === void 0 ? void 0 : logOpts.toolContent) === true &&
+                        event.data.output !== undefined) {
+                        span.setAttribute("agent_sdk.tool_output", truncate(json(event.data.output)));
+                    }
+                    if (event.data.isError) {
+                        span.setStatus({
+                            code: SpanStatusCode.ERROR,
+                            message: "tool error",
+                        });
+                    }
+                    span.end(startTime);
+                    turn === null || turn === void 0 ? void 0 : turn.tools.delete(event.data.callId);
+                }
+                metrics === null || metrics === void 0 ? void 0 : metrics.toolCalls.add(1, {
+                    "cursor.tool.name": event.data.toolName,
+                    "cursor.tool.kind": "builtin",
+                    "cursor.tool.status": status,
+                    "agent_sdk.agent": agentName,
+                });
+                emitLog("action.result", event.data.isError ? SeverityNumber.ERROR : SeverityNumber.INFO, attrs(Object.assign(Object.assign({}, baseLog(event, session)), { "cursor.tool.name": event.data.toolName, "cursor.tool.status": status, "agent_sdk.call_id": event.data.callId })));
+                // Direct callTool never emits turn.completed — close when idle.
+                if (turn !== undefined &&
+                    turn.synthetic &&
+                    turn.tools.size === 0 &&
+                    turn.subagents.size === 0 &&
+                    event.turnId !== undefined) {
+                    turn.span.setStatus({ code: SpanStatusCode.OK });
+                    turn.span.end(startTime);
+                    (_j = sessions.get(event.sessionId)) === null || _j === void 0 ? void 0 : _j.turns.delete(event.turnId);
+                }
+                return;
+            }
+            case "subagent.called": {
+                const turn = ensureTurn(event, session, startTime);
+                if (turn === undefined) {
+                    return;
+                }
+                const span = runtime.tracer.startSpan("agent_sdk.subagent", {
+                    kind: SpanKind.INTERNAL,
+                    startTime,
+                    attributes: attrs({
+                        "cursor.conversation.id": event.sessionId,
+                        "agent_sdk.agent": agentName,
+                        "agent_sdk.turn_id": event.turnId,
+                        "agent_sdk.call_id": event.data.callId,
+                        "agent_sdk.subagent_name": event.data.name,
+                        "agent_sdk.subagent_description": (logOpts === null || logOpts === void 0 ? void 0 : logOpts.toolContent) === true &&
+                            event.data.description !== undefined
+                            ? truncate(event.data.description)
+                            : undefined,
+                    }),
+                }, trace.setSpan(context.active(), turn.span));
+                turn.subagents.set(event.data.callId, span);
+                metrics === null || metrics === void 0 ? void 0 : metrics.subagents.add(1, {
+                    "agent_sdk.agent": agentName,
+                    "agent_sdk.subagent_name": (_q = event.data.name) !== null && _q !== void 0 ? _q : "unknown",
+                });
+                return;
+            }
+            case "subagent.completed": {
+                const turn = ensureTurn(event, session, startTime);
+                const span = turn === null || turn === void 0 ? void 0 : turn.subagents.get(event.data.callId);
+                if (span !== undefined) {
+                    span.end(startTime);
+                    turn === null || turn === void 0 ? void 0 : turn.subagents.delete(event.data.callId);
+                }
+                return;
+            }
+            case "artifact.tagged": {
+                (_k = ensureSession(event, session, startTime)) === null || _k === void 0 ? void 0 : _k.span.addEvent("artifact.tagged", attrs({
+                    "agent_sdk.artifact_id": event.data.id,
+                    "agent_sdk.artifact_kind": event.data.kind,
+                    "agent_sdk.artifact_key": event.data.key,
+                    "agent_sdk.artifact_source": event.data.source,
+                }), startTime);
+                return;
+            }
+            case "turn.completed": {
+                const turn = ensureTurn(event, session, startTime);
+                if (turn === undefined || event.turnId === undefined) {
+                    return;
+                }
+                endOpenChildren(turn, startTime);
+                const usage = event.data.usage;
+                const cost = event.data.cost;
+                if (usage !== undefined) {
+                    turn.span.setAttributes(attrs({
+                        "agent_sdk.usage.input_tokens": usage.inputTokens,
+                        "agent_sdk.usage.output_tokens": usage.outputTokens,
+                        "agent_sdk.usage.cache_read_tokens": usage.cacheReadTokens,
+                        "agent_sdk.usage.cache_write_tokens": usage.cacheWriteTokens,
+                        "agent_sdk.usage.reasoning_tokens": usage.reasoningTokens,
+                    }));
+                    recordTokens(usage);
+                }
+                if (cost !== undefined) {
+                    turn.span.setAttributes(attrs({
+                        "cursor.model.name": cost.model,
+                        "agent_sdk.cost_usd": cost.totalUsd,
+                        "agent_sdk.cost_source": cost.source,
+                    }));
+                    metrics === null || metrics === void 0 ? void 0 : metrics.cost.add(cost.totalUsd, {
+                        "cursor.model.name": cost.model,
+                        "agent_sdk.agent": agentName,
+                    });
+                }
+                turn.span.setStatus({ code: SpanStatusCode.OK });
+                turn.span.end(startTime);
+                (_l = sessions.get(event.sessionId)) === null || _l === void 0 ? void 0 : _l.turns.delete(event.turnId);
+                metrics === null || metrics === void 0 ? void 0 : metrics.turns.add(1, {
+                    "agent_sdk.agent": agentName,
+                    "agent_sdk.turn_status": "completed",
+                });
+                emitLog("turn.completed", SeverityNumber.INFO, attrs(Object.assign(Object.assign({}, baseLog(event, session)), { "agent_sdk.usage.input_tokens": usage === null || usage === void 0 ? void 0 : usage.inputTokens, "agent_sdk.usage.output_tokens": usage === null || usage === void 0 ? void 0 : usage.outputTokens, "agent_sdk.cost_usd": cost === null || cost === void 0 ? void 0 : cost.totalUsd, "cursor.model.name": cost === null || cost === void 0 ? void 0 : cost.model })));
+                return;
+            }
+            case "turn.failed": {
+                const turn = ensureTurn(event, session, startTime);
+                if (turn === undefined || event.turnId === undefined) {
+                    return;
+                }
+                endOpenChildren(turn, startTime);
+                // Failure text can contain secrets/PII — same gate as log payloads.
+                const failureText = gatedContent(event.data.message);
+                turn.span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: failureText !== null && failureText !== void 0 ? failureText : "turn failed",
+                });
+                if (failureText !== undefined) {
+                    turn.span.recordException(new Error(failureText));
+                }
+                turn.span.end(startTime);
+                (_m = sessions.get(event.sessionId)) === null || _m === void 0 ? void 0 : _m.turns.delete(event.turnId);
+                metrics === null || metrics === void 0 ? void 0 : metrics.turns.add(1, {
+                    "agent_sdk.agent": agentName,
+                    "agent_sdk.turn_status": "failed",
+                });
+                emitLog("turn.failed", SeverityNumber.ERROR, attrs(Object.assign(Object.assign({}, baseLog(event, session)), { "agent_sdk.error_message": failureText })));
+                return;
+            }
+            case "session.waiting": {
+                (_o = ensureSession(event, session, startTime)) === null || _o === void 0 ? void 0 : _o.span.addEvent("session.waiting", undefined, startTime);
+                return;
+            }
+            case "session.completed": {
+                endSession({
+                    sessionId: event.sessionId,
+                    code: SpanStatusCode.OK,
+                    message: undefined,
+                    endTime: startTime,
+                });
+                return;
+            }
+            case "session.failed": {
+                const failureText = gatedContent(event.data.message);
+                endSession({
+                    sessionId: event.sessionId,
+                    code: SpanStatusCode.ERROR,
+                    message: failureText !== null && failureText !== void 0 ? failureText : "session failed",
+                    endTime: startTime,
+                });
+                emitLog("session.failed", SeverityNumber.ERROR, attrs(Object.assign(Object.assign({}, baseLog(event, session)), { "agent_sdk.error_message": failureText })));
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    /**
+     * Open a session span on first live event after restore/resume (no
+     * `session.started` in this process). Fresh sessions still use the
+     * dedicated `session.started` case.
+     */
+    function ensureSession(event, session, startTime) {
+        const existing = sessions.get(event.sessionId);
+        if (existing !== undefined) {
+            return existing;
+        }
+        return openSession({
+            sessionId: event.sessionId,
+            session,
+            channelId: session.channelId,
+            startTime,
+            restored: true,
+        });
+    }
+    function openSession(args) {
+        var _a;
+        const parent = context.active();
+        const span = runtime.tracer.startSpan("agent_sdk.session", {
+            kind: SpanKind.INTERNAL,
+            startTime: args.startTime,
+            attributes: attrs({
+                "cursor.conversation.id": args.sessionId,
+                "agent_sdk.agent": agentName,
+                "agent_sdk.channel": args.channelId,
+                "agent_sdk.session_mode": args.session.mode,
+                "agent_sdk.session_purpose": (_a = args.session.purpose) !== null && _a !== void 0 ? _a : "live",
+                "agent_sdk.session_restored": args.restored ? true : undefined,
+            }),
+        }, parent);
+        const state = {
+            span,
+            ctx: trace.setSpan(parent, span),
+            turns: new Map(),
+        };
+        sessions.set(args.sessionId, state);
+        if (!args.restored) {
+            metrics === null || metrics === void 0 ? void 0 : metrics.sessions.add(1, {
+                "agent_sdk.agent": agentName,
+                "agent_sdk.channel": args.channelId,
+            });
+        }
+        return state;
+    }
+    /**
+     * Direct `callTool` and post-restore turns may emit tool events without
+     * a prior `turn.started` in this process — open a synthetic turn span.
+     */
+    function ensureTurn(event, session, startTime) {
+        if (event.turnId === undefined) {
+            return undefined;
+        }
+        const state = ensureSession(event, session, startTime);
+        if (state === undefined) {
+            return undefined;
+        }
+        const existing = state.turns.get(event.turnId);
+        if (existing !== undefined) {
+            return existing;
+        }
+        return openTurn({
+            state,
+            sessionId: event.sessionId,
+            turnId: event.turnId,
+            session,
+            startTime,
+            synthetic: true,
+        });
+    }
+    function openTurn(args) {
+        const span = runtime.tracer.startSpan("agent_sdk.turn", {
+            kind: SpanKind.INTERNAL,
+            startTime: args.startTime,
+            attributes: attrs({
+                "cursor.conversation.id": args.sessionId,
+                "agent_sdk.agent": agentName,
+                "agent_sdk.turn_id": args.turnId,
+                "agent_sdk.channel": args.session.channelId,
+                "agent_sdk.turn_synthetic": args.synthetic ? true : undefined,
+            }),
+        }, args.state.ctx);
+        const turn = {
+            span,
+            tools: new Map(),
+            subagents: new Map(),
+            synthetic: args.synthetic,
+        };
+        args.state.turns.set(args.turnId, turn);
+        return turn;
+    }
+    function parentCtxFor(turn, parentCallId) {
+        if (parentCallId !== undefined) {
+            const sub = turn.subagents.get(parentCallId);
+            if (sub !== undefined) {
+                return trace.setSpan(context.active(), sub);
+            }
+        }
+        return trace.setSpan(context.active(), turn.span);
+    }
+    function endOpenChildren(turn, endTime) {
+        for (const span of turn.tools.values()) {
+            span.end(endTime);
+        }
+        turn.tools.clear();
+        for (const span of turn.subagents.values()) {
+            span.end(endTime);
+        }
+        turn.subagents.clear();
+    }
+    function endSession(args) {
+        const state = sessions.get(args.sessionId);
+        if (state === undefined) {
+            return;
+        }
+        for (const turn of state.turns.values()) {
+            endOpenChildren(turn, args.endTime);
+            turn.span.end(args.endTime);
+        }
+        state.turns.clear();
+        state.span.setStatus(args.message === undefined
+            ? { code: args.code }
+            : { code: args.code, message: args.message });
+        state.span.end(args.endTime);
+        sessions.delete(args.sessionId);
+    }
+    function recordTokens(usage) {
+        if (metrics === undefined) {
+            return;
+        }
+        const agent = agentName;
+        // Wire token types match enterprise export (`cache_creation`, not write).
+        addTokens(usage.inputTokens, "input", agent);
+        addTokens(usage.outputTokens, "output", agent);
+        addTokens(usage.cacheReadTokens, "cache_read", agent);
+        addTokens(usage.cacheWriteTokens, "cache_creation", agent);
+        if (usage.reasoningTokens !== undefined) {
+            // Reasoning is Agent-SDK-only; enterprise wire has no reasoning enum.
+            metrics.tokens.add(usage.reasoningTokens, {
+                "cursor.token.type": "reasoning",
+                "agent_sdk.agent": agent,
+            });
+        }
+    }
+    function addTokens(value, type, agent) {
+        if (metrics === undefined || value === 0) {
+            return;
+        }
+        metrics.tokens.add(value, {
+            "cursor.token.type": type,
+            "agent_sdk.agent": agent,
+        });
+    }
+    /** Content opt-in for failure text (same gate as tool payloads). */
+    function gatedContent(value) {
+        if ((logOpts === null || logOpts === void 0 ? void 0 : logOpts.toolContent) !== true) {
+            return undefined;
+        }
+        return truncate(value);
+    }
+    function baseLog(event, session) {
+        return {
+            "cursor.conversation.id": event.sessionId,
+            "agent_sdk.event": event.type,
+            "agent_sdk.agent": agentName,
+            "agent_sdk.channel": session.channelId,
+            "agent_sdk.turn_id": event.turnId,
+        };
+    }
+    function emitLog(eventName, severity, attributes) {
+        var _a;
+        (_a = runtime.logger) === null || _a === void 0 ? void 0 : _a.emit({
+            body: eventName,
+            severityNumber: severity,
+            attributes,
+        });
+    }
+}
+function buildMetrics(meter) {
+    return {
+        sessions: meter.createCounter("agent_sdk.session.count", {
+            description: "Sessions started",
+            unit: "{session}",
+        }),
+        turns: meter.createCounter("agent_sdk.turn.count", {
+            description: "Turns completed or failed",
+            unit: "{turn}",
+        }),
+        // Wire-aligned name so collectors joining org export see one series family.
+        toolCalls: meter.createCounter("cursor.tool.calls", {
+            description: "Tool calls finished",
+            unit: "{call}",
+        }),
+        subagents: meter.createCounter("agent_sdk.subagent.count", {
+            description: "Subagent invocations",
+            unit: "{call}",
+        }),
+        tokens: meter.createCounter("cursor.token.usage", {
+            description: "Token usage by type",
+            unit: "{token}",
+        }),
+        cost: meter.createCounter("cursor.cost.usage", {
+            description: "Estimated turn cost in USD",
+            unit: "USD",
+        }),
+    };
+}
+function truncate(value) {
+    if (value.length <= CONTENT_MAX) {
+        return value;
+    }
+    return `${value.slice(0, CONTENT_MAX)}…`;
+}
+function json(value) {
+    var _a;
+    try {
+        return (_a = JSON.stringify(value)) !== null && _a !== void 0 ? _a : String(value);
+    }
+    catch (_b) {
+        return String(value);
+    }
+}

package/dist/internal/otel/config.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Merge authored `defineOtel`, `serve({ otel })`, and standard OTel env.
+ */
+import type { OtelConfig, OtelDefinition, OtelExporterConfig, OtelLogOptions, OtelMetricOptions, OtelSignal, OtelTraceOptions } from "../../otel.js";
+export interface ResolvedOtelConfig {
+    enabled: boolean;
+    serviceName: string;
+    serviceVersion: string | undefined;
+    resourceAttributes: Record<string, string>;
+    exporters: OtelExporterConfig[];
+    traces: false | OtelTraceOptions;
+    metrics: false | OtelMetricOptions;
+    logs: false | OtelLogOptions;
+}
+/** True when any standard OTLP endpoint env var is set. */
+export declare function hasOtelEnv(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Process-global authored config. OTel SDK is one per serve process — if
+ * several mounts ship `agent/otel.ts`, they must be identical.
+ */
+export declare function pickAuthoredOtel(mounts: ReadonlyArray<{
+    slug: string;
+    name: string;
+    otel?: OtelDefinition;
+}>): OtelDefinition | undefined;
+/**
+ * Resolve effective config.
+ *
+ * Precedence: `serve({ otel: false })` disables; otherwise merge
+ * `serve({ otel })` over `defineOtel` over env defaults.
+ */
+export declare function resolveOtelConfig(input: {
+    authored?: OtelConfig;
+    serve?: OtelConfig | false;
+    env?: NodeJS.ProcessEnv;
+}): ResolvedOtelConfig;
+export declare function parseOtelHeaders(raw: string | undefined): Record<string, string>;
+/** Collapse `…/v1/{traces,metrics,logs}` to the collector base. */
+export declare function stripSignalPath(url: string): string;
+/** Exporters that apply to one signal (honors per-exporter `signals`). */
+export declare function exportersForSignal(exporters: readonly OtelExporterConfig[], signal: OtelSignal): OtelExporterConfig[];
+//# sourceMappingURL=config.d.ts.map

package/dist/internal/otel/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/internal/otel/config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EACV,UAAU,EACV,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,iBAAiB,EACjB,UAAU,EACV,gBAAgB,EACjB,MAAM,eAAe,CAAC;AAEvB,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3C,SAAS,EAAE,kBAAkB,EAAE,CAAC;IAChC,MAAM,EAAE,KAAK,GAAG,gBAAgB,CAAC;IACjC,OAAO,EAAE,KAAK,GAAG,iBAAiB,CAAC;IACnC,IAAI,EAAE,KAAK,GAAG,cAAc,CAAC;CAC9B;AAED,2DAA2D;AAC3D,wBAAgB,UAAU,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,OAAO,CAOxE;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,cAAc,CAAA;CAAE,CAAC,GAC3E,cAAc,GAAG,SAAS,CAmB5B;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE;IACvC,QAAQ,CAAC,EAAE,UAAU,CAAC;IACtB,KAAK,CAAC,EAAE,UAAU,GAAG,KAAK,CAAC;IAC3B,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACzB,GAAG,kBAAkB,CAiDrB;AAED,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,MAAM,GAAG,SAAS,GACtB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAiBxB;AAED,mEAAmE;AACnE,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,0EAA0E;AAC1E,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,SAAS,kBAAkB,EAAE,EACxC,MAAM,EAAE,UAAU,GACjB,kBAAkB,EAAE,CAKtB"}