autotel 3.7.0 → 4.1.0

package/skills/migrate-to-autotel/SKILL.md

@@ -68,7 +68,7 @@ import { init } from 'autotel';
 
 init({
   service: 'my-app',
-  exporter: { url: process.env.OTEL_ENDPOINT! },
+  endpoint: process.env.OTEL_ENDPOINT!,
 });
 ```
 
@@ -78,7 +78,7 @@ init({
 
 - `useLogger().set({ … })` flattens onto the active span — no more `span.setAttribute('user.id', id)` boilerplate.
 - `attributeRedactor: 'default'` — PII masking for free in production.
-- `composeSpanProcessors([…])` for multi-backend tee.
+- `destinations: [...]` for straightforward OTLP multi-backend fan-out.
 - Cloudflare Workers + Edge support out of the box (`defineWorkerFetch`).
 
 ### What stays the same
@@ -121,20 +121,27 @@ init({
 
 ### Step 3: Decide on errors-only vs full tracing
 
-Sentry shines at errors; for tracing you may want to fan out to Honeycomb or Grafana Tempo. Use `composeSpanProcessors`:
+Sentry shines at errors; for tracing you may want to fan out to Honeycomb or Grafana Tempo. If both targets are plain OTLP backends, prefer `destinations`:
 
 ```typescript
-spanProcessors: composeSpanProcessors([
-  new BatchSpanProcessor(new SentrySpanExporter({ dsn })),
-  new BatchSpanProcessor(
-    new OTLPHttpJsonExporter({
-      url: honeycombUrl,
+init({
+  service: 'my-app',
+  destinations: [
+    {
+      endpoint: grafanaUrl,
+      headers: 'Authorization=Basic ...',
+    },
+    {
+      endpoint: honeycombUrl,
       headers: { 'x-honeycomb-team': key },
-    }),
-  ),
-]);
+      signals: ['traces'],
+    },
+  ],
+});
 ```
 
+If one destination needs a non-OTLP exporter or custom filtering, drop to `composeSpanProcessors`.
+
 ## From Datadog APM
 
 Datadog APM uses its own format and proprietary tracer. The migration path is OTLP → Datadog OTLP intake, then sunset `dd-trace`.
@@ -150,10 +157,8 @@ import { init } from 'autotel';
 
 init({
   service: 'my-app',
-  exporter: {
-    url: 'https://trace.agent.datadoghq.com/api/v0.4/traces',
-    headers: { 'dd-api-key': process.env.DD_API_KEY! },
-  },
+  endpoint: 'https://trace.agent.datadoghq.com/api/v0.4/traces',
+  headers: { 'dd-api-key': process.env.DD_API_KEY! },
 });
 ```
 
@@ -191,10 +196,8 @@ Drop it from `start` script and `NODE_OPTIONS`.
 ```typescript
 init({
   service: 'my-app',
-  exporter: {
-    url: 'https://otlp.nr-data.net/v1/traces',
-    headers: { 'api-key': process.env.NEW_RELIC_LICENSE_KEY! },
-  },
+  endpoint: 'https://otlp.nr-data.net/v1/traces',
+  headers: { 'api-key': process.env.NEW_RELIC_LICENSE_KEY! },
 });
 ```
 
@@ -216,10 +219,8 @@ Beelines for Node was Honeycomb's pre-OTel SDK. Migration is straightforward —
 ```typescript
 init({
   service: 'my-app',
-  exporter: {
-    url: 'https://api.honeycomb.io/v1/traces',
-    headers: { 'x-honeycomb-team': process.env.HONEYCOMB_API_KEY! },
-  },
+  endpoint: 'https://api.honeycomb.io',
+  headers: { 'x-honeycomb-team': process.env.HONEYCOMB_API_KEY! },
 });
 ```
 

package/skills/review-otel-patterns/SKILL.md

