@telemetry-dev/sdk 0.1.0

package/src/attrs.ts

@@ -0,0 +1,157 @@
+import type { Attributes, AttributeValue } from "@opentelemetry/api";
+
+import { diag, jsonAttr, omitUndefined } from "@telemetry-dev/otel";
+
+import { type CaptureConfig, prepareCaptureValue, truncate } from "./capture.ts";
+
+export type SpanType = "span" | "generation" | "tool" | "agent" | "embedding";
+
+// Operation names are taken verbatim by the ingest's deriveOperation. Plain spans always get an
+// explicit "function": without one, the propagated gen_ai.conversation.id would trip the ingest's
+// hasGenAi heuristic and misclassify them as "llm".
+export const SPAN_TYPE_OPERATIONS: Record<SpanType, string> = {
+  span: "function",
+  generation: "chat",
+  tool: "execute_tool",
+  agent: "invoke_agent",
+  embedding: "embeddings",
+};
+
+export function inputKeyFor(type: SpanType): string {
+  return type === "tool" ? "gen_ai.tool.call.arguments" : "gen_ai.input.messages";
+}
+
+export function outputKeyFor(type: SpanType): string {
+  return type === "tool" ? "gen_ai.tool.call.result" : "gen_ai.output.messages";
+}
+
+export interface TokenUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+  cacheReadInputTokens?: number;
+  cacheCreationInputTokens?: number;
+  reasoningOutputTokens?: number;
+}
+
+export interface GenerationFields {
+  model?: string;
+  provider?: string;
+  systemInstructions?: unknown;
+  responseModel?: string;
+  responseId?: string;
+  usage?: TokenUsage;
+  /** Optional client-side cost override; the server computes cost from usage by default. */
+  costUsd?: number;
+  finishReason?: string;
+  outputType?: string;
+  temperature?: number;
+  topP?: number;
+  topK?: number;
+  maxTokens?: number;
+  stopSequences?: string[];
+  seed?: number;
+  frequencyPenalty?: number;
+  presencePenalty?: number;
+  timeToFirstChunkMs?: number;
+}
+
+export interface ToolFields {
+  toolName?: string;
+  toolCallId?: string;
+  toolDescription?: string;
+}
+
+export interface AgentFields {
+  agentName?: string;
+  agentId?: string;
+}
+
+export interface SpanFields extends GenerationFields, ToolFields, AgentFields {
+  /** Rename the span (update only). */
+  name?: string;
+  input?: unknown;
+  output?: unknown;
+  /** Marks the span failed: status ERROR + error.type + an "exception" event. */
+  error?: unknown;
+  /** td.metadata.<key> on this span only; use propagateAttributes for scope-wide metadata. */
+  metadata?: Record<string, unknown>;
+  /** Raw attribute escape hatch, merged last. */
+  attributes?: Record<string, AttributeValue>;
+}
+
+export interface FieldCaptureConfig extends CaptureConfig {
+  captureInput: boolean;
+  captureOutput: boolean;
+}
+
+const RESERVED_METADATA_KEYS = new Set(["userId", "sessionId", "user_id", "session_id"]);
+
+export function fieldsToAttributes(
+  fields: SpanFields,
+  type: SpanType,
+  cfg: FieldCaptureConfig,
+): Attributes {
+  const attrs = omitUndefined({
+    "gen_ai.request.model": fields.model,
+    "gen_ai.provider.name": fields.provider,
+    "gen_ai.response.model": fields.responseModel,
+    "gen_ai.response.id": fields.responseId,
+    "gen_ai.usage.input_tokens": fields.usage?.inputTokens,
+    "gen_ai.usage.output_tokens": fields.usage?.outputTokens,
+    "gen_ai.usage.total_tokens": fields.usage?.totalTokens,
+    "gen_ai.usage.cache_read.input_tokens": fields.usage?.cacheReadInputTokens,
+    "gen_ai.usage.cache_creation.input_tokens": fields.usage?.cacheCreationInputTokens,
+    "gen_ai.usage.reasoning.output_tokens": fields.usage?.reasoningOutputTokens,
+    "gen_ai.usage.cost": fields.costUsd,
+    "gen_ai.response.finish_reasons": fields.finishReason ? [fields.finishReason] : undefined,
+    "gen_ai.output.type": fields.outputType,
+    "gen_ai.request.temperature": fields.temperature,
+    "gen_ai.request.top_p": fields.topP,
+    "gen_ai.request.top_k": fields.topK,
+    "gen_ai.request.max_tokens": fields.maxTokens,
+    "gen_ai.request.stop_sequences": fields.stopSequences,
+    "gen_ai.request.seed": fields.seed,
+    "gen_ai.request.frequency_penalty": fields.frequencyPenalty,
+    "gen_ai.request.presence_penalty": fields.presencePenalty,
+    // The key carries no "ms" unit suffix, so the ingest reads the value as seconds.
+    "gen_ai.response.time_to_first_chunk":
+      fields.timeToFirstChunkMs !== undefined ? fields.timeToFirstChunkMs / 1000 : undefined,
+    "gen_ai.tool.name": fields.toolName,
+    "gen_ai.tool.call.id": fields.toolCallId,
+    "gen_ai.tool.description": fields.toolDescription,
+    "gen_ai.agent.name": fields.agentName,
+    "gen_ai.agent.id": fields.agentId,
+  });
+
+  if (fields.systemInstructions !== undefined && cfg.captureInput) {
+    const value = prepareCaptureValue("gen_ai.system_instructions", fields.systemInstructions, cfg);
+    if (value !== undefined) attrs["gen_ai.system_instructions"] = value;
+  }
+  if (fields.input !== undefined && cfg.captureInput) {
+    const key = inputKeyFor(type);
+    const value = prepareCaptureValue(key, fields.input, cfg);
+    if (value !== undefined) attrs[key] = value;
+  }
+  if (fields.output !== undefined && cfg.captureOutput) {
+    const key = outputKeyFor(type);
+    const value = prepareCaptureValue(key, fields.output, cfg);
+    if (value !== undefined) attrs[key] = value;
+  }
+  if (fields.metadata) {
+    for (const [key, value] of Object.entries(fields.metadata)) {
+      if (RESERVED_METADATA_KEYS.has(key)) {
+        diag.debug(`metadata key "${key}" is reserved; pass it via propagateAttributes instead`);
+        continue;
+      }
+      const attr = typeof value === "string" ? value : jsonAttr(value);
+      if (attr !== undefined) {
+        attrs[`td.metadata.${key}`] = truncate(attr, cfg.maxAttributeLength);
+      }
+    }
+  }
+  if (fields.attributes) {
+    Object.assign(attrs, omitUndefined(fields.attributes));
+  }
+  return attrs;
+}

