@cursor/bdk 0.2.24 → 0.2.26

package/dist/internal/otel/customer.js

@@ -0,0 +1,727 @@
+/**
+ * Bake-time OpenTelemetry providers. Discovery installs them before other
+ * agent modules load. Real OTLP exporters attach from `OTEL_*` variables
+ * at the first secret load.
+ */
+import { context, metrics, propagation, trace } from "@opentelemetry/api";
+import { logs } from "@opentelemetry/api-logs";
+import { ExportResultCode } from "@opentelemetry/core";
+import { OTLPLogExporter as OTLPLogExporterHttp } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPLogExporter as OTLPLogExporterProto } from "@opentelemetry/exporter-logs-otlp-proto";
+import { DeltaTemporalitySelector, OTLPMetricExporter as OTLPMetricExporterHttp, } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPMetricExporter as OTLPMetricExporterProto } from "@opentelemetry/exporter-metrics-otlp-proto";
+import { OTLPTraceExporter as OTLPTraceExporterHttp } from "@opentelemetry/exporter-trace-otlp-http";
+import { OTLPTraceExporter as OTLPTraceExporterProto } from "@opentelemetry/exporter-trace-otlp-proto";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { BatchLogRecordProcessor, LoggerProvider, } from "@opentelemetry/sdk-logs";
+import { MeterProvider, PeriodicExportingMetricReader, } from "@opentelemetry/sdk-metrics";
+import { BatchSpanProcessor, } from "@opentelemetry/sdk-trace-base";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { ATTR_DEPLOYMENT_ENVIRONMENT_NAME, ATTR_SERVICE_NAME, ATTR_SERVICE_NAMESPACE, ATTR_SERVICE_VERSION, } from "@opentelemetry/semantic-conventions";
+import { UNKNOWN_SERVICE_NAME, exportersForSignal, parseOtelHeaders, resolveOtelConfig, } from "./config.js";
+import { conversationIdSpanProcessor } from "./conversation-span-processor.js";
+import { metricTemporalityPreference, metricTemporalitySelector, installOtelDiagLogger, raceOtelForceFlush, warnEgress, } from "./runtime.js";
+import { installOutboundFetchInstrumentation } from "../../otel.js";
+const METRIC_EXPORT_INTERVAL_MS = 10_000;
+const FRAMEWORK_SCOPE = "agent_sdk";
+/** Matches the batch processor's default `maxQueueSize`. */
+const MAX_HELD_PER_SIGNAL = 2048;
+let armed;
+let secrets = deferred();
+let loggedTemporality = false;
+let loggedLateSampler = false;
+let loggedLateInterval = false;
+let samplerAtInstall;
+let metricIntervalAtInstall = METRIC_EXPORT_INTERVAL_MS;
+/**
+ * One list for every copy of this module. A hosted process loads `dist/`
+ * while an agent file can load `src/`. A per-module array would drop the mapper.
+ */
+const OTEL_ENV_CONTRIBUTORS = Symbol.for("cursor.bdk.otelEnvContributors");
+function otelEnvContributors() {
+    const slot = globalThis;
+    let list = slot[OTEL_ENV_CONTRIBUTORS];
+    if (list === undefined) {
+        list = [];
+        slot[OTEL_ENV_CONTRIBUTORS] = list;
+    }
+    return list;
+}
+/**
+ * Register a mapper that runs when secrets load, before exporters are built.
+ * Factory agents use this to copy their own secret names into `OTEL_*`.
+ * Not exported from `@cursor/bdk/otel`.
+ */
+export function contributeOtelEnv(contribute) {
+    otelEnvContributors().push(contribute);
+}
+export function writeDatadogTraceEnv(env, input) {
+    if (foreignOtelHost(env, input.tracesUrl)) {
+        return;
+    }
+    if (!hasOtelEndpoint(env)) {
+        env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT = tracesSignalUrl(input.tracesUrl);
+    }
+    if (!nonEmpty(env.OTEL_SERVICE_NAME)) {
+        env.OTEL_SERVICE_NAME = input.serviceName;
+    }
+    env.OTEL_EXPORTER_OTLP_HEADERS = replaceHeader(env.OTEL_EXPORTER_OTLP_HEADERS, "dd-api-key", input.apiKey);
+    const attributes = parseResourceAttributes(env.OTEL_RESOURCE_ATTRIBUTES);
+    if (attributes[ATTR_DEPLOYMENT_ENVIRONMENT_NAME] === undefined &&
+        attributes["deployment.environment"] === undefined) {
+        const pair = `${ATTR_DEPLOYMENT_ENVIRONMENT_NAME}=${encodeURIComponent(input.environment)}`;
+        env.OTEL_RESOURCE_ATTRIBUTES =
+            env.OTEL_RESOURCE_ATTRIBUTES !== undefined && env.OTEL_RESOURCE_ATTRIBUTES.length > 0
+                ? `${env.OTEL_RESOURCE_ATTRIBUTES},${pair}`
+                : pair;
+    }
+}
+function tracesSignalUrl(url) {
+    const trimmed = url.replace(/\/$/, "");
+    if (/\/v1\/traces$/i.test(trimmed)) {
+        return trimmed;
+    }
+    return `${trimmed}/v1/traces`;
+}
+function foreignOtelHost(env, tracesUrl) {
+    const ours = hostnameOf(tracesUrl);
+    if (ours === undefined) {
+        return false;
+    }
+    for (const raw of [env.OTEL_EXPORTER_OTLP_ENDPOINT, env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT]) {
+        if (!nonEmpty(raw)) {
+            continue;
+        }
+        const host = hostnameOf(raw);
+        if (host !== undefined && host !== ours) {
+            return true;
+        }
+    }
+    return false;
+}
+function hostnameOf(raw) {
+    try {
+        return new URL(raw).hostname;
+    }
+    catch {
+        return undefined;
+    }
+}
+function replaceHeader(raw, name, value) {
+    const kept = (raw ?? "")
+        .split(",")
+        .map((part) => part.trim())
+        .filter((part) => {
+        if (part.length === 0) {
+            return false;
+        }
+        const idx = part.indexOf("=");
+        if (idx <= 0) {
+            return true;
+        }
+        return part.slice(0, idx).trim().toLowerCase() !== name.toLowerCase();
+    });
+    kept.push(`${name}=${encodeURIComponent(value)}`);
+    return kept.join(",");
+}
+function hasOtelEndpoint(env) {
+    return (nonEmpty(env.OTEL_EXPORTER_OTLP_ENDPOINT) || nonEmpty(env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT));
+}
+/** Resolves at the first secret load. Local serve resolves it at start. */
+export function otelSecretsReady() {
+    return secrets.promise;
+}
+/**
+ * Install global trace, metric, and log providers before `agent.ts` loads.
+ * A second call does nothing. BDK shuts down a provider only when its
+ * registration installed that provider. If another SDK already owns a
+ * global, that provider stays and the new one is shut down.
+ */
+export function installCustomerOtel() {
+    if (armed !== undefined) {
+        return;
+    }
+    const serviceName = deferred();
+    const serviceNamespace = deferred();
+    const serviceVersion = deferred();
+    const deploymentEnvironment = deferred();
+    const resource = resourceFromAttributes({
+        [ATTR_SERVICE_NAME]: serviceName.promise,
+        [ATTR_SERVICE_NAMESPACE]: serviceNamespace.promise,
+        [ATTR_SERVICE_VERSION]: serviceVersion.promise,
+        [ATTR_DEPLOYMENT_ENVIRONMENT_NAME]: deploymentEnvironment.promise,
+    });
+    const traces = new ForwardingSpanExporter();
+    const metricForwarder = new ForwardingMetricExporter();
+    const logForwarder = new ForwardingLogExporter();
+    const heldSpans = new ResourceGatedSpanProcessor(new BatchSpanProcessor(traces));
+    const heldLogs = new ResourceGatedLogProcessor(new BatchLogRecordProcessor(logForwarder));
+    const traceProvider = new NodeTracerProvider({
+        resource,
+        spanProcessors: [conversationIdSpanProcessor(), heldSpans],
+    });
+    metricIntervalAtInstall = metricIntervalFromEnv(process.env);
+    samplerAtInstall = process.env.OTEL_TRACES_SAMPLER;
+    const metricReader = new StartableMetricReader({
+        exporter: metricForwarder,
+        exportIntervalMillis: metricIntervalAtInstall,
+    });
+    metricForwarder.reader = metricReader;
+    const meterProvider = new MeterProvider({
+        resource,
+        readers: [metricReader],
+    });
+    const loggerProvider = new LoggerProvider({
+        resource,
+        processors: [heldLogs],
+    });
+    metricForwarder.temporality = metricTemporalitySelector("delta");
+    const owned = [];
+    const registered = {};
+    traceProvider.register();
+    if (tracerDelegate() === traceProvider) {
+        owned.push(traceProvider);
+        registered.tracer = traceProvider;
+    }
+    else {
+        void traceProvider.shutdown();
+    }
+    if (metrics.setGlobalMeterProvider(meterProvider)) {
+        owned.push(meterProvider);
+        registered.meter = meterProvider;
+    }
+    else {
+        void meterProvider.shutdown();
+    }
+    if (logs.setGlobalLoggerProvider(loggerProvider) === loggerProvider) {
+        owned.push(loggerProvider);
+        registered.logger = loggerProvider;
+    }
+    else {
+        void loggerProvider.shutdown();
+    }
+    armed = {
+        owned,
+        resource,
+        heldSpans,
+        heldLogs,
+        traces,
+        metrics: metricForwarder,
+        logs: logForwarder,
+        serviceName,
+        serviceNamespace,
+        serviceVersion,
+        deploymentEnvironment,
+        resourceSettled: false,
+        attached: false,
+        attachedKey: undefined,
+        registered,
+    };
+}
+/**
+ * Settle resource promises and attach OTLP exporters from the current env.
+ * Later calls keep the same URLs. Exporter headers are read on each export.
+ */
+export function notifyOtelSecretsReady(input) {
+    const env = input.env ?? process.env;
+    for (const contribute of otelEnvContributors()) {
+        contribute(env);
+    }
+    try {
+        if (armed !== undefined) {
+            const resolved = resolveOtelConfig({
+                env,
+                defaultServiceName: input.defaultServiceName,
+            });
+            for (const warning of resolved.warnings) {
+                input.log(`[bdk:otel] warn: ${warning}`);
+            }
+            warnLateEnv(env, input.log);
+            const shouldExport = resolved.enabled && exportable(resolved);
+            if (!shouldExport) {
+                if (armed.attached) {
+                    retireTargets(armed);
+                    armed.attached = false;
+                    armed.attachedKey = undefined;
+                }
+            }
+            else {
+                const key = exporterKey(resolved);
+                if (!armed.resourceSettled) {
+                    settleResource(armed, env, input.defaultServiceName);
+                }
+                if (!armed.attached || armed.attachedKey !== key) {
+                    retireTargets(armed);
+                    attachExporters(armed, resolved, input.log);
+                    warnEgress(resolved, input.egressDomains, input.log);
+                    logTemporalityDefault(resolved, env, input.log);
+                    armed.attached = true;
+                    armed.attachedKey = key;
+                }
+            }
+        }
+    }
+    catch (error) {
+        input.log(`[bdk:otel] error: OTel config failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    secrets.settle(undefined);
+}
+function exportable(resolved) {
+    return ((resolved.traces !== false && exportersForSignal(resolved.exporters, "traces").length > 0) ||
+        (resolved.metrics !== false && exportersForSignal(resolved.exporters, "metrics").length > 0) ||
+        (resolved.logs !== false && exportersForSignal(resolved.exporters, "logs").length > 0));
+}
+function exporterKey(resolved) {
+    // Unset and `otlp` share one exporter list. Record the logs choice so a later change reattaches.
+    const logs = resolved.logs === false ? "off" : "on";
+    return `${logs}|${resolved.exporters
+        .map((exporter) => `${exporter.url}|${exporter.protocol ?? ""}|${exporter.literalUrl === true ? "literal" : "base"}|${(exporter.signals ?? []).join("+")}`)
+        .join(",")}`;
+}
+function retireTargets(state) {
+    const targets = [...state.traces.targets, ...state.metrics.targets, ...state.logs.targets];
+    state.traces.targets = [];
+    state.metrics.targets = [];
+    state.logs.targets = [];
+    void Promise.allSettled(targets.map((target) => target.shutdown()));
+}
+function warnLateEnv(env, log) {
+    if (!loggedLateSampler && env.OTEL_TRACES_SAMPLER !== samplerAtInstall) {
+        loggedLateSampler = true;
+        log("[bdk:otel] warn: OTEL_TRACES_SAMPLER is read when the provider is built, before secrets load. Set it on the process, then restart.");
+    }
+    const interval = metricIntervalFromEnv(env);
+    if (!loggedLateInterval && interval !== metricIntervalAtInstall) {
+        loggedLateInterval = true;
+        log("[bdk:otel] warn: OTEL_METRIC_EXPORT_INTERVAL is read when the provider is built, before secrets load. Set it on the process, then restart.");
+    }
+}
+function logTemporalityDefault(resolved, env, log) {
+    if (loggedTemporality || resolved.metrics === false) {
+        return;
+    }
+    if (resolved.metrics.temporality === "delta" &&
+        !nonEmpty(env.OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE)) {
+        loggedTemporality = true;
+        log("[bdk:otel] metrics temporality is delta. Set OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE=cumulative for Prometheus or Grafana Cloud.");
+    }
+}
+function metricIntervalFromEnv(env) {
+    const raw = env.OTEL_METRIC_EXPORT_INTERVAL?.trim();
+    const value = raw === undefined ? Number.NaN : Number(raw);
+    if (!Number.isFinite(value) || value <= 0) {
+        return METRIC_EXPORT_INTERVAL_MS;
+    }
+    return value;
+}
+/**
+ * The runtime `serve` uses after discovery installs the providers.
+ * HTTP spans, the collector, and flush stay on one path.
+ */
+export function createCustomerOtelRuntime(log, options = {}) {
+    installOtelDiagLogger(log);
+    const meter = metrics.getMeter(FRAMEWORK_SCOPE);
+    const runtime = {
+        config: resolveOtelConfig({ env: process.env, defaultServiceName: options.defaultServiceName }),
+        tracer: trace.getTracer(FRAMEWORK_SCOPE),
+        meter,
+        logger: logs.getLogger(FRAMEWORK_SCOPE),
+        httpDuration: meter.createHistogram("agent_sdk.http.duration", {
+            description: "HTTP request duration",
+            unit: "ms",
+        }),
+        forceFlush: () => raceOtelForceFlush(forceFlushGlobalOtel(), log),
+        shutdown: () => shutdownCustomerOtel(log),
+    };
+    return {
+        runtime,
+        reload() {
+            try {
+                // Mappers write OTEL_* during notify. The collector reads the config after that write.
+                notifyOtelSecretsReady({
+                    log,
+                    egressDomains: options.egressDomains,
+                    defaultServiceName: options.defaultServiceName,
+                });
+                runtime.config = resolveOtelConfig({
+                    env: process.env,
+                    defaultServiceName: options.defaultServiceName,
+                });
+                if (runtime.config.enabled && runtime.config.traces !== false) {
+                    installOutboundFetchInstrumentation();
+                }
+            }
+            catch (error) {
+                log(`[bdk:otel] error: OTel config failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+    };
+}
+export async function forceFlushGlobalOtel() {
+    await Promise.allSettled([tracerDelegate(), metrics.getMeterProvider(), loggerDelegate()].map((provider) => flushExporter(provider)));
+}
+async function shutdownCustomerOtel(log) {
+    const current = armed;
+    if (current === undefined) {
+        await raceOtelForceFlush(forceFlushGlobalOtel(), log);
+        return;
+    }
+    const mine = new Set(current.owned);
+    armed = undefined;
+    if (!current.resourceSettled) {
+        settleArmed(current, { serviceName: UNKNOWN_SERVICE_NAME });
+    }
+    const ownedTracer = mine.has(tracerDelegate());
+    const ownedMeter = mine.has(metrics.getMeterProvider());
+    const ownedLogger = mine.has(loggerDelegate());
+    await raceOtelForceFlush(Promise.all([
+        Promise.allSettled(current.owned.map((provider) => provider.shutdown())),
+        Promise.allSettled(globalProviders()
+            .filter((provider) => !mine.has(provider))
+            .map((provider) => flushExporter(provider))),
+    ]), log);
+    if (ownedTracer) {
+        trace.disable();
+    }
+    if (ownedMeter) {
+        metrics.disable();
+    }
+    if (ownedLogger) {
+        logs.disable();
+    }
+    secrets = deferred();
+}
+function globalProviders() {
+    return [tracerDelegate(), metrics.getMeterProvider(), loggerDelegate()];
+}
+/** True when agent code replaced a provider this process installed. */
+export function otelProvidersReplaced() {
+    const registered = armed?.registered;
+    if (registered === undefined) {
+        return false;
+    }
+    return ((registered.tracer !== undefined && tracerDelegate() !== registered.tracer) ||
+        (registered.meter !== undefined && metrics.getMeterProvider() !== registered.meter) ||
+        (registered.logger !== undefined && loggerDelegate() !== registered.logger));
+}
+function tracerDelegate() {
+    const provider = trace.getTracerProvider();
+    return provider.getDelegate?.() ?? provider;
+}
+function loggerDelegate() {
+    return logs.getLoggerProvider();
+}
+/** Test isolation. Settles pending resource promises so a flush cannot wait forever. */
+export async function resetCustomerOtelForTests() {
+    const current = armed;
+    armed = undefined;
+    if (current !== undefined) {
+        settleArmed(current);
+        await Promise.allSettled(current.owned.map((provider) => provider.shutdown()));
+    }
+    secrets.settle(undefined);
+    secrets = deferred();
+    otelEnvContributors().length = 0;
+    loggedTemporality = false;
+    loggedLateSampler = false;
+    loggedLateInterval = false;
+    trace.disable();
+    metrics.disable();
+    logs.disable();
+    context.disable();
+    propagation.disable();
+}
+function settleResource(state, env, defaultServiceName) {
+    if (state.resourceSettled) {
+        return;
+    }
+    const attributes = parseResourceAttributes(env.OTEL_RESOURCE_ATTRIBUTES);
+    const fromService = env.OTEL_SERVICE_NAME?.trim();
+    const attributeName = attributes[ATTR_SERVICE_NAME];
+    const serviceName = nonEmpty(fromService)
+        ? fromService
+        : nonEmpty(attributeName)
+            ? attributeName
+            : nonEmpty(defaultServiceName)
+                ? defaultServiceName
+                : UNKNOWN_SERVICE_NAME;
+    try {
+        const raw = state.resource.getRawAttributes();
+        const present = new Set(raw.map(([key]) => key));
+        for (const [key, value] of Object.entries(attributes)) {
+            if (present.has(key)) {
+                continue;
+            }
+            raw.push([key, value]);
+        }
+    }
+    finally {
+        settleArmed(state, {
+            serviceName,
+            serviceNamespace: attributes[ATTR_SERVICE_NAMESPACE],
+            serviceVersion: attributes[ATTR_SERVICE_VERSION],
+            deploymentEnvironment: attributes[ATTR_DEPLOYMENT_ENVIRONMENT_NAME],
+        });
+    }
+}
+function settleArmed(state, values = {}) {
+    if (state.resourceSettled) {
+        return;
+    }
+    state.serviceName.settle(values.serviceName);
+    state.serviceNamespace.settle(values.serviceNamespace);
+    state.serviceVersion.settle(values.serviceVersion);
+    state.deploymentEnvironment.settle(values.deploymentEnvironment);
+    state.resourceSettled = true;
+    state.heldSpans.release();
+    state.heldLogs.release();
+}
+function attachExporters(state, resolved, log) {
+    if (resolved.traces !== false) {
+        state.traces.targets = exportersForSignal(resolved.exporters, "traces").map((exporter) => isProtobuf(exporter.protocol)
+            ? new OTLPTraceExporterProto(otlpOptions(exporter.url, "traces", exporter.literalUrl === true))
+            : new OTLPTraceExporterHttp(otlpOptions(exporter.url, "traces", exporter.literalUrl === true)));
+    }
+    if (resolved.metrics !== false) {
+        const metricsConfig = resolved.metrics;
+        const metricExporters = exportersForSignal(resolved.exporters, "metrics");
+        state.metrics.temporality = metricTemporalitySelector(metricsConfig.temporality);
+        if (metricExporters.length > 0) {
+            state.metrics.start();
+        }
+        state.metrics.targets = metricExporters.map((exporter) => {
+            const options = {
+                ...otlpOptions(exporter.url, "metrics", exporter.literalUrl === true),
+                temporalityPreference: metricTemporalityPreference(metricsConfig, log),
+            };
+            return isProtobuf(exporter.protocol)
+                ? new OTLPMetricExporterProto(options)
+                : new OTLPMetricExporterHttp(options);
+        });
+    }
+    if (resolved.logs !== false) {
+        state.logs.targets = exportersForSignal(resolved.exporters, "logs").map((exporter) => isProtobuf(exporter.protocol)
+            ? new OTLPLogExporterProto(otlpOptions(exporter.url, "logs", exporter.literalUrl === true))
+            : new OTLPLogExporterHttp(otlpOptions(exporter.url, "logs", exporter.literalUrl === true)));
+    }
+}
+function otlpOptions(url, signal, literalUrl) {
+    const base = url.replace(/\/$/, "");
+    return {
+        url: literalUrl ? base : `${base}/v1/${signal}`,
+        headers: async () => parseOtelHeaders(process.env.OTEL_EXPORTER_OTLP_HEADERS),
+    };
+}
+function isProtobuf(protocol) {
+    return protocol !== "http/json";
+}
+function parseResourceAttributes(raw) {
+    const out = {};
+    if (raw === undefined || raw.trim().length === 0) {
+        return out;
+    }
+    for (const part of raw.split(",")) {
+        const idx = part.indexOf("=");
+        if (idx <= 0) {
+            continue;
+        }
+        const key = part.slice(0, idx).trim();
+        const value = decodeAttribute(part.slice(idx + 1).trim());
+        if (key.length > 0 && value.length > 0) {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+function decodeAttribute(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+function nonEmpty(value) {
+    return value !== undefined && value.length > 0;
+}
+function deferred() {
+    let settle;
+    let settled = false;
+    const promise = new Promise((resolve) => {
+        settle = (value) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            resolve(value);
+        };
+    });
+    return {
+        promise,
+        settle(value) {
+            settle?.(value);
+        },
+    };
+}
+async function flushExporter(target) {
+    if (!("forceFlush" in target) || typeof target.forceFlush !== "function") {
+        return;
+    }
+    await Promise.resolve(target.forceFlush.call(target));
+}
+/**
+ * Holds items until the resource settles. A batch processor waits on an
+ * unsettled resource with no limit, and each waiting batch stays in memory.
+ * With no endpoint the resource can stay unsettled for the process lifetime.
+ */
+class HeldUntilSettled {
+    constructor(forward) {
+        this.forward = forward;
+        this.held = [];
+    }
+    push(item) {
+        if (this.held === undefined) {
+            this.forward(item);
+            return;
+        }
+        if (this.held.length < MAX_HELD_PER_SIGNAL) {
+            this.held.push(item);
+        }
+    }
+    release() {
+        const held = this.held;
+        if (held === undefined) {
+            return;
+        }
+        this.held = undefined;
+        for (const item of held) {
+            this.forward(item);
+        }
+    }
+}
+class ResourceGatedSpanProcessor {
+    constructor(inner) {
+        this.inner = inner;
+        this.ended = new HeldUntilSettled((span) => inner.onEnd(span));
+    }
+    onStart(span, parentContext) {
+        this.inner.onStart(span, parentContext);
+    }
+    onEnd(span) {
+        this.ended.push(span);
+    }
+    release() {
+        this.ended.release();
+    }
+    forceFlush() {
+        return this.inner.forceFlush();
+    }
+    shutdown() {
+        return this.inner.shutdown();
+    }
+}
+class ResourceGatedLogProcessor {
+    constructor(inner) {
+        this.inner = inner;
+        this.emitted = new HeldUntilSettled(([record, recordContext]) => inner.onEmit(record, recordContext));
+    }
+    onEmit(logRecord, recordContext) {
+        this.emitted.push([logRecord, recordContext]);
+    }
+    release() {
+        this.emitted.release();
+    }
+    forceFlush() {
+        return this.inner.forceFlush();
+    }
+    shutdown() {
+        return this.inner.shutdown();
+    }
+}
+class ForwardingSpanExporter {
+    constructor() {
+        this.targets = [];
+    }
+    export(spans, resultCallback) {
+        exportAll(this.targets, (target, done) => target.export(spans, done), resultCallback);
+    }
+    async forceFlush() {
+        await Promise.all(this.targets.map((target) => flushExporter(target)));
+    }
+    async shutdown() {
+        await Promise.all(this.targets.map((target) => target.shutdown()));
+    }
+}
+class ForwardingLogExporter {
+    constructor() {
+        this.targets = [];
+    }
+    export(records, resultCallback) {
+        exportAll(this.targets, (target, done) => target.export(records, done), resultCallback);
+    }
+    async forceFlush() {
+        await Promise.all(this.targets.map((target) => flushExporter(target)));
+    }
+    async shutdown() {
+        await Promise.all(this.targets.map((target) => target.shutdown()));
+    }
+}
+class StartableMetricReader extends PeriodicExportingMetricReader {
+    constructor() {
+        super(...arguments);
+        this.started = false;
+    }
+    onInitialized() { }
+    async onForceFlush() {
+        if (this.started) {
+            await super.onForceFlush();
+        }
+    }
+    start() {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        super.onInitialized();
+    }
+}
+class ForwardingMetricExporter {
+    constructor() {
+        this.targets = [];
+        this.temporality = DeltaTemporalitySelector;
+    }
+    start() {
+        this.reader?.start();
+    }
+    export(metricsBatch, resultCallback) {
+        exportAll(this.targets, (target, done) => target.export(metricsBatch, done), resultCallback);
+    }
+    selectAggregationTemporality(instrumentType) {
+        return this.temporality(instrumentType);
+    }
+    async forceFlush() {
+        await Promise.all(this.targets.map((target) => target.forceFlush()));
+    }
+    async shutdown() {
+        await Promise.all(this.targets.map((target) => target.shutdown()));
+    }
+}
+function exportAll(targets, send, done) {
+    if (targets.length === 0) {
+        done({ code: ExportResultCode.SUCCESS });
+        return;
+    }
+    let pending = targets.length;
+    let failure;
+    for (const target of targets) {
+        send(target, (result) => {
+            if (result.code !== ExportResultCode.SUCCESS && failure === undefined) {
+                failure = result;
+            }
+            pending -= 1;
+            if (pending === 0) {
+                done(failure ?? { code: ExportResultCode.SUCCESS });
+            }
+        });
+    }
+}