@@ -74,7 +74,7 @@ export function register() {
   if (process.env.NEXT_RUNTIME === 'nodejs') {
     init({
       service: 'my-app',
-      exporter: { url: process.env.OTLP_ENDPOINT! },
+      endpoint: process.env.OTLP_ENDPOINT!,
       sampling: { rates: { server: 25, client: 5 } },
       attributeRedactor: 'default',
     });
@@ -201,7 +201,7 @@ export const handler = withLambda(async (event) => {
 ```typescript
 import { init, trace } from 'autotel';
 
-init({ service: 'my-worker', exporter: { url: process.env.OTLP_ENDPOINT! } });
+init({ service: 'my-worker', endpoint: process.env.OTLP_ENDPOINT! });
 
 const processJob = trace(async (job: Job) => {
   // span auto-named after the function
@@ -219,7 +219,8 @@ All options work with `init()`, framework adapters, and `wrapModule` / `defineWo
 | Option                                  | Type                                                            | Default           | Description                                                     |
 | --------------------------------------- | --------------------------------------------------------------- | ----------------- | --------------------------------------------------------------- |
 | `service` / `service.name`              | `string`                                                        | `'app'`           | Service name in `service.name` resource attribute               |
-| `exporter`                              | `{ url, headers?, protocol? }`                                  | —                 | OTLP HTTP/JSON or HTTP/protobuf endpoint                        |
+| `endpoint`                              | `string`                                                        | —                 | Single OTLP destination shorthand                               |
+| `destinations`                          | `Array<{ endpoint, headers?, protocol?, signals? }>`            | —                 | Declarative OTLP fan-out to multiple backends                   |
 | `spanProcessors`                        | `SpanProcessor[]`                                               | —                 | Use **instead of** `exporter` for full control                  |
 | `sampling.rates`                        | `{ server?: number, client?: number, internal?: number }`       | `100%`            | Head sampling per span kind (0–100%)                            |
 | `sampling.tail`                         | `TailSampleFn`                                                  | —                 | Keep traces matching predicate (e.g. errors, slow)              |
@@ -291,7 +292,7 @@ Switch backends with **no code changes** — autotel speaks OTLP HTTP/JSON and H
 | New Relic                        | `https://otlp.nr-data.net/v1/traces`                       | `{ 'api-key': '<key>' }`              |
 | Local Jaeger / Tempo / Collector | `http://localhost:4318/v1/traces`                          | —                                     |
 
-Use `init({ exporter: { url, headers } })`. Multiple destinations? Use `composeSpanProcessors([batchA, batchB])` (see Composition below).
+Use `init({ endpoint, headers })` for one backend. For multiple OTLP backends, prefer `init({ destinations: [...] })`. Drop to `composeSpanProcessors([batchA, batchB])` only when you need custom processor-level control.
 
 ---
 
@@ -385,7 +386,9 @@ Compose them at build time with `composeSpanProcessors([...])` — no boilerplat
 
 ## AI SDK integration (gen-ai semantic conventions)
 
-autotel implements the **OTel gen-ai semantic conventions** out of the box. Token usage, tool calls, model info, latency, cost — captured as standard attributes (`gen_ai.usage.input_tokens`, `gen_ai.tool.name`, `gen_ai.response.finish_reason`, …) so any backend that understands OTel can render LLM telemetry without custom mapping.
+autotel implements the **OTel gen-ai semantic conventions** out of the box. Token usage, tool calls, model info, latency, cost — captured as standard attributes (`gen_ai.usage.input_tokens`, `gen_ai.tool.name`, `gen_ai.response.finish_reasons`, …) so any backend that understands OTel can render LLM telemetry without custom mapping.
+
+> Node.js apps get the same canonical `gen_ai.*` conventions (plus cost, metric views, and agent governance) from the `autotel-genai` package — `traceGenAI` / `recordGenAiUsage` from `autotel-genai/trace` and `genAiMetricViews` from `autotel-genai/metrics`. `withAiTelemetry` below is the edge-runtime entry point.
 
 ```typescript
 import { trace } from 'autotel';
@@ -402,7 +405,7 @@ const handler = trace(async (req) => {
 });
 ```
 
-Captured attributes per call: `gen_ai.system`, `gen_ai.request.model`, `gen_ai.usage.{input,output,reasoning,cache_read}_tokens`, `gen_ai.response.finish_reason`, `gen_ai.response.id`, plus per-tool spans with `gen_ai.tool.name`, `gen_ai.tool.duration`. Cost estimation comes for free if you pass a pricing map to `withAiTelemetry`.
+Captured attributes per call: `gen_ai.provider.name`, `gen_ai.request.model`, `gen_ai.usage.input_tokens` / `output_tokens` / `reasoning.output_tokens` / `cache_read.input_tokens`, `gen_ai.response.finish_reasons`, `gen_ai.response.id`, plus per-tool spans with `gen_ai.tool.name`. Cost estimation (`gen_ai.usage.cost.usd`) comes for free if you pass a pricing map to `withAiTelemetry`.
 
 Anti-patterns to detect:
 

package/skills/tune-sampling/SKILL.md

@@ -108,7 +108,12 @@ const tail = new TailSamplingProcessor({
 
     // 4. Always keep AI traces (rare + expensive — full visibility helps)
     if (
-      trace.spans.some((s) => typeof s.attributes['gen_ai.system'] === 'string')
+      trace.spans.some(
+        (s) =>
+          typeof s.attributes['gen_ai.provider.name'] === 'string' ||
+          // legacy: third-party instrumentations may still emit gen_ai.system
+          typeof s.attributes['gen_ai.system'] === 'string',
+      )
     )
       return true;
 
@@ -142,8 +147,8 @@ keep: (trace) => {
   const cost = trace.spans.reduce(
     (acc, s) =>
       acc +
-      (typeof s.attributes['gen_ai.cost.usd'] === 'number'
-        ? (s.attributes['gen_ai.cost.usd'] as number)
+      (typeof s.attributes['gen_ai.usage.cost.usd'] === 'number'
+        ? (s.attributes['gen_ai.usage.cost.usd'] as number)
         : 0),
     0,
   );

package/src/attributes/builders.ts

@@ -38,7 +38,6 @@ import {
   FaaSAttributes,
   FeatureFlagAttributes,
   MessagingAttributes,
-  GenAIAttributes,
   RPCAttributes,
   GraphQLAttributes,
   OTelAttributes,
@@ -477,25 +476,8 @@ export const attrs = {
     },
   },
 
-  genAI: {
-    system: (value: string) => ({ [GenAIAttributes.system]: value }),
-    requestModel: (value: string) => ({
-      [GenAIAttributes.requestModel]: value,
-    }),
-    responseModel: (value: string) => ({
-      [GenAIAttributes.responseModel]: value,
-    }),
-    operationName: (value: 'chat' | 'completion' | 'embedding') => ({
-      [GenAIAttributes.operationName]: value,
-    }),
-    usagePromptTokens: (value: number) => ({
-      [GenAIAttributes.usagePromptTokens]: value,
-    }),
-    usageCompletionTokens: (value: number) => ({
-      [GenAIAttributes.usageCompletionTokens]: value,
-    }),
-    provider: (value: string) => ({ [GenAIAttributes.provider]: value }),
-  },
+  // GenAI/LLM attribute builders moved to the `autotel-genai` package
+  // (canonical `gen_ai.*` semantic conventions).
 
   rpc: {
     system: (value: string) => ({ [RPCAttributes.system]: value }),

package/src/attributes/index.ts

@@ -70,7 +70,6 @@ export type {
   K8sAttrs,
   FaaSAttrs,
   ThreadAttrs,
-  GenAIAttrs,
   RPCAttrs,
   GraphQLAttrs,
   ClientAttrs,

package/src/attributes/registry.ts

@@ -155,15 +155,8 @@ export const MessagingAttributes = {
   consumerGroup: 'messaging.consumer.group' as const,
 } as const;
 
-export const GenAIAttributes = {
-  system: 'gen.ai.system' as const,
-  requestModel: 'gen.ai.request.model' as const,
-  responseModel: 'gen.ai.response.model' as const,
-  operationName: 'gen.ai.operation.name' as const,
-  usagePromptTokens: 'gen.ai.usage.prompt_tokens' as const,
-  usageCompletionTokens: 'gen.ai.usage.completion_tokens' as const,
-  provider: 'gen.ai.provider' as const,
-} as const;
+// GenAI attribute registry moved to the `autotel-genai` package, which uses the
+// canonical `gen_ai.*` namespace (these legacy `gen.ai.*` keys were non-spec).
 
 export const RPCAttributes = {
   system: 'rpc.system' as const,

package/src/attributes/types.ts

@@ -155,14 +155,6 @@ export interface ThreadAttrs {
   name?: string;
 }
 
-export interface GenAIAttrs {
-  system?: string;
-  requestModel?: string;
-  responseModel?: string;
-  operationName?: 'chat' | 'completion' | 'embedding';
-  provider?: string;
-}
-
 export interface RPCAttrs {
   system?: string;
   service?: string;

package/src/index.ts

@@ -241,43 +241,9 @@ export {
   createObservableGauge,
 } from './metric-helpers';
 
-// LLM-tuned histogram buckets — pass genAiMetricViews() to your
-// MeterProvider so gen_ai.* histograms have useful resolution.
-export {
-  GEN_AI_DURATION_BUCKETS_SECONDS,
-  GEN_AI_TOKEN_USAGE_BUCKETS,
-  GEN_AI_COST_USD_BUCKETS,
-  genAiMetricViews,
-  llmHistogramAdvice,
-} from './gen-ai-metrics';
-
-// OTel GenAI span event helpers — record prompt-sent / response-received
-// / retry / tool-call / stream-first-token as timestamped events aligned
-// with the published GenAI semantic conventions.
-export {
-  recordPromptSent,
-  recordResponseReceived,
-  recordRetry,
-  recordToolCall,
-  recordStreamFirstToken,
-  type PromptSentEvent,
-  type ResponseReceivedEvent,
-  type RetryEvent,
-  type ToolCallEvent,
-  type StreamFirstTokenEvent,
-} from './gen-ai-events';
-
-// Per-model LLM cost estimation — estimate USD cost from token usage and
-// record it as the gen_ai.usage.cost.usd span attribute.
-export {
-  estimateLLMCost,
-  recordLLMCost,
-  MODEL_PRICING,
-  GEN_AI_COST_ATTRIBUTE,
-  type ModelPricing,
-  type TokenUsage,
-  type EstimateCostOptions,
-} from './gen-ai-cost';
+// GenAI / LLM instrumentation (cost, token usage, metric buckets, span event
+// helpers, traceLLM) lives in the dedicated `autotel-genai` package — canonical
+// `gen_ai.*` semantic conventions. Core stays generic and AI-free.
 
 // Tracer helpers for custom spans
 export {
@@ -303,13 +269,11 @@ export {
   getAutotelTracer,
 } from './tracer-provider';
 
-// Semantic convention helpers
+// Semantic convention helpers (GenAI/LLM helpers moved to `autotel-genai`).
 export {
-  traceLLM,
   traceDB,
   traceHTTP,
   traceMessaging,
-  type LLMConfig,
   type DBConfig,
   type HTTPConfig,
   type MessagingConfig,
@@ -389,7 +353,6 @@ export {
   type K8sAttrs,
   type FaaSAttrs,
   type ThreadAttrs,
-  type GenAIAttrs,
   type RPCAttrs,
   type GraphQLAttrs,
   type ClientAttrs,

package/src/init.customization.test.ts

@@ -325,6 +325,77 @@ describe('init() customization', () => {
     });
   });
 
+  it('supports declarative multi-destination OTLP fan-out', async () => {
+    const {
+      init,
+      traceExporterOptions,
+      metricExporterOptions,
+      logExporterOptions,
+      metricReaderOptions,
+    } = await loadInitWithMocks();
+
+    init({
+      service: 'fanout-app',
+      logs: true,
+      destinations: [
+        {
+          endpoint: 'https://otlp-gateway.grafana.net/otlp',
+          headers: { Authorization: 'Basic grafana' },
+        },
+        {
+          endpoint: 'https://api.honeycomb.io',
+          headers: { 'x-honeycomb-team': 'hny' },
+          signals: ['traces'],
+        },
+      ],
+    });
+
+    expect(traceExporterOptions).toHaveLength(2);
+    expect(traceExporterOptions[0]).toMatchObject({
+      url: 'https://otlp-gateway.grafana.net/otlp/v1/traces',
+      headers: { Authorization: 'Basic grafana' },
+    });
+    expect(traceExporterOptions[1]).toMatchObject({
+      url: 'https://api.honeycomb.io/v1/traces',
+      headers: { 'x-honeycomb-team': 'hny' },
+    });
+
+    expect(metricExporterOptions).toHaveLength(1);
+    expect(metricExporterOptions[0]).toMatchObject({
+      url: 'https://otlp-gateway.grafana.net/otlp/v1/metrics',
+    });
+    expect(metricReaderOptions).toHaveLength(1);
+
+    expect(logExporterOptions).toHaveLength(1);
+    expect(logExporterOptions[0]).toMatchObject({
+      url: 'https://otlp-gateway.grafana.net/otlp/v1/logs',
+    });
+  });
+
+  it('lets destinations inherit top-level protocol and headers', async () => {
+    const { init, traceExporterOptions, metricExporterOptions } =
+      await loadInitWithMocks();
+
+    init({
+      service: 'fanout-inherited',
+      protocol: 'http',
+      headers: 'Authorization=Bearer shared',
+      destinations: [
+        { endpoint: 'https://grafana.example.com/otlp' },
+        { endpoint: 'https://honeycomb.example.com' },
+      ],
+    });
+
+    expect(traceExporterOptions).toHaveLength(2);
+    expect(traceExporterOptions[0]).toMatchObject({
+      headers: { Authorization: 'Bearer shared' },
+    });
+    expect(traceExporterOptions[1]).toMatchObject({
+      headers: { Authorization: 'Bearer shared' },
+    });
+    expect(metricExporterOptions).toHaveLength(2);
+  });
+
   it('resolves sampling preset shorthand to a sampler instance', async () => {
     const { init, getDefaultSampler } = await loadInitWithMocks();
 

package/src/init.ts

@@ -126,6 +126,33 @@ type OTLPExporterConfig = {
   concurrencyLimit?: number;
 };
 
+export type OtlpSignal = 'traces' | 'metrics' | 'logs';
+
+export interface OtlpDestinationConfig {
+  /**
+   * Base OTLP endpoint for this destination.
+   * HTTP destinations may omit `/v1/{signal}`; autotel appends it automatically.
+   * gRPC destinations should point at the collector host:port.
+   */
+  endpoint: string;
+
+  /**
+   * Headers for this destination. Falls back to top-level `headers`.
+   */
+  headers?: Record<string, string> | string;
+
+  /**
+   * Protocol for this destination. Falls back to top-level `protocol`.
+   */
+  protocol?: 'http' | 'grpc';
+
+  /**
+   * Signals to send to this destination.
+   * Defaults to all signals supported by the current init() config.
+   */
+  signals?: OtlpSignal[];
+}
+
 // Lazy-load gRPC exporters (optional peer dependencies)
 let OTLPTraceExporterGRPC:
   | (new (config: OTLPExporterConfig) => SpanExporter)
@@ -415,11 +442,45 @@ export interface AutotelConfig {
 
   /**
    * OTLP endpoint for traces/metrics/logs
+   * Single-destination shorthand. For multi-backend OTLP fan-out, use
+   * `destinations` instead.
    * Only used if you don't provide custom exporters/processors
    * @default process.env.OTLP_ENDPOINT || 'http://localhost:4318'
    */
   endpoint?: string;
 
+  /**
+   * Declarative OTLP multi-destination config.
+   * Each destination can override endpoint, headers, protocol, and signals.
+   *
+   * This is the high-level alternative to wiring `spanExporters`,
+   * `spanProcessors`, `metricReaders`, and `logRecordProcessors` manually when
+   * you want to fan telemetry out to multiple OTLP backends.
+   *
+   * When provided, `destinations` takes precedence over the single `endpoint`
+   * shorthand for built-in OTLP exporters/readers/processors.
+   *
+   * @example Grafana + Honeycomb for traces, Grafana only for metrics/logs
+   * ```typescript
+   * init({
+   *   service: 'my-app',
+   *   logs: true,
+   *   destinations: [
+   *     {
+   *       endpoint: 'https://otlp-gateway-prod-eu-west-2.grafana.net/otlp',
+   *       headers: { Authorization: 'Basic ...' },
+   *     },
+   *     {
+   *       endpoint: 'https://api.honeycomb.io',
+   *       headers: { 'x-honeycomb-team': '...' },
+   *       signals: ['traces'],
+   *     },
+   *   ],
+   * })
+   * ```
+   */
+  destinations?: OtlpDestinationConfig[];
+
   /**
    * Custom span processors for traces (supports multiple processors)
    * Allows you to use any backend: Jaeger, Zipkin, Datadog, New Relic, etc.
@@ -1406,6 +1467,45 @@ function normalizeOtlpHeaders(
   return parsed;
 }
 
+type ResolvedOtlpDestination = {
+  endpoint: string;
+  protocol: 'http' | 'grpc';
+  headers?: Record<string, string>;
+  signals?: Set<OtlpSignal>;
+};
+
+function resolveOtlpDestinations(
+  config: AutotelConfig,
+  fallbackEndpoint?: string,
+): ResolvedOtlpDestination[] {
+  const rawDestinations =
+    config.destinations !== undefined
+      ? config.destinations
+      : fallbackEndpoint
+        ? [
+            {
+              endpoint: fallbackEndpoint,
+              headers: config.headers,
+              protocol: config.protocol,
+            },
+          ]
+        : [];
+
+  return rawDestinations.map((destination) => ({
+    endpoint: destination.endpoint,
+    protocol: resolveProtocol(destination.protocol ?? config.protocol),
+    headers: normalizeOtlpHeaders(destination.headers ?? config.headers),
+    signals: destination.signals ? new Set(destination.signals) : undefined,
+  }));
+}
+
+function destinationSupportsSignal(
+  destination: ResolvedOtlpDestination,
+  signal: OtlpSignal,
+): boolean {
+  return destination.signals ? destination.signals.has(signal) : true;
+}
+
 /**
  * Initialize autotel - Write Once, Observe Everywhere
  *
@@ -1533,7 +1633,6 @@ export function init(cfg: AutotelConfig): void {
   // Initialize OpenTelemetry
   // Only use endpoint if explicitly configured (no default fallback)
   let endpoint = mergedConfig.endpoint ?? devtoolsConfig.endpoint;
-  const otlpHeaders = normalizeOtlpHeaders(mergedConfig.headers);
   const version = mergedConfig.version || detectVersion();
   const environment =
     mergedConfig.environment || process.env.NODE_ENV || 'development';
@@ -1600,8 +1699,7 @@ export function init(cfg: AutotelConfig): void {
     );
   }
 
-  // Resolve OTLP protocol (http or grpc)
-  const protocol = resolveProtocol(mergedConfig.protocol);
+  const otlpDestinations = resolveOtlpDestinations(mergedConfig, endpoint);
 
   // Backward-compatible singular aliases. Plural forms take precedence when both are provided.
   const configuredSpanProcessors =
@@ -1643,16 +1741,23 @@ export function init(cfg: AutotelConfig): void {
         new TailSamplingSpanProcessor(new BatchSpanProcessor(exporter)),
       );
     }
-  } else if (endpoint) {
-    // Default: OTLP with tail sampling (only if endpoint is configured)
-    const traceExporter = createTraceExporter(protocol, {
-      url: formatEndpointUrl(endpoint, 'traces', protocol),
-      headers: otlpHeaders,
-    });
-
-    spanProcessors.push(
-      new TailSamplingSpanProcessor(new BatchSpanProcessor(traceExporter)),
-    );
+  } else {
+    for (const destination of otlpDestinations) {
+      if (!destinationSupportsSignal(destination, 'traces')) continue;
+
+      const traceExporter = createTraceExporter(destination.protocol, {
+        url: formatEndpointUrl(
+          destination.endpoint,
+          'traces',
+          destination.protocol,
+        ),
+        headers: destination.headers,
+      });
+
+      spanProcessors.push(
+        new TailSamplingSpanProcessor(new BatchSpanProcessor(traceExporter)),
+      );
+    }
   }
   // If no endpoint and no custom processors/exporters, array remains empty
   // SDK will still work but won't export traces
@@ -1760,18 +1865,25 @@ export function init(cfg: AutotelConfig): void {
   if (configuredMetricReaders && configuredMetricReaders.length > 0) {
     // User provided custom metric readers
     metricReaders.push(...configuredMetricReaders);
-  } else if (metricsEnabled && endpoint) {
-    // Default: OTLP metrics exporter (only if endpoint is configured)
-    const metricExporter = createMetricExporter(protocol, {
-      url: formatEndpointUrl(endpoint, 'metrics', protocol),
-      headers: otlpHeaders,
-    });
-
-    metricReaders.push(
-      new PeriodicExportingMetricReader({
-        exporter: metricExporter,
-      }),
-    );
+  } else if (metricsEnabled) {
+    for (const destination of otlpDestinations) {
+      if (!destinationSupportsSignal(destination, 'metrics')) continue;
+
+      const metricExporter = createMetricExporter(destination.protocol, {
+        url: formatEndpointUrl(
+          destination.endpoint,
+          'metrics',
+          destination.protocol,
+        ),
+        headers: destination.headers,
+      });
+
+      metricReaders.push(
+        new PeriodicExportingMetricReader({
+          exporter: metricExporter,
+        }),
+      );
+    }
   }
 
   let logRecordProcessors: LogRecordProcessor[] | undefined;
@@ -1782,24 +1894,39 @@ export function init(cfg: AutotelConfig): void {
     logRecordProcessors = [...configuredLogRecordProcessors];
   }
 
-  // Auto-configure OTLP log exporter when logs are enabled and endpoint is set
-  if (logsEnabled && endpoint) {
-    const logExporter = createLogExporter(protocol, {
-      url: formatEndpointUrl(endpoint, 'logs', protocol),
-      headers: otlpHeaders,
-    });
+  // Auto-configure OTLP log exporters when logs are enabled.
+  if (logsEnabled) {
+    for (const destination of otlpDestinations) {
+      if (!destinationSupportsSignal(destination, 'logs')) continue;
+
+      const logExporter = createLogExporter(destination.protocol, {
+        url: formatEndpointUrl(
+          destination.endpoint,
+          'logs',
+          destination.protocol,
+        ),
+        headers: destination.headers,
+      });
 
-    let processor: LogRecordProcessor = new BatchLogRecordProcessor(
-      logExporter,
-    );
-    if (_stringRedactor) {
-      processor = new RedactingLogRecordProcessor(processor, _stringRedactor);
+      let processor: LogRecordProcessor = new BatchLogRecordProcessor(
+        logExporter,
+      );
+      if (_stringRedactor) {
+        processor = new RedactingLogRecordProcessor(processor, _stringRedactor);
+      }
+      if (!logRecordProcessors) {
+        logRecordProcessors = [];
+      }
+      logRecordProcessors.push(processor);
     }
-    if (!logRecordProcessors) {
-      logRecordProcessors = [];
+
+    if (
+      otlpDestinations.some((destination) =>
+        destinationSupportsSignal(destination, 'logs'),
+      )
+    ) {
+      logger.info({}, '[autotel] OTLP log exporter configured');
     }
-    logRecordProcessors.push(processor);
-    logger.info({}, '[autotel] OTLP log exporter configured');
   }
 
   // PostHog OTLP logs integration