package/src/capture.ts

@@ -0,0 +1,39 @@
+import { jsonAttr, reportError } from "@telemetry-dev/otel";
+
+import type { MaskFn } from "./config.ts";
+
+// Byte-identical with the Python SDK so truncated payloads are self-describing across languages.
+export const TRUNCATION_MARKER = "...[truncated]";
+
+export interface CaptureConfig {
+  mask?: MaskFn;
+  maxAttributeLength: number;
+  onError?: (error: unknown) => void;
+}
+
+export function truncate(value: string, maxLength: number): string {
+  if (value.length <= maxLength) return value;
+  // Total stays within maxLength so the provider's attributeValueLengthLimit backstop
+  // (set to the same cap) never slices the marker off.
+  return value.slice(0, Math.max(maxLength - TRUNCATION_MARKER.length, 0)) + TRUNCATION_MARKER;
+}
+
+/** The single content funnel: mask → JSON stringify → truncate. */
+export function prepareCaptureValue(
+  key: string,
+  value: unknown,
+  cfg: CaptureConfig,
+): string | undefined {
+  let masked = value;
+  if (cfg.mask) {
+    try {
+      masked = cfg.mask(value, { key });
+    } catch (error) {
+      reportError(cfg.onError, error);
+      return undefined;
+    }
+  }
+  const serialized = jsonAttr(masked);
+  if (serialized === undefined) return undefined;
+  return truncate(serialized, cfg.maxAttributeLength);
+}

