@cursor/july 0.1.42 → 0.1.45

package/src/internal/otel/config.ts

@@ -0,0 +1,307 @@
+/**
+ * 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 function hasOtelEnv(env: NodeJS.ProcessEnv = process.env): boolean {
+  return (
+    nonEmpty(env.OTEL_EXPORTER_OTLP_ENDPOINT) ||
+    nonEmpty(env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT) ||
+    nonEmpty(env.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT) ||
+    nonEmpty(env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT)
+  );
+}
+
+/**
+ * Process-global authored config. OTel SDK is one per serve process — if
+ * several mounts ship `agent/otel.ts`, they must be identical.
+ */
+export function pickAuthoredOtel(
+  mounts: ReadonlyArray<{ slug: string; name: string; otel?: OtelDefinition }>
+): OtelDefinition | undefined {
+  const found = mounts.filter(
+    (m): m is typeof m & { otel: OtelDefinition } => m.otel !== undefined
+  );
+  if (found.length === 0) {
+    return undefined;
+  }
+  const first = found[0]!;
+  const key = stableConfigKey(first.otel);
+  for (const other of found.slice(1)) {
+    if (stableConfigKey(other.otel) !== key) {
+      const a = first.slug === "" ? first.name : first.slug;
+      const b = other.slug === "" ? other.name : other.slug;
+      throw new Error(
+        `Conflicting agent/otel.ts on mounts "${a}" and "${b}": OTel is process-global. Use identical defineOtel configs, or configure once via serve({ otel }) / OTEL_EXPORTER_OTLP_*.`
+      );
+    }
+  }
+  return first.otel;
+}
+
+/**
+ * Resolve effective config.
+ *
+ * Precedence: `serve({ otel: false })` disables; otherwise merge
+ * `serve({ otel })` over `defineOtel` over env defaults.
+ */
+export function resolveOtelConfig(input: {
+  authored?: OtelConfig;
+  serve?: OtelConfig | false;
+  env?: NodeJS.ProcessEnv;
+}): ResolvedOtelConfig {
+  const env = input.env ?? process.env;
+  if (input.serve === false) {
+    return disabled();
+  }
+
+  const authored = input.authored ?? {};
+  const serve = input.serve === undefined ? {} : input.serve;
+  const merged: OtelConfig = {
+    serviceName: serve.serviceName ?? authored.serviceName,
+    serviceVersion: serve.serviceVersion ?? authored.serviceVersion,
+    resourceAttributes: {
+      ...authored.resourceAttributes,
+      ...serve.resourceAttributes,
+    },
+    exporters: serve.exporters ?? authored.exporters,
+    traces: serve.traces ?? authored.traces,
+    metrics: serve.metrics ?? authored.metrics,
+    logs: serve.logs ?? authored.logs,
+  };
+
+  const envExporters = exportersFromEnv(env);
+  const exporters =
+    merged.exporters !== undefined && merged.exporters.length > 0
+      ? merged.exporters.map((e) => withEnvHeaders(e, env))
+      : envExporters;
+
+  const optedIn =
+    input.authored !== undefined ||
+    input.serve !== undefined ||
+    envExporters.length > 0;
+  if (!optedIn || exporters.length === 0) {
+    return disabled();
+  }
+
+  const traces = resolveSignal(merged.traces);
+  const metrics = resolveSignal(merged.metrics);
+  const logs = resolveLogs(merged.logs, env);
+
+  return {
+    enabled: traces !== false || metrics !== false || logs !== false,
+    serviceName: merged.serviceName ?? env.OTEL_SERVICE_NAME ?? "cursor",
+    serviceVersion: merged.serviceVersion,
+    resourceAttributes: merged.resourceAttributes ?? {},
+    exporters,
+    traces,
+    metrics,
+    logs,
+  };
+}
+
+export function parseOtelHeaders(
+  raw: string | undefined
+): Record<string, string> {
+  if (raw === undefined || raw.length === 0) {
+    return {};
+  }
+  const out: Record<string, string> = {};
+  for (const part of raw.split(",")) {
+    const idx = part.indexOf("=");
+    if (idx <= 0) {
+      continue;
+    }
+    const key = part.slice(0, idx).trim();
+    const value = part.slice(idx + 1).trim();
+    if (key.length > 0) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+
+/** Collapse `…/v1/{traces,metrics,logs}` to the collector base. */
+export function stripSignalPath(url: string): string {
+  return url.replace(/\/v1\/(traces|metrics|logs)\/?$/i, "");
+}
+
+/** Exporters that apply to one signal (honors per-exporter `signals`). */
+export function exportersForSignal(
+  exporters: readonly OtelExporterConfig[],
+  signal: OtelSignal
+): OtelExporterConfig[] {
+  return exporters.filter(
+    (exporter) =>
+      exporter.signals === undefined || exporter.signals.includes(signal)
+  );
+}
+
+function disabled(): ResolvedOtelConfig {
+  return {
+    enabled: false,
+    serviceName: "cursor",
+    serviceVersion: undefined,
+    resourceAttributes: {},
+    exporters: [],
+    traces: false,
+    metrics: false,
+    logs: false,
+  };
+}
+
+/**
+ * Build exporters from env. A shared `OTEL_EXPORTER_OTLP_ENDPOINT` fans out
+ * to every signal. Distinct `*_TRACES_ENDPOINT` / `*_METRICS_ENDPOINT` /
+ * `*_LOGS_ENDPOINT` values each become their own exporter scoped to that
+ * signal (OTel env spec).
+ */
+function exportersFromEnv(env: NodeJS.ProcessEnv): OtelExporterConfig[] {
+  const base = env.OTEL_EXPORTER_OTLP_ENDPOINT?.trim();
+  const traces = env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT?.trim();
+  const metrics = env.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT?.trim();
+  const logs = env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT?.trim();
+  const protocol = protocolFromEnv(env.OTEL_EXPORTER_OTLP_PROTOCOL);
+  const headers = parseOtelHeaders(env.OTEL_EXPORTER_OTLP_HEADERS);
+
+  if (nonEmpty(base)) {
+    return [{ url: stripSignalPath(base!), headers, protocol }];
+  }
+
+  const out: OtelExporterConfig[] = [];
+  pushSignalExporter(out, traces, "traces", headers, protocol);
+  pushSignalExporter(out, metrics, "metrics", headers, protocol);
+  pushSignalExporter(out, logs, "logs", headers, protocol);
+  return out;
+}
+
+function pushSignalExporter(
+  out: OtelExporterConfig[],
+  raw: string | undefined,
+  signal: OtelSignal,
+  headers: Record<string, string>,
+  protocol: "http/json" | "http/protobuf"
+): void {
+  if (!nonEmpty(raw)) {
+    return;
+  }
+  out.push({
+    url: stripSignalPath(raw!),
+    headers,
+    protocol,
+    signals: [signal],
+  });
+}
+
+function withEnvHeaders(
+  exporter: OtelExporterConfig,
+  env: NodeJS.ProcessEnv
+): OtelExporterConfig {
+  const envHeaders = parseOtelHeaders(env.OTEL_EXPORTER_OTLP_HEADERS);
+  return {
+    url: stripSignalPath(exporter.url),
+    headers: { ...envHeaders, ...exporter.headers },
+    protocol:
+      exporter.protocol ?? protocolFromEnv(env.OTEL_EXPORTER_OTLP_PROTOCOL),
+    signals: exporter.signals,
+  };
+}
+
+function protocolFromEnv(
+  raw: string | undefined
+): "http/json" | "http/protobuf" {
+  const v = raw?.trim().toLowerCase();
+  if (v === "http/json" || v === "json") {
+    return "http/json";
+  }
+  // Default protobuf — matches Cursor enterprise OTLP/HTTP. grpc unsupported.
+  return "http/protobuf";
+}
+
+function resolveSignal<T extends object>(
+  value: boolean | T | undefined
+): false | T | Record<string, never> {
+  if (value === false) {
+    return false;
+  }
+  if (value === true || value === undefined) {
+    return {};
+  }
+  return value;
+}
+
+function resolveLogs(
+  value: OtelConfig["logs"],
+  env: NodeJS.ProcessEnv
+): false | OtelLogOptions {
+  if (value === false) {
+    return false;
+  }
+  const envPrompts = env.OTEL_LOG_USER_PROMPTS === "1";
+  const envTools = env.OTEL_LOG_TOOL_CONTENT === "1";
+  if (value === true) {
+    return { userPrompts: envPrompts, toolContent: envTools };
+  }
+  if (value === undefined) {
+    // Match OTel: unset / empty / `none` means logs off. Any other
+    // `OTEL_LOGS_EXPORTER` value (e.g. `otlp`) opts logs on.
+    if (!envPrompts && !envTools && !logsExporterOptIn(env)) {
+      return false;
+    }
+    return { userPrompts: envPrompts, toolContent: envTools };
+  }
+  return {
+    userPrompts: value.userPrompts ?? envPrompts,
+    toolContent: value.toolContent ?? envTools,
+  };
+}
+
+/** `OTEL_LOGS_EXPORTER=none` (or unset) must not enable log export. */
+function logsExporterOptIn(env: NodeJS.ProcessEnv): boolean {
+  const raw = env.OTEL_LOGS_EXPORTER?.trim().toLowerCase();
+  return raw !== undefined && raw.length > 0 && raw !== "none";
+}
+
+function stableConfigKey(def: OtelDefinition): string {
+  const { __agentServe: _brand, ...rest } = def;
+  return stable(rest);
+}
+
+function stable(value: unknown): string {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stable).join(",")}]`;
+  }
+  const obj = value as Record<string, unknown>;
+  return `{${Object.keys(obj)
+    .sort()
+    .map((key) => `${JSON.stringify(key)}:${stable(obj[key])}`)
+    .join(",")}}`;
+}
+
+function nonEmpty(value: string | undefined): boolean {
+  return value !== undefined && value.trim().length > 0;
+}

package/src/internal/otel/http.ts

@@ -0,0 +1,126 @@
+/**
+ * HTTP SERVER spans + W3C `traceparent` extraction for inbound requests.
+ */
+
+import type { IncomingMessage, ServerResponse } from "node:http";
+import {
+  type Context,
+  context,
+  propagation,
+  SpanKind,
+  SpanStatusCode,
+  trace,
+} from "@opentelemetry/api";
+import { W3CTraceContextPropagator } from "@opentelemetry/core";
+import type { OtelRuntime } from "./runtime.js";
+
+let propagatorInstalled = false;
+
+function ensurePropagator(): void {
+  if (propagatorInstalled) {
+    return;
+  }
+  propagation.setGlobalPropagator(new W3CTraceContextPropagator());
+  propagatorInstalled = true;
+}
+
+interface HttpSpanHandle {
+  context: Context;
+  end(statusCode: number, error?: unknown): void;
+}
+
+/**
+ * Instrument one inbound Node request: SERVER span, W3C extract, auto-end
+ * on response finish/close, run `fn` under the span context.
+ */
+export function instrumentHttp<T>(
+  runtime: OtelRuntime | undefined,
+  req: IncomingMessage,
+  res: ServerResponse,
+  fn: () => Promise<T>
+): Promise<T> {
+  const handle = startHttpSpan(runtime, req);
+  if (handle === undefined) {
+    return fn();
+  }
+  res.once("finish", () => {
+    handle.end(res.statusCode);
+  });
+  res.once("close", () => {
+    if (!res.writableFinished) {
+      handle.end(res.statusCode || 499);
+    }
+  });
+  return context.with(handle.context, fn);
+}
+
+function startHttpSpan(
+  runtime: OtelRuntime | undefined,
+  req: IncomingMessage
+): HttpSpanHandle | undefined {
+  if (runtime === undefined || runtime.config.traces === false) {
+    return undefined;
+  }
+  ensurePropagator();
+  const headers: Record<string, string> = {};
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (typeof value === "string") {
+      headers[key] = value;
+    } else if (Array.isArray(value) && value[0] !== undefined) {
+      headers[key] = value[0];
+    }
+  }
+  const parent = propagation.extract(context.active(), headers);
+  const method = req.method ?? "GET";
+  const path = (req.url ?? "/").split("?")[0] ?? "/";
+  const started = Date.now();
+  const span = runtime.tracer.startSpan(
+    "agent_sdk.http",
+    {
+      kind: SpanKind.SERVER,
+      attributes: {
+        "http.request.method": method,
+        "url.path": path,
+        "network.peer.address": req.socket.remoteAddress ?? "",
+      },
+    },
+    parent
+  );
+  const ctx = trace.setSpan(parent, span);
+  let ended = false;
+  return {
+    context: ctx,
+    end(statusCode, error) {
+      if (ended) {
+        return;
+      }
+      ended = true;
+      span.setAttribute("http.response.status_code", statusCode);
+      if (error !== undefined) {
+        span.recordException(
+          error instanceof Error ? error : new Error(String(error))
+        );
+        span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: error instanceof Error ? error.message : String(error),
+        });
+      } else if (statusCode >= 500) {
+        span.setStatus({ code: SpanStatusCode.ERROR });
+      } else {
+        span.setStatus({ code: SpanStatusCode.OK });
+      }
+      span.end();
+      runtime.httpDuration?.record(Date.now() - started, {
+        "http.request.method": method,
+        "http.response.status_code": statusCode,
+        "url.path": routeClass(path),
+      });
+    },
+  };
+}
+
+function routeClass(path: string): string {
+  return path
+    .replace(/\/sessions\/[0-9a-f-]{8,}/gi, "/sessions/:id")
+    .replace(/\/[0-9a-f]{8,}(?:-[0-9a-f]{4,})+/gi, "/:id");
+}

package/src/internal/otel/runtime.ts

@@ -0,0 +1,271 @@
+/**
+ * Process-level OTel SDK (OTLP HTTP exporters for traces / metrics / logs).
+ *
+ * Refuses to install a second global Tracer/Meter/Logger provider when one
+ * already owns the process (CLI, extension host, etc.). Spans still use
+ * `trace.getTracer()` so they nest under an existing parent when present.
+ */
+
+import type { Histogram, Meter, Tracer } from "@opentelemetry/api";
+import { DiagLogLevel, diag, metrics, trace } from "@opentelemetry/api";
+import type { Logger as OtelLogger } from "@opentelemetry/api-logs";
+import { logs } from "@opentelemetry/api-logs";
+import { OTLPLogExporter as OTLPLogExporterHttp } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPLogExporter as OTLPLogExporterProto } from "@opentelemetry/exporter-logs-otlp-proto";
+import { 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 {
+  type Resource,
+  resourceFromAttributes,
+} from "@opentelemetry/resources";
+import {
+  BatchLogRecordProcessor,
+  LoggerProvider,
+} from "@opentelemetry/sdk-logs";
+import {
+  AggregationTemporality,
+  MeterProvider,
+  PeriodicExportingMetricReader,
+} from "@opentelemetry/sdk-metrics";
+import {
+  BatchSpanProcessor,
+  NodeTracerProvider,
+  ParentBasedSampler,
+  TraceIdRatioBasedSampler,
+} from "@opentelemetry/sdk-trace-node";
+import {
+  ATTR_SERVICE_NAME,
+  ATTR_SERVICE_VERSION,
+} from "@opentelemetry/semantic-conventions";
+import type { OtelExporterConfig, OtelSignal } from "../../otel.js";
+import { exportersForSignal, type ResolvedOtelConfig } from "./config.js";
+
+const INSTRUMENTATION = "agent_sdk";
+
+export interface OtelRuntime {
+  config: ResolvedOtelConfig;
+  tracer: Tracer;
+  meter: Meter | undefined;
+  logger: OtelLogger | undefined;
+  httpDuration: Histogram | undefined;
+  shutdown: () => Promise<void>;
+}
+
+export function createOtelRuntime(
+  config: ResolvedOtelConfig,
+  log: (line: string) => void
+): OtelRuntime | undefined {
+  if (!config.enabled) {
+    return undefined;
+  }
+  const proto = process.env.OTEL_EXPORTER_OTLP_PROTOCOL?.trim().toLowerCase();
+  if (proto === "grpc") {
+    log(
+      "[agent-sdk:otel] OTEL_EXPORTER_OTLP_PROTOCOL=grpc is unsupported; using http/protobuf"
+    );
+  }
+  const sdk = startOtelSdk(config, log);
+  const meter =
+    config.metrics === false
+      ? undefined
+      : metrics.getMeterProvider().getMeter(INSTRUMENTATION);
+  return {
+    config,
+    tracer: trace.getTracer(INSTRUMENTATION),
+    meter,
+    logger: config.logs === false ? undefined : logs.getLogger(INSTRUMENTATION),
+    httpDuration:
+      meter === undefined
+        ? undefined
+        : meter.createHistogram("agent_sdk.http.duration", {
+            description: "HTTP request duration",
+            unit: "ms",
+          }),
+    shutdown: sdk.shutdown,
+  };
+}
+
+export async function shutdownOtelRuntime(
+  runtime: OtelRuntime | undefined
+): Promise<void> {
+  await runtime?.shutdown();
+}
+
+function startOtelSdk(
+  config: ResolvedOtelConfig,
+  logger: (line: string) => void
+): {
+  shutdown: () => Promise<void>;
+} {
+  diag.setLogger(
+    {
+      verbose: (m) => logger(`[agent-sdk:otel] ${m}`),
+      debug: (m) => logger(`[agent-sdk:otel] ${m}`),
+      info: (m) => logger(`[agent-sdk:otel] ${m}`),
+      warn: (m) => logger(`[agent-sdk:otel] warn: ${m}`),
+      error: (m) => logger(`[agent-sdk:otel] error: ${m}`),
+    },
+    DiagLogLevel.ERROR
+  );
+
+  const resource = buildResource(config);
+  let tracerProvider: NodeTracerProvider | undefined;
+  let meterProvider: MeterProvider | undefined;
+  let loggerProvider: LoggerProvider | undefined;
+
+  const traceOpts = config.traces;
+  if (traceOpts !== false) {
+    const exporters = exportersForSignal(config.exporters, "traces");
+    if (exporters.length > 0) {
+      if (hasRealTracerProvider()) {
+        logger(
+          "[agent-sdk:otel] TracerProvider already registered; reusing global (Agent SDK OTLP exporters not attached)"
+        );
+      } else {
+        tracerProvider = new NodeTracerProvider({
+          resource,
+          spanProcessors: exporters.map(
+            (exporter) =>
+              new BatchSpanProcessor(
+                createTraceExporter(exporter, signalUrl(exporter.url, "traces"))
+              )
+          ),
+          sampler: new ParentBasedSampler({
+            root: new TraceIdRatioBasedSampler(traceOpts.sampleRatio ?? 1),
+          }),
+        });
+        tracerProvider.register();
+      }
+    }
+  }
+
+  const metricOpts = config.metrics;
+  if (metricOpts !== false) {
+    const exporters = exportersForSignal(config.exporters, "metrics");
+    if (exporters.length > 0) {
+      const exportIntervalMillis = metricOpts.exportIntervalMillis ?? 10_000;
+      const provider = new MeterProvider({
+        resource,
+        readers: exporters.map(
+          (exporter) =>
+            new PeriodicExportingMetricReader({
+              exporter: createMetricExporter(
+                exporter,
+                signalUrl(exporter.url, "metrics")
+              ),
+              exportIntervalMillis,
+            })
+        ),
+      });
+      if (metrics.setGlobalMeterProvider(provider)) {
+        meterProvider = provider;
+      } else {
+        logger(
+          "[agent-sdk:otel] MeterProvider already registered; reusing global (Agent SDK OTLP exporters not attached)"
+        );
+        void provider.shutdown();
+      }
+    }
+  }
+
+  if (config.logs !== false) {
+    const exporters = exportersForSignal(config.exporters, "logs");
+    if (exporters.length > 0) {
+      const provider = new LoggerProvider({
+        resource,
+        processors: exporters.map(
+          (exporter) =>
+            new BatchLogRecordProcessor(
+              createLogExporter(exporter, signalUrl(exporter.url, "logs"))
+            )
+        ),
+      });
+      // api-logs returns the active provider (ours on success, existing otherwise).
+      if (logs.setGlobalLoggerProvider(provider) === provider) {
+        loggerProvider = provider;
+      } else {
+        logger(
+          "[agent-sdk:otel] LoggerProvider already registered; reusing global (Agent SDK OTLP exporters not attached)"
+        );
+        void provider.shutdown();
+      }
+    }
+  }
+
+  logger(
+    `[agent-sdk] otel enabled service=${config.serviceName} exporters=${config.exporters.length} traces=${config.traces !== false} metrics=${config.metrics !== false} logs=${config.logs !== false}`
+  );
+
+  return {
+    shutdown: async () => {
+      await Promise.allSettled([
+        tracerProvider?.shutdown(),
+        meterProvider?.shutdown(),
+        loggerProvider?.shutdown(),
+      ]);
+    },
+  };
+}
+
+function buildResource(config: ResolvedOtelConfig): Resource {
+  // Align with Cursor enterprise wire resource attrs where they overlap so
+  // Agent SDK traces join org metrics/logs in the same collector.
+  const resourceAttrs: Record<string, string> = {
+    [ATTR_SERVICE_NAME]: config.serviceName,
+    "telemetry.sdk.language": "nodejs",
+    "cursor.surface": "unspecified",
+    "cursor.entrypoint": "sdk_ts",
+    "agent_sdk.framework": "@cursor/july",
+    ...config.resourceAttributes,
+  };
+  if (config.serviceVersion !== undefined) {
+    resourceAttrs[ATTR_SERVICE_VERSION] = config.serviceVersion;
+  }
+  return resourceFromAttributes(resourceAttrs);
+}
+
+function signalUrl(base: string, signal: OtelSignal): string {
+  return `${base.replace(/\/$/, "")}/v1/${signal}`;
+}
+
+/** True when a non-noop TracerProvider already owns the process. */
+function hasRealTracerProvider(): boolean {
+  const provider = trace.getTracerProvider() as {
+    getDelegate?: () => { constructor: { name: string } };
+  };
+  const delegate = provider.getDelegate?.();
+  return (
+    delegate !== undefined && delegate.constructor.name !== "NoopTracerProvider"
+  );
+}
+
+function isProtobuf(exporter: OtelExporterConfig): boolean {
+  return exporter.protocol !== "http/json";
+}
+
+function createTraceExporter(exporter: OtelExporterConfig, url: string) {
+  const opts = { url, headers: exporter.headers };
+  return isProtobuf(exporter)
+    ? new OTLPTraceExporterProto(opts)
+    : new OTLPTraceExporterHttp(opts);
+}
+
+function createMetricExporter(exporter: OtelExporterConfig, url: string) {
+  const opts = {
+    url,
+    headers: exporter.headers,
+    temporalityPreference: AggregationTemporality.DELTA,
+  };
+  return isProtobuf(exporter)
+    ? new OTLPMetricExporterProto(opts)
+    : new OTLPMetricExporterHttp(opts);
+}
+
+function createLogExporter(exporter: OtelExporterConfig, url: string) {
+  const opts = { url, headers: exporter.headers };
+  return isProtobuf(exporter)
+    ? new OTLPLogExporterProto(opts)
+    : new OTLPLogExporterHttp(opts);
+}