package/src/client.ts

@@ -0,0 +1,240 @@
+import { context as apiContext, propagation, trace, type Tracer } from "@opentelemetry/api";
+import type { Logger } from "@opentelemetry/api-logs";
+import { W3CTraceContextPropagator } from "@opentelemetry/core";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import {
+  BatchLogRecordProcessor,
+  LoggerProvider,
+  type LogRecordExporter,
+  SimpleLogRecordProcessor,
+} from "@opentelemetry/sdk-logs";
+import type { PushMetricExporter } from "@opentelemetry/sdk-metrics";
+import {
+  BasicTracerProvider,
+  type ReadableSpan,
+  type SpanExporter,
+} from "@opentelemetry/sdk-trace-base";
+
+import {
+  als,
+  AlsContextManager,
+  BATCHED_METRIC_INTERVAL_MS,
+  createLogExporter,
+  createMetricExporter,
+  createMetricsPipeline,
+  createTraceExporter,
+  diag,
+  DORMANT_INTERVAL_MS,
+  otlpHeaders,
+  reportError,
+  SCOPE_NAME,
+  SCOPE_VERSION,
+  setLogLevel,
+  StampingSpanProcessor,
+  type Transport,
+} from "@telemetry-dev/otel";
+
+import { type ResolvedConfig, resolveConfig, type TelemetryOptions } from "./config.ts";
+
+/** Test seam: inject in-memory exporters instead of the OTLP fetch transport. */
+export interface ClientOverrides {
+  spanExporter?: SpanExporter;
+  logRecordExporter?: LogRecordExporter;
+  metricExporter?: PushMetricExporter;
+}
+
+export interface TelemetryClient {
+  readonly enabled: boolean;
+  /** Never rejects; hands the export off to waitUntil when configured. */
+  flush(): Promise<void>;
+  /** Flush + teardown + unregister globals; the client becomes a no-op afterwards. */
+  shutdown(): Promise<void>;
+}
+
+export interface ClientCore {
+  config: ResolvedConfig;
+  tracer: Tracer;
+  ensureLogger(): Logger | undefined;
+}
+
+export interface ClientHandle extends TelemetryClient {
+  core?: ClientCore;
+}
+
+const NOOP_CLIENT: ClientHandle = {
+  enabled: false,
+  flush: () => Promise.resolve(),
+  shutdown: () => Promise.resolve(),
+};
+
+let activeClient: ClientHandle | undefined;
+
+export function currentClient(): ClientHandle {
+  return activeClient ?? NOOP_CLIENT;
+}
+
+export function flush(): Promise<void> {
+  return currentClient().flush();
+}
+
+export function shutdown(): Promise<void> {
+  return currentClient().shutdown();
+}
+
+export function init(options?: TelemetryOptions, overrides?: ClientOverrides): TelemetryClient {
+  try {
+    return initInner(options, overrides);
+  } catch (error) {
+    reportError(options?.onError, error);
+    activeClient = NOOP_CLIENT;
+    return NOOP_CLIENT;
+  }
+}
+
+function initInner(options?: TelemetryOptions, overrides?: ClientOverrides): TelemetryClient {
+  const config = resolveConfig(options);
+  setLogLevel(config.logLevel);
+
+  if (activeClient && activeClient !== NOOP_CLIENT) {
+    diag.warn("init() called again; replacing the previous client");
+    // shutdown() synchronously releases global registrations before this init claims them.
+    void activeClient.shutdown().catch((error: unknown) => reportError(config.onError, error));
+  }
+
+  const enabled = config.enabled && Boolean(config.apiKey ?? overrides?.spanExporter);
+  if (!enabled) {
+    if (config.enabled && !config.apiKey) {
+      diag.debug("no api key (apiKey option or TELEMETRY_DEV_API_KEY); telemetry disabled");
+    }
+    activeClient = NOOP_CLIENT;
+    return NOOP_CLIENT;
+  }
+
+  const resource = resourceFromAttributes({
+    "service.name": config.serviceName,
+    "deployment.environment.name": config.environment,
+    ...config.resourceAttributes,
+  });
+  const transport: Transport = { fetchImpl: config.fetchImpl, onError: config.onError };
+  const headers = config.apiKey ? otlpHeaders(config.apiKey) : undefined;
+
+  const spanExporter =
+    overrides?.spanExporter ??
+    createTraceExporter({ url: `${config.baseUrl}/v1/traces`, headers: headers! }, transport);
+
+  const metricExporter =
+    overrides?.metricExporter ??
+    (headers
+      ? createMetricExporter({ url: `${config.baseUrl}/v1/metrics`, headers }, transport)
+      : undefined);
+  const metrics = metricExporter
+    ? createMetricsPipeline({
+        resource,
+        exporter: metricExporter,
+        exportIntervalMillis:
+          config.exportMode === "batched" ? BATCHED_METRIC_INTERVAL_MS : DORMANT_INTERVAL_MS,
+      })
+    : undefined;
+
+  const spanFilter =
+    config.spanFilter ??
+    (config.registerGlobal
+      ? (span: ReadableSpan) => span.instrumentationScope.name === SCOPE_NAME
+      : undefined);
+
+  const processor = new StampingSpanProcessor({
+    exporter: spanExporter,
+    exportMode: config.exportMode,
+    batch: config.batch,
+    spanFilter,
+    recordMetrics: metrics ? (span) => metrics.record(span) : undefined,
+    onError: config.onError,
+  });
+
+  const provider = new BasicTracerProvider({
+    resource,
+    spanProcessors: [processor],
+    spanLimits: { attributeValueLengthLimit: config.maxAttributeLength },
+  });
+  const tracer = provider.getTracer(SCOPE_NAME, SCOPE_VERSION);
+
+  let registeredTrace = false;
+  let registeredContext = false;
+  let registeredPropagation = false;
+  if (config.registerGlobal) {
+    registeredTrace = trace.setGlobalTracerProvider(provider);
+    if (als) {
+      registeredContext = apiContext.setGlobalContextManager(new AlsContextManager(als));
+    }
+    registeredPropagation = propagation.setGlobalPropagator(new W3CTraceContextPropagator());
+    if (!registeredTrace) {
+      diag.warn(
+        "a global TracerProvider is already registered; attach the TelemetrySpanProcessor from '@telemetry-dev/otel' to your own provider instead",
+      );
+    }
+  }
+
+  const logExporter =
+    overrides?.logRecordExporter ??
+    (headers
+      ? createLogExporter({ url: `${config.baseUrl}/v1/logs`, headers }, transport)
+      : undefined);
+  // Lazy: the log pipeline only exists once log() is first called.
+  let logs: { logger: Logger; forceFlush(): Promise<void>; shutdown(): Promise<void> } | undefined;
+  const ensureLogger = (): Logger | undefined => {
+    if (!logExporter) return undefined;
+    if (!logs) {
+      const logProcessor =
+        config.exportMode === "immediate"
+          ? new SimpleLogRecordProcessor(logExporter)
+          : new BatchLogRecordProcessor(logExporter);
+      const loggerProvider = new LoggerProvider({
+        resource,
+        logRecordLimits: { attributeValueLengthLimit: config.maxAttributeLength },
+        processors: [logProcessor],
+      });
+      logs = {
+        logger: loggerProvider.getLogger(SCOPE_NAME, SCOPE_VERSION),
+        forceFlush: () => loggerProvider.forceFlush(),
+        shutdown: () => loggerProvider.shutdown(),
+      };
+    }
+    return logs.logger;
+  };
+
+  let torn = false;
+  const collect = (op: "forceFlush" | "shutdown"): Promise<void> => {
+    const parts: Promise<unknown>[] = [provider[op]()];
+    if (logs) parts.push(logs[op]());
+    if (metrics) parts.push(metrics[op]());
+    return Promise.all(parts)
+      .then(() => undefined)
+      .catch((error: unknown) => reportError(config.onError, error));
+  };
+  const handoff = (p: Promise<void>): Promise<void> => {
+    if (config.waitUntil) {
+      config.waitUntil(p);
+      return Promise.resolve();
+    }
+    return p;
+  };
+
+  const handle: ClientHandle = {
+    get enabled() {
+      return !torn;
+    },
+    flush: () => (torn ? Promise.resolve() : handoff(collect("forceFlush"))),
+    shutdown: () => {
+      if (torn) return Promise.resolve();
+      torn = true;
+      if (registeredTrace) trace.disable();
+      if (registeredContext) apiContext.disable();
+      if (registeredPropagation) propagation.disable();
+      handle.core = undefined;
+      return handoff(collect("shutdown"));
+    },
+  };
+  handle.core = { config, tracer, ensureLogger };
+  activeClient = handle;
+  return handle;
+}

package/src/config.ts

@@ -0,0 +1,104 @@
+import type { AttributeValue } from "@opentelemetry/api";
+import type { ReadableSpan } from "@opentelemetry/sdk-trace-base";
+import {
+  type BatchOptions,
+  DEFAULT_BASE_URL,
+  DEFAULT_BATCH,
+  type ExportMode,
+  resolveEnv,
+  type SdkLogLevel,
+} from "@telemetry-dev/otel";
+
+export type { BatchOptions, ExportMode, LogLevel, SdkLogLevel } from "@telemetry-dev/otel";
+
+/** Redaction hook applied to captured content (input/output/log message) before JSON stringification. */
+export type MaskFn = (value: unknown, ctx: { key: string }) => unknown;
+
+export interface TelemetryOptions {
+  /** telemetry.dev ingest key (`td_live_…`). Falls back to `TELEMETRY_DEV_API_KEY`. When absent the SDK is a no-op. */
+  apiKey?: string;
+  /** Ingest base URL. Falls back to `TELEMETRY_DEV_BASE_URL`, then `https://ingest.telemetry.dev`. */
+  baseUrl?: string;
+  /** Deployment environment label. Falls back to `TELEMETRY_DEV_ENVIRONMENT`, then `production`. */
+  environment?: string;
+  /** Service name attached to every trace. Falls back to `OTEL_SERVICE_NAME`, then `unknown_service`. */
+  serviceName?: string;
+  /** Kill switch: `false` makes the SDK a complete no-op (tests). Default true. */
+  enabled?: boolean;
+  /** Register this SDK's TracerProvider/context manager/propagator globally. Default false (isolated). */
+  registerGlobal?: boolean;
+  /** "batched" (default) buffers spans; "immediate" exports per span (serverless). */
+  exportMode?: ExportMode;
+  /** Capture span inputs (args, prompts) by default. Default true. */
+  captureInput?: boolean;
+  /** Capture span outputs (results, completions) by default. Default true. */
+  captureOutput?: boolean;
+  /** Redaction hook run on captured content before stringify/truncate. */
+  mask?: MaskFn;
+  /** Truncation cap (chars) for content attributes; also set as the provider's attributeValueLengthLimit. Default 65536. */
+  maxAttributeLength?: number;
+  batch?: BatchOptions;
+  /** Export filter. Default when registerGlobal: only spans from this SDK's instrumentation scope. */
+  spanFilter?: (span: ReadableSpan) => boolean;
+  /** Extra resource attributes merged onto service.name / deployment.environment.name. */
+  resourceAttributes?: Record<string, AttributeValue>;
+  /** SDK self-diagnostics console level. Default "warn"; "silent" disables. */
+  logLevel?: SdkLogLevel;
+  /** Injected fetch implementation. Defaults to `globalThis.fetch`. */
+  fetch?: typeof fetch;
+  /** Serverless extender (e.g. Cloudflare `ctx.waitUntil`). When provided, `flush()` does not await exports. */
+  waitUntil?: (p: Promise<unknown>) => void;
+  /** Receives any error raised while emitting telemetry; the SDK never throws into user code. */
+  onError?: (error: unknown) => void;
+}
+
+export interface ResolvedConfig {
+  apiKey: string | undefined;
+  baseUrl: string;
+  environment: string;
+  serviceName: string;
+  enabled: boolean;
+  registerGlobal: boolean;
+  exportMode: ExportMode;
+  captureInput: boolean;
+  captureOutput: boolean;
+  mask?: MaskFn;
+  maxAttributeLength: number;
+  batch: Required<BatchOptions>;
+  spanFilter?: (span: ReadableSpan) => boolean;
+  resourceAttributes?: Record<string, AttributeValue>;
+  logLevel: SdkLogLevel;
+  fetchImpl: typeof fetch;
+  waitUntil?: (p: Promise<unknown>) => void;
+  onError?: (error: unknown) => void;
+}
+
+export const DEFAULT_MAX_ATTRIBUTE_LENGTH = 65536;
+
+export function resolveConfig(options: TelemetryOptions = {}): ResolvedConfig {
+  const env = resolveEnv();
+  const baseUrl = (options.baseUrl ?? env.TELEMETRY_DEV_BASE_URL ?? DEFAULT_BASE_URL).replace(
+    /\/+$/,
+    "",
+  );
+  return {
+    apiKey: options.apiKey ?? env.TELEMETRY_DEV_API_KEY,
+    baseUrl,
+    environment: options.environment ?? env.TELEMETRY_DEV_ENVIRONMENT ?? "production",
+    serviceName: options.serviceName ?? env.OTEL_SERVICE_NAME ?? "unknown_service",
+    enabled: options.enabled ?? true,
+    registerGlobal: options.registerGlobal ?? false,
+    exportMode: options.exportMode ?? "batched",
+    captureInput: options.captureInput ?? true,
+    captureOutput: options.captureOutput ?? true,
+    mask: options.mask,
+    maxAttributeLength: options.maxAttributeLength ?? DEFAULT_MAX_ATTRIBUTE_LENGTH,
+    batch: { ...DEFAULT_BATCH, ...options.batch },
+    spanFilter: options.spanFilter,
+    resourceAttributes: options.resourceAttributes,
+    logLevel: options.logLevel ?? "warn",
+    fetchImpl: options.fetch ?? globalThis.fetch,
+    waitUntil: options.waitUntil,
+    onError: options.onError,
+  };
+}

package/src/index.ts

@@ -0,0 +1,29 @@
+export type {
+  AgentFields,
+  GenerationFields,
+  SpanFields,
+  SpanType,
+  TokenUsage,
+  ToolFields,
+} from "./attrs.ts";
+export { type ClientOverrides, flush, init, shutdown, type TelemetryClient } from "./client.ts";
+export type {
+  BatchOptions,
+  ExportMode,
+  LogLevel,
+  MaskFn,
+  SdkLogLevel,
+  TelemetryOptions,
+} from "./config.ts";
+export { propagateAttributes, type PropagatedAttributes } from "@telemetry-dev/otel";
+export { log, type LogOptions } from "./logs.ts";
+export { observe, type ObserveOptions } from "./observe.ts";
+export {
+  getTraceparent,
+  type ParentRef,
+  type SpanHandle,
+  startActiveSpan,
+  startSpan,
+  type StartSpanOptions,
+  updateActiveSpan,
+} from "./span.ts";

package/src/logs.ts

@@ -0,0 +1,77 @@
+import type { AttributeValue } from "@opentelemetry/api";
+import { SeverityNumber } from "@opentelemetry/api-logs";
+
+import { activeContext, propagatedFromContext, reportError } from "@telemetry-dev/otel";
+
+import { prepareCaptureValue, truncate } from "./capture.ts";
+import { currentClient } from "./client.ts";
+import type { LogLevel } from "./config.ts";
+
+// Severity numbers match the ingest's severityFromNumber buckets exactly.
+const SEVERITIES: Record<LogLevel, { number: SeverityNumber; text: string }> = {
+  debug: { number: SeverityNumber.DEBUG, text: "DEBUG" },
+  info: { number: SeverityNumber.INFO, text: "INFO" },
+  warn: { number: SeverityNumber.WARN, text: "WARN" },
+  error: { number: SeverityNumber.ERROR, text: "ERROR" },
+};
+
+export interface LogOptions {
+  /** Default "info". */
+  level?: LogLevel;
+  attributes?: Record<string, unknown>;
+  eventName?: string;
+  timestamp?: Date | number;
+}
+
+/**
+ * Emit a log record to /v1/logs, correlated to the active span (when any) and stamped with the
+ * propagated correlation attributes. Works inside and outside spans.
+ */
+export function log(message: string, options?: LogOptions): void {
+  const core = currentClient().core;
+  if (!core) return;
+  try {
+    const logger = core.ensureLogger();
+    if (!logger) return;
+    const cfg = core.config;
+    const captureCfg = {
+      mask: cfg.mask,
+      maxAttributeLength: cfg.maxAttributeLength,
+      onError: cfg.onError,
+    };
+    const severity = SEVERITIES[options?.level ?? "info"];
+    const ctx = activeContext();
+
+    const attributes: Record<string, AttributeValue> = {};
+    for (const [key, value] of Object.entries(options?.attributes ?? {})) {
+      if (value === undefined) continue;
+      if (typeof value === "number" || typeof value === "boolean") {
+        attributes[key] = value;
+        continue;
+      }
+      const prepared = prepareCaptureValue(key, value, captureCfg);
+      if (prepared !== undefined) attributes[key] = prepared;
+    }
+    const propagated = propagatedFromContext(ctx);
+    if (propagated) {
+      for (const [key, value] of Object.entries(propagated)) {
+        if (value !== undefined) {
+          attributes[key] =
+            typeof value === "string" ? truncate(value, cfg.maxAttributeLength) : value;
+        }
+      }
+    }
+
+    logger.emit({
+      body: prepareCaptureValue("log.message", message, captureCfg) ?? "",
+      severityNumber: severity.number,
+      severityText: severity.text,
+      eventName: options?.eventName,
+      timestamp: options?.timestamp,
+      context: ctx,
+      attributes,
+    });
+  } catch (error) {
+    reportError(core.config.onError, error);
+  }
+}

package/src/noop.ts

@@ -0,0 +1,17 @@
+import { INVALID_SPAN_CONTEXT, ROOT_CONTEXT, trace } from "@opentelemetry/api";
+
+import type { SpanHandle } from "./span.ts";
+
+const noopSpan = trace.wrapSpanContext(INVALID_SPAN_CONTEXT);
+
+/** Shared inert handle returned by span primitives before init() or when disabled. */
+export const NOOP_SPAN_HANDLE: SpanHandle = {
+  span: noopSpan,
+  context: trace.setSpan(ROOT_CONTEXT, noopSpan),
+  traceId: INVALID_SPAN_CONTEXT.traceId,
+  spanId: INVALID_SPAN_CONTEXT.spanId,
+  traceparent: null,
+  isRecording: false,
+  update: () => NOOP_SPAN_HANDLE,
+  end: () => {},
+};