@babelqueue/core 1.1.0 → 1.2.0

package/dist/otel.cjs

@@ -0,0 +1,245 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/otel.ts
+var otel_exports = {};
+__export(otel_exports, {
+  publish: () => publish,
+  traceIdOf: () => traceIdOf,
+  uuidOf: () => uuidOf,
+  wrapHandler: () => wrapHandler
+});
+module.exports = __toCommonJS(otel_exports);
+var import_node_crypto2 = require("crypto");
+var import_api = require("@opentelemetry/api");
+
+// src/codec.ts
+var import_node_crypto = require("crypto");
+
+// src/errors.ts
+var BabelQueueError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BabelQueueError";
+  }
+};
+
+// src/codec.ts
+var SCHEMA_VERSION = 1;
+var SOURCE_LANG = "node";
+var EnvelopeCodec = {
+  SCHEMA_VERSION,
+  SOURCE_LANG,
+  /**
+   * Build the canonical envelope for a `(urn, data)` pair. Mints a fresh trace id
+   * unless `options.traceId` is given, starts `attempts` at 0, and stamps `meta`.
+   * Throws {@link BabelQueueError} when the URN is blank.
+   */
+  make(urn, data, options = {}) {
+    const resolvedUrn = (urn ?? "").trim();
+    if (resolvedUrn === "") {
+      throw new BabelQueueError(
+        "A polyglot message must expose a stable, non-empty URN so consumers can identify it without any class name."
+      );
+    }
+    const traceId = (options.traceId ?? "").trim() || (0, import_node_crypto.randomUUID)();
+    return {
+      job: resolvedUrn,
+      trace_id: traceId,
+      data: { ...data },
+      meta: {
+        id: (0, import_node_crypto.randomUUID)(),
+        queue: options.queue ?? "default",
+        lang: SOURCE_LANG,
+        schema_version: SCHEMA_VERSION,
+        created_at: Date.now()
+      },
+      attempts: 0
+    };
+  },
+  /**
+   * Build the envelope from a {@link PolyglotMessage}. If the message also
+   * implements {@link HasTraceId} and returns a non-empty value, that trace id is
+   * reused.
+   */
+  fromMessage(message, queue = "default") {
+    const traceId = typeof message.getBabelTraceId === "function" ? message.getBabelTraceId() ?? void 0 : void 0;
+    return EnvelopeCodec.make(message.getBabelUrn(), message.toPayload(), {
+      queue,
+      traceId
+    });
+  },
+  /**
+   * Encode the envelope as compact UTF-8 JSON. `JSON.stringify` already emits the
+   * canonical form — no spaces, and slashes/unicode/HTML left unescaped — matching
+   * the other SDK cores.
+   */
+  encode(envelope) {
+    return JSON.stringify(envelope);
+  },
+  /**
+   * Parse a raw JSON body. Returns `{}` for malformed or non-object input (call
+   * {@link EnvelopeCodec.accepts} before trusting it). Resolves the `urn` inbound
+   * alias into `job`.
+   */
+  decode(raw) {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return {};
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {};
+    }
+    const envelope = parsed;
+    if (!envelope.job && typeof envelope.urn === "string") {
+      envelope.job = envelope.urn;
+    }
+    return envelope;
+  },
+  /** The message URN — canonical `job`, with `urn` accepted as an alias. */
+  urn(envelope) {
+    const value = envelope?.job ?? envelope?.urn ?? "";
+    return typeof value === "string" ? value.trim() : "";
+  },
+  /**
+   * Whether a consumer should accept this envelope. Rejects a missing URN, an
+   * unsupported `meta.schema_version`, a non-object `data`, a non-integer
+   * `attempts`, or a blank `trace_id` — the consumer-side counterpart to the
+   * producer JSON Schema. Acts as a type guard that narrows to {@link Envelope}.
+   */
+  accepts(envelope) {
+    if (EnvelopeCodec.urn(envelope) === "") {
+      return false;
+    }
+    const meta = envelope.meta;
+    if (meta === null || typeof meta !== "object" || meta.schema_version !== SCHEMA_VERSION) {
+      return false;
+    }
+    const data = envelope.data;
+    if (data === null || typeof data !== "object" || Array.isArray(data)) {
+      return false;
+    }
+    const attempts = envelope.attempts;
+    if (typeof attempts !== "number" || !Number.isInteger(attempts)) {
+      return false;
+    }
+    const traceId = envelope.trace_id;
+    if (typeof traceId !== "string" || traceId.trim() === "") {
+      return false;
+    }
+    return true;
+  }
+};
+
+// src/otel.ts
+var SYSTEM = "babelqueue";
+var INVALID_TRACE_ID = "00000000000000000000000000000000";
+var INVALID_SPAN_ID = "0000000000000000";
+function traceIdOf(traceId) {
+  const hex = traceId.replace(/-/g, "").toLowerCase();
+  if (/^[0-9a-f]{32}$/.test(hex) && hex !== INVALID_TRACE_ID) {
+    return hex;
+  }
+  return (0, import_node_crypto2.createHash)("sha256").update(traceId).digest("hex").slice(0, 32);
+}
+function uuidOf(traceIdHex) {
+  const h = traceIdHex.replace(/-/g, "").toLowerCase().padStart(32, "0").slice(0, 32);
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;
+}
+function spanIdOf(traceId) {
+  const sid = (0, import_node_crypto2.createHash)("sha256").update(`babelqueue-span:${traceId}`).digest("hex").slice(0, 16);
+  return sid === INVALID_SPAN_ID ? "0000000000000001" : sid;
+}
+function parentContext(traceId) {
+  return import_api.trace.setSpanContext(import_api.context.active(), {
+    traceId: traceIdOf(traceId),
+    spanId: spanIdOf(traceId),
+    traceFlags: import_api.TraceFlags.SAMPLED,
+    isRemote: true
+  });
+}
+function consumeAttributes(env) {
+  return {
+    "messaging.system": SYSTEM,
+    "messaging.operation": "process",
+    "messaging.destination.name": env.meta?.queue ?? "",
+    "messaging.message.id": env.meta?.id ?? "",
+    "messaging.message.conversation_id": env.trace_id,
+    "messaging.babelqueue.attempts": env.attempts ?? 0
+  };
+}
+function wrapHandler(tracer, handler) {
+  return (env) => {
+    const ctx = parentContext(env.trace_id);
+    return tracer.startActiveSpan(
+      `process ${env.job ?? ""}`,
+      { kind: import_api.SpanKind.CONSUMER, attributes: consumeAttributes(env) },
+      ctx,
+      async (span) => {
+        try {
+          await handler(env);
+        } catch (err) {
+          span.recordException(err);
+          span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: err.message });
+          throw err;
+        } finally {
+          span.end();
+        }
+      }
+    );
+  };
+}
+function publish(tracer, urn, data, send, options = {}) {
+  return tracer.startActiveSpan(
+    `publish ${urn}`,
+    {
+      kind: import_api.SpanKind.PRODUCER,
+      attributes: {
+        "messaging.system": SYSTEM,
+        "messaging.operation": "publish",
+        "messaging.destination.name": urn
+      }
+    },
+    async (span) => {
+      try {
+        const traceId = uuidOf(span.spanContext().traceId);
+        const envelope = EnvelopeCodec.make(urn, data, { ...options, traceId });
+        const result = await send(envelope);
+        span.setAttribute("messaging.message.id", envelope.meta.id);
+        return result;
+      } catch (err) {
+        span.recordException(err);
+        span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: err.message });
+        throw err;
+      } finally {
+        span.end();
+      }
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  publish,
+  traceIdOf,
+  uuidOf,
+  wrapHandler
+});
+//# sourceMappingURL=otel.cjs.map

package/dist/otel.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/otel.ts","../src/codec.ts","../src/errors.ts"],"sourcesContent":["/**\n * Optional OpenTelemetry tracing (ADR-0025) — the Node mirror of `babelqueue-go/otel`.\n *\n * Emits a CONSUMER span per handled message and a PRODUCER span per publish, correlating them\n * across every hop and SDK through the envelope's `trace_id` — a UUID, which maps 1:1 to a\n * 32-hex OTel trace id. The wire envelope is untouched (GR-1) and the zero-dependency core\n * never imports OpenTelemetry: this module pulls `@opentelemetry/api` as an **optional peer\n * dependency** and is reached only via the `@babelqueue/core/otel` subpath, so importing the\n * core itself stays dependency-free.\n *\n * ```ts\n * import { trace } from \"@opentelemetry/api\";\n * import { wrapHandler, publish } from \"@babelqueue/core/otel\";\n *\n * const tracer = trace.getTracer(\"orders\");\n * const traced = wrapHandler(tracer, async (env) => { ... });        // consumer\n * await publish(tracer, \"urn:babel:orders:created\", { order_id: 1 }, // producer\n *   (env) => myTransport.send(env));\n * ```\n *\n * Every hop that shares a `trace_id` shares one OTel trace. Exact cross-hop *span* parent-child\n * linkage (W3C `traceparent` as a transport header) is a documented follow-up.\n */\n\nimport { createHash } from \"node:crypto\";\n\nimport {\n  SpanKind,\n  SpanStatusCode,\n  TraceFlags,\n  context as otelContext,\n  trace,\n  type Attributes,\n  type Context,\n  type Tracer,\n} from \"@opentelemetry/api\";\n\nimport { EnvelopeCodec, type Envelope, type MakeOptions } from \"./codec.js\";\nimport type { Handler } from \"./idempotency.js\";\n\nconst SYSTEM = \"babelqueue\";\nconst INVALID_TRACE_ID = \"00000000000000000000000000000000\";\nconst INVALID_SPAN_ID = \"0000000000000000\";\n\n/**\n * Map an envelope `trace_id` to a deterministic 32-hex OTel trace id: a UUID maps to its\n * hex bytes; any other string is hashed (SHA-256, first 16 bytes). The inverse of {@link uuidOf}\n * for the UUID case.\n */\nexport function traceIdOf(traceId: string): string {\n  const hex = traceId.replace(/-/g, \"\").toLowerCase();\n  if (/^[0-9a-f]{32}$/.test(hex) && hex !== INVALID_TRACE_ID) {\n    return hex;\n  }\n  return createHash(\"sha256\").update(traceId).digest(\"hex\").slice(0, 32);\n}\n\n/**\n * Format a 32-hex OTel trace id as a canonical UUID string — the form a producer stamps into\n * the message's `trace_id` so a consumer can recover the same trace id via {@link traceIdOf}.\n */\nexport function uuidOf(traceIdHex: string): string {\n  const h = traceIdHex.replace(/-/g, \"\").toLowerCase().padStart(32, \"0\").slice(0, 32);\n  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;\n}\n\n/** Deterministic, non-zero 16-hex span id so the remote parent context is valid. */\nfunction spanIdOf(traceId: string): string {\n  const sid = createHash(\"sha256\").update(`babelqueue-span:${traceId}`).digest(\"hex\").slice(0, 16);\n  return sid === INVALID_SPAN_ID ? \"0000000000000001\" : sid;\n}\n\n/** A context carrying a remote parent in the `trace_id`-derived trace. */\nfunction parentContext(traceId: string): Context {\n  return trace.setSpanContext(otelContext.active(), {\n    traceId: traceIdOf(traceId),\n    spanId: spanIdOf(traceId),\n    traceFlags: TraceFlags.SAMPLED,\n    isRemote: true,\n  });\n}\n\nfunction consumeAttributes(env: Envelope): Attributes {\n  return {\n    \"messaging.system\": SYSTEM,\n    \"messaging.operation\": \"process\",\n    \"messaging.destination.name\": env.meta?.queue ?? \"\",\n    \"messaging.message.id\": env.meta?.id ?? \"\",\n    \"messaging.message.conversation_id\": env.trace_id,\n    \"messaging.babelqueue.attempts\": env.attempts ?? 0,\n  };\n}\n\n/**\n * Wrap a consume handler to emit a CONSUMER span per message, in the OTel trace derived from\n * the envelope's `trace_id`, recording the handler's error/status. The handler receives the\n * full {@link Envelope} as before.\n */\nexport function wrapHandler(\n  tracer: Tracer,\n  handler: Handler,\n): (env: Envelope) => Promise<void> {\n  return (env: Envelope): Promise<void> => {\n    const ctx = parentContext(env.trace_id);\n    return tracer.startActiveSpan(\n      `process ${env.job ?? \"\"}`,\n      { kind: SpanKind.CONSUMER, attributes: consumeAttributes(env) },\n      ctx,\n      async (span) => {\n        try {\n          await handler(env);\n        } catch (err) {\n          span.recordException(err as Error);\n          span.setStatus({ code: SpanStatusCode.ERROR, message: (err as Error).message });\n          throw err;\n        } finally {\n          span.end();\n        }\n      },\n    );\n  };\n}\n\n/**\n * Run a publish under a PRODUCER span `publish <urn>`, carrying the active trace's id into the\n * built envelope's `trace_id` so the downstream consumer recovers the same trace. `send`\n * performs the real transport write and its result is returned.\n */\nexport function publish<R>(\n  tracer: Tracer,\n  urn: string,\n  data: Record<string, unknown>,\n  send: (envelope: Envelope) => R | Promise<R>,\n  options: MakeOptions = {},\n): Promise<R> {\n  return tracer.startActiveSpan(\n    `publish ${urn}`,\n    {\n      kind: SpanKind.PRODUCER,\n      attributes: {\n        \"messaging.system\": SYSTEM,\n        \"messaging.operation\": \"publish\",\n        \"messaging.destination.name\": urn,\n      },\n    },\n    async (span) => {\n      try {\n        const traceId = uuidOf(span.spanContext().traceId);\n        const envelope = EnvelopeCodec.make(urn, data, { ...options, traceId });\n        const result = await send(envelope);\n        span.setAttribute(\"messaging.message.id\", envelope.meta.id);\n        return result;\n      } catch (err) {\n        span.recordException(err as Error);\n        span.setStatus({ code: SpanStatusCode.ERROR, message: (err as Error).message });\n        throw err;\n      } finally {\n        span.end();\n      }\n    },\n  );\n}\n","import { randomUUID } from \"node:crypto\";\n\nimport type { HasTraceId, PolyglotMessage } from \"./contracts.js\";\nimport { BabelQueueError } from \"./errors.js\";\n\n/** The wire envelope schema version this core implements (versioned independently of the package version). */\nexport const SCHEMA_VERSION = 1;\n\n/** Stamped into `meta.lang` for envelopes produced by this core. */\nexport const SOURCE_LANG = \"node\";\n\n/** Immutable per-message metadata. */\nexport interface Meta {\n  id: string;\n  queue: string;\n  lang: string;\n  schema_version: number;\n  /** Unix milliseconds, UTC. */\n  created_at: number;\n}\n\n/** The additive block appended to an envelope when a message is dead-lettered. */\nexport interface DeadLetter {\n  reason: string;\n  error: string | null;\n  exception: string | null;\n  /** Unix milliseconds, UTC. */\n  failed_at: number;\n  original_queue: string;\n  attempts: number;\n  lang: string;\n}\n\n/**\n * The canonical BabelQueue wire message: a strict, language-neutral JSON shape\n * that every SDK produces and consumes identically. The property order here is\n * significant — it matches the other cores so {@link EnvelopeCodec.encode} is\n * byte-for-byte identical across the insertion-order languages (PHP/Python).\n */\nexport interface Envelope {\n  /** The message URN (never a class name). */\n  job: string;\n  /** Correlation id, preserved across every hop. */\n  trace_id: string;\n  /** The pure-JSON payload. */\n  data: Record<string, unknown>;\n  meta: Meta;\n  /** Top-level transport retry counter. */\n  attempts: number;\n  /** Present only once the message has been dead-lettered. */\n  dead_letter?: DeadLetter;\n}\n\n/**\n * A decoded, not-yet-validated envelope. Fields are loosely typed because they\n * come off the wire; `urn` is accepted as an inbound alias for `job`. Narrow it\n * with {@link EnvelopeCodec.accepts} before trusting the contents.\n */\nexport interface IncomingEnvelope {\n  job?: string;\n  /** Inbound alias for `job`. */\n  urn?: string;\n  trace_id?: string;\n  data?: unknown;\n  meta?: unknown;\n  attempts?: unknown;\n  dead_letter?: unknown;\n}\n\n/** Options for {@link EnvelopeCodec.make}. */\nexport interface MakeOptions {\n  /** Logical queue name recorded in `meta.queue` (default `\"default\"`). */\n  queue?: string;\n  /** Reuse an existing trace id (trace continuation) instead of minting one. */\n  traceId?: string;\n}\n\n/**\n * Builds, encodes and decodes the canonical envelope — the single Node/TypeScript\n * implementation of the wire format.\n */\nexport const EnvelopeCodec = {\n  SCHEMA_VERSION,\n  SOURCE_LANG,\n\n  /**\n   * Build the canonical envelope for a `(urn, data)` pair. Mints a fresh trace id\n   * unless `options.traceId` is given, starts `attempts` at 0, and stamps `meta`.\n   * Throws {@link BabelQueueError} when the URN is blank.\n   */\n  make(\n    urn: string,\n    data: Record<string, unknown>,\n    options: MakeOptions = {},\n  ): Envelope {\n    const resolvedUrn = (urn ?? \"\").trim();\n    if (resolvedUrn === \"\") {\n      throw new BabelQueueError(\n        \"A polyglot message must expose a stable, non-empty URN so consumers can identify it without any class name.\",\n      );\n    }\n\n    const traceId = (options.traceId ?? \"\").trim() || randomUUID();\n\n    return {\n      job: resolvedUrn,\n      trace_id: traceId,\n      data: { ...data },\n      meta: {\n        id: randomUUID(),\n        queue: options.queue ?? \"default\",\n        lang: SOURCE_LANG,\n        schema_version: SCHEMA_VERSION,\n        created_at: Date.now(),\n      },\n      attempts: 0,\n    };\n  },\n\n  /**\n   * Build the envelope from a {@link PolyglotMessage}. If the message also\n   * implements {@link HasTraceId} and returns a non-empty value, that trace id is\n   * reused.\n   */\n  fromMessage(\n    message: PolyglotMessage & Partial<HasTraceId>,\n    queue = \"default\",\n  ): Envelope {\n    const traceId =\n      typeof message.getBabelTraceId === \"function\"\n        ? (message.getBabelTraceId() ?? undefined)\n        : undefined;\n\n    return EnvelopeCodec.make(message.getBabelUrn(), message.toPayload(), {\n      queue,\n      traceId,\n    });\n  },\n\n  /**\n   * Encode the envelope as compact UTF-8 JSON. `JSON.stringify` already emits the\n   * canonical form — no spaces, and slashes/unicode/HTML left unescaped — matching\n   * the other SDK cores.\n   */\n  encode(envelope: Envelope): string {\n    return JSON.stringify(envelope);\n  },\n\n  /**\n   * Parse a raw JSON body. Returns `{}` for malformed or non-object input (call\n   * {@link EnvelopeCodec.accepts} before trusting it). Resolves the `urn` inbound\n   * alias into `job`.\n   */\n  decode(raw: string): IncomingEnvelope {\n    let parsed: unknown;\n    try {\n      parsed = JSON.parse(raw);\n    } catch {\n      return {};\n    }\n    if (parsed === null || typeof parsed !== \"object\" || Array.isArray(parsed)) {\n      return {};\n    }\n\n    const envelope = parsed as IncomingEnvelope;\n    if (!envelope.job && typeof envelope.urn === \"string\") {\n      envelope.job = envelope.urn;\n    }\n    return envelope;\n  },\n\n  /** The message URN — canonical `job`, with `urn` accepted as an alias. */\n  urn(envelope: IncomingEnvelope): string {\n    const value = envelope?.job ?? envelope?.urn ?? \"\";\n    return typeof value === \"string\" ? value.trim() : \"\";\n  },\n\n  /**\n   * Whether a consumer should accept this envelope. Rejects a missing URN, an\n   * unsupported `meta.schema_version`, a non-object `data`, a non-integer\n   * `attempts`, or a blank `trace_id` — the consumer-side counterpart to the\n   * producer JSON Schema. Acts as a type guard that narrows to {@link Envelope}.\n   */\n  accepts(envelope: IncomingEnvelope): envelope is Envelope {\n    if (EnvelopeCodec.urn(envelope) === \"\") {\n      return false;\n    }\n\n    const meta = envelope.meta;\n    if (\n      meta === null ||\n      typeof meta !== \"object\" ||\n      (meta as Meta).schema_version !== SCHEMA_VERSION\n    ) {\n      return false;\n    }\n\n    const data = envelope.data;\n    if (data === null || typeof data !== \"object\" || Array.isArray(data)) {\n      return false;\n    }\n\n    const attempts = envelope.attempts;\n    if (typeof attempts !== \"number\" || !Number.isInteger(attempts)) {\n      return false;\n    }\n\n    const traceId = envelope.trace_id;\n    if (typeof traceId !== \"string\" || traceId.trim() === \"\") {\n      return false;\n    }\n\n    return true;\n  },\n} as const;\n","/** Base error for all BabelQueue failures. */\nexport class BabelQueueError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"BabelQueueError\";\n  }\n}\n\n/** Raised when no handler is mapped for a message URN. */\nexport class UnknownUrnError extends BabelQueueError {\n  constructor(urn: string) {\n    super(`No handler is mapped for the message URN \"${urn}\".`);\n    this.name = \"UnknownUrnError\";\n  }\n}\n\n/**\n * Raised when a message's `data` does not match the JSON Schema registered for its URN\n * (ADR-0024). The consumer-side {@link schema.wrap} throws it so the adapter redelivers\n * (and eventually dead-letters) a poison message.\n */\nexport class InvalidPayloadError extends BabelQueueError {\n  constructor(\n    readonly urn: string,\n    readonly violation: string,\n  ) {\n    super(`Message data for \"${urn}\" does not match its URN schema: ${violation}.`);\n    this.name = \"InvalidPayloadError\";\n  }\n}\n"],"mappings":"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","names":["import_node_crypto","otelContext"]}

package/dist/otel.d.cts

@@ -0,0 +1,52 @@
+import { Tracer } from '@opentelemetry/api';
+import { E as Envelope, M as MakeOptions, H as Handler } from './idempotency-DDHjGwF7.cjs';
+
+/**
+ * Optional OpenTelemetry tracing (ADR-0025) — the Node mirror of `babelqueue-go/otel`.
+ *
+ * Emits a CONSUMER span per handled message and a PRODUCER span per publish, correlating them
+ * across every hop and SDK through the envelope's `trace_id` — a UUID, which maps 1:1 to a
+ * 32-hex OTel trace id. The wire envelope is untouched (GR-1) and the zero-dependency core
+ * never imports OpenTelemetry: this module pulls `@opentelemetry/api` as an **optional peer
+ * dependency** and is reached only via the `@babelqueue/core/otel` subpath, so importing the
+ * core itself stays dependency-free.
+ *
+ * ```ts
+ * import { trace } from "@opentelemetry/api";
+ * import { wrapHandler, publish } from "@babelqueue/core/otel";
+ *
+ * const tracer = trace.getTracer("orders");
+ * const traced = wrapHandler(tracer, async (env) => { ... });        // consumer
+ * await publish(tracer, "urn:babel:orders:created", { order_id: 1 }, // producer
+ *   (env) => myTransport.send(env));
+ * ```
+ *
+ * Every hop that shares a `trace_id` shares one OTel trace. Exact cross-hop *span* parent-child
+ * linkage (W3C `traceparent` as a transport header) is a documented follow-up.
+ */
+
+/**
+ * Map an envelope `trace_id` to a deterministic 32-hex OTel trace id: a UUID maps to its
+ * hex bytes; any other string is hashed (SHA-256, first 16 bytes). The inverse of {@link uuidOf}
+ * for the UUID case.
+ */
+declare function traceIdOf(traceId: string): string;
+/**
+ * Format a 32-hex OTel trace id as a canonical UUID string — the form a producer stamps into
+ * the message's `trace_id` so a consumer can recover the same trace id via {@link traceIdOf}.
+ */
+declare function uuidOf(traceIdHex: string): string;
+/**
+ * Wrap a consume handler to emit a CONSUMER span per message, in the OTel trace derived from
+ * the envelope's `trace_id`, recording the handler's error/status. The handler receives the
+ * full {@link Envelope} as before.
+ */
+declare function wrapHandler(tracer: Tracer, handler: Handler): (env: Envelope) => Promise<void>;
+/**
+ * Run a publish under a PRODUCER span `publish <urn>`, carrying the active trace's id into the
+ * built envelope's `trace_id` so the downstream consumer recovers the same trace. `send`
+ * performs the real transport write and its result is returned.
+ */
+declare function publish<R>(tracer: Tracer, urn: string, data: Record<string, unknown>, send: (envelope: Envelope) => R | Promise<R>, options?: MakeOptions): Promise<R>;
+
+export { publish, traceIdOf, uuidOf, wrapHandler };

package/dist/otel.d.ts

@@ -0,0 +1,52 @@
+import { Tracer } from '@opentelemetry/api';
+import { E as Envelope, M as MakeOptions, H as Handler } from './idempotency-DDHjGwF7.js';
+
+/**
+ * Optional OpenTelemetry tracing (ADR-0025) — the Node mirror of `babelqueue-go/otel`.
+ *
+ * Emits a CONSUMER span per handled message and a PRODUCER span per publish, correlating them
+ * across every hop and SDK through the envelope's `trace_id` — a UUID, which maps 1:1 to a
+ * 32-hex OTel trace id. The wire envelope is untouched (GR-1) and the zero-dependency core
+ * never imports OpenTelemetry: this module pulls `@opentelemetry/api` as an **optional peer
+ * dependency** and is reached only via the `@babelqueue/core/otel` subpath, so importing the
+ * core itself stays dependency-free.
+ *
+ * ```ts
+ * import { trace } from "@opentelemetry/api";
+ * import { wrapHandler, publish } from "@babelqueue/core/otel";
+ *
+ * const tracer = trace.getTracer("orders");
+ * const traced = wrapHandler(tracer, async (env) => { ... });        // consumer
+ * await publish(tracer, "urn:babel:orders:created", { order_id: 1 }, // producer
+ *   (env) => myTransport.send(env));
+ * ```
+ *
+ * Every hop that shares a `trace_id` shares one OTel trace. Exact cross-hop *span* parent-child
+ * linkage (W3C `traceparent` as a transport header) is a documented follow-up.
+ */
+
+/**
+ * Map an envelope `trace_id` to a deterministic 32-hex OTel trace id: a UUID maps to its
+ * hex bytes; any other string is hashed (SHA-256, first 16 bytes). The inverse of {@link uuidOf}
+ * for the UUID case.
+ */
+declare function traceIdOf(traceId: string): string;
+/**
+ * Format a 32-hex OTel trace id as a canonical UUID string — the form a producer stamps into
+ * the message's `trace_id` so a consumer can recover the same trace id via {@link traceIdOf}.
+ */
+declare function uuidOf(traceIdHex: string): string;
+/**
+ * Wrap a consume handler to emit a CONSUMER span per message, in the OTel trace derived from
+ * the envelope's `trace_id`, recording the handler's error/status. The handler receives the
+ * full {@link Envelope} as before.
+ */
+declare function wrapHandler(tracer: Tracer, handler: Handler): (env: Envelope) => Promise<void>;
+/**
+ * Run a publish under a PRODUCER span `publish <urn>`, carrying the active trace's id into the
+ * built envelope's `trace_id` so the downstream consumer recovers the same trace. `send`
+ * performs the real transport write and its result is returned.
+ */
+declare function publish<R>(tracer: Tracer, urn: string, data: Record<string, unknown>, send: (envelope: Envelope) => R | Promise<R>, options?: MakeOptions): Promise<R>;
+
+export { publish, traceIdOf, uuidOf, wrapHandler };

package/dist/otel.js

@@ -0,0 +1,105 @@
+import {
+  EnvelopeCodec
+} from "./chunk-7FUZ3LYT.js";
+
+// src/otel.ts
+import { createHash } from "crypto";
+import {
+  SpanKind,
+  SpanStatusCode,
+  TraceFlags,
+  context as otelContext,
+  trace
+} from "@opentelemetry/api";
+var SYSTEM = "babelqueue";
+var INVALID_TRACE_ID = "00000000000000000000000000000000";
+var INVALID_SPAN_ID = "0000000000000000";
+function traceIdOf(traceId) {
+  const hex = traceId.replace(/-/g, "").toLowerCase();
+  if (/^[0-9a-f]{32}$/.test(hex) && hex !== INVALID_TRACE_ID) {
+    return hex;
+  }
+  return createHash("sha256").update(traceId).digest("hex").slice(0, 32);
+}
+function uuidOf(traceIdHex) {
+  const h = traceIdHex.replace(/-/g, "").toLowerCase().padStart(32, "0").slice(0, 32);
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;
+}
+function spanIdOf(traceId) {
+  const sid = createHash("sha256").update(`babelqueue-span:${traceId}`).digest("hex").slice(0, 16);
+  return sid === INVALID_SPAN_ID ? "0000000000000001" : sid;
+}
+function parentContext(traceId) {
+  return trace.setSpanContext(otelContext.active(), {
+    traceId: traceIdOf(traceId),
+    spanId: spanIdOf(traceId),
+    traceFlags: TraceFlags.SAMPLED,
+    isRemote: true
+  });
+}
+function consumeAttributes(env) {
+  return {
+    "messaging.system": SYSTEM,
+    "messaging.operation": "process",
+    "messaging.destination.name": env.meta?.queue ?? "",
+    "messaging.message.id": env.meta?.id ?? "",
+    "messaging.message.conversation_id": env.trace_id,
+    "messaging.babelqueue.attempts": env.attempts ?? 0
+  };
+}
+function wrapHandler(tracer, handler) {
+  return (env) => {
+    const ctx = parentContext(env.trace_id);
+    return tracer.startActiveSpan(
+      `process ${env.job ?? ""}`,
+      { kind: SpanKind.CONSUMER, attributes: consumeAttributes(env) },
+      ctx,
+      async (span) => {
+        try {
+          await handler(env);
+        } catch (err) {
+          span.recordException(err);
+          span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
+          throw err;
+        } finally {
+          span.end();
+        }
+      }
+    );
+  };
+}
+function publish(tracer, urn, data, send, options = {}) {
+  return tracer.startActiveSpan(
+    `publish ${urn}`,
+    {
+      kind: SpanKind.PRODUCER,
+      attributes: {
+        "messaging.system": SYSTEM,
+        "messaging.operation": "publish",
+        "messaging.destination.name": urn
+      }
+    },
+    async (span) => {
+      try {
+        const traceId = uuidOf(span.spanContext().traceId);
+        const envelope = EnvelopeCodec.make(urn, data, { ...options, traceId });
+        const result = await send(envelope);
+        span.setAttribute("messaging.message.id", envelope.meta.id);
+        return result;
+      } catch (err) {
+        span.recordException(err);
+        span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
+        throw err;
+      } finally {
+        span.end();
+      }
+    }
+  );
+}
+export {
+  publish,
+  traceIdOf,
+  uuidOf,
+  wrapHandler
+};
+//# sourceMappingURL=otel.js.map

package/dist/otel.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/otel.ts"],"sourcesContent":["/**\n * Optional OpenTelemetry tracing (ADR-0025) — the Node mirror of `babelqueue-go/otel`.\n *\n * Emits a CONSUMER span per handled message and a PRODUCER span per publish, correlating them\n * across every hop and SDK through the envelope's `trace_id` — a UUID, which maps 1:1 to a\n * 32-hex OTel trace id. The wire envelope is untouched (GR-1) and the zero-dependency core\n * never imports OpenTelemetry: this module pulls `@opentelemetry/api` as an **optional peer\n * dependency** and is reached only via the `@babelqueue/core/otel` subpath, so importing the\n * core itself stays dependency-free.\n *\n * ```ts\n * import { trace } from \"@opentelemetry/api\";\n * import { wrapHandler, publish } from \"@babelqueue/core/otel\";\n *\n * const tracer = trace.getTracer(\"orders\");\n * const traced = wrapHandler(tracer, async (env) => { ... });        // consumer\n * await publish(tracer, \"urn:babel:orders:created\", { order_id: 1 }, // producer\n *   (env) => myTransport.send(env));\n * ```\n *\n * Every hop that shares a `trace_id` shares one OTel trace. Exact cross-hop *span* parent-child\n * linkage (W3C `traceparent` as a transport header) is a documented follow-up.\n */\n\nimport { createHash } from \"node:crypto\";\n\nimport {\n  SpanKind,\n  SpanStatusCode,\n  TraceFlags,\n  context as otelContext,\n  trace,\n  type Attributes,\n  type Context,\n  type Tracer,\n} from \"@opentelemetry/api\";\n\nimport { EnvelopeCodec, type Envelope, type MakeOptions } from \"./codec.js\";\nimport type { Handler } from \"./idempotency.js\";\n\nconst SYSTEM = \"babelqueue\";\nconst INVALID_TRACE_ID = \"00000000000000000000000000000000\";\nconst INVALID_SPAN_ID = \"0000000000000000\";\n\n/**\n * Map an envelope `trace_id` to a deterministic 32-hex OTel trace id: a UUID maps to its\n * hex bytes; any other string is hashed (SHA-256, first 16 bytes). The inverse of {@link uuidOf}\n * for the UUID case.\n */\nexport function traceIdOf(traceId: string): string {\n  const hex = traceId.replace(/-/g, \"\").toLowerCase();\n  if (/^[0-9a-f]{32}$/.test(hex) && hex !== INVALID_TRACE_ID) {\n    return hex;\n  }\n  return createHash(\"sha256\").update(traceId).digest(\"hex\").slice(0, 32);\n}\n\n/**\n * Format a 32-hex OTel trace id as a canonical UUID string — the form a producer stamps into\n * the message's `trace_id` so a consumer can recover the same trace id via {@link traceIdOf}.\n */\nexport function uuidOf(traceIdHex: string): string {\n  const h = traceIdHex.replace(/-/g, \"\").toLowerCase().padStart(32, \"0\").slice(0, 32);\n  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;\n}\n\n/** Deterministic, non-zero 16-hex span id so the remote parent context is valid. */\nfunction spanIdOf(traceId: string): string {\n  const sid = createHash(\"sha256\").update(`babelqueue-span:${traceId}`).digest(\"hex\").slice(0, 16);\n  return sid === INVALID_SPAN_ID ? \"0000000000000001\" : sid;\n}\n\n/** A context carrying a remote parent in the `trace_id`-derived trace. */\nfunction parentContext(traceId: string): Context {\n  return trace.setSpanContext(otelContext.active(), {\n    traceId: traceIdOf(traceId),\n    spanId: spanIdOf(traceId),\n    traceFlags: TraceFlags.SAMPLED,\n    isRemote: true,\n  });\n}\n\nfunction consumeAttributes(env: Envelope): Attributes {\n  return {\n    \"messaging.system\": SYSTEM,\n    \"messaging.operation\": \"process\",\n    \"messaging.destination.name\": env.meta?.queue ?? \"\",\n    \"messaging.message.id\": env.meta?.id ?? \"\",\n    \"messaging.message.conversation_id\": env.trace_id,\n    \"messaging.babelqueue.attempts\": env.attempts ?? 0,\n  };\n}\n\n/**\n * Wrap a consume handler to emit a CONSUMER span per message, in the OTel trace derived from\n * the envelope's `trace_id`, recording the handler's error/status. The handler receives the\n * full {@link Envelope} as before.\n */\nexport function wrapHandler(\n  tracer: Tracer,\n  handler: Handler,\n): (env: Envelope) => Promise<void> {\n  return (env: Envelope): Promise<void> => {\n    const ctx = parentContext(env.trace_id);\n    return tracer.startActiveSpan(\n      `process ${env.job ?? \"\"}`,\n      { kind: SpanKind.CONSUMER, attributes: consumeAttributes(env) },\n      ctx,\n      async (span) => {\n        try {\n          await handler(env);\n        } catch (err) {\n          span.recordException(err as Error);\n          span.setStatus({ code: SpanStatusCode.ERROR, message: (err as Error).message });\n          throw err;\n        } finally {\n          span.end();\n        }\n      },\n    );\n  };\n}\n\n/**\n * Run a publish under a PRODUCER span `publish <urn>`, carrying the active trace's id into the\n * built envelope's `trace_id` so the downstream consumer recovers the same trace. `send`\n * performs the real transport write and its result is returned.\n */\nexport function publish<R>(\n  tracer: Tracer,\n  urn: string,\n  data: Record<string, unknown>,\n  send: (envelope: Envelope) => R | Promise<R>,\n  options: MakeOptions = {},\n): Promise<R> {\n  return tracer.startActiveSpan(\n    `publish ${urn}`,\n    {\n      kind: SpanKind.PRODUCER,\n      attributes: {\n        \"messaging.system\": SYSTEM,\n        \"messaging.operation\": \"publish\",\n        \"messaging.destination.name\": urn,\n      },\n    },\n    async (span) => {\n      try {\n        const traceId = uuidOf(span.spanContext().traceId);\n        const envelope = EnvelopeCodec.make(urn, data, { ...options, traceId });\n        const result = await send(envelope);\n        span.setAttribute(\"messaging.message.id\", envelope.meta.id);\n        return result;\n      } catch (err) {\n        span.recordException(err as Error);\n        span.setStatus({ code: SpanStatusCode.ERROR, message: (err as Error).message });\n        throw err;\n      } finally {\n        span.end();\n      }\n    },\n  );\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babelqueue/core",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Polyglot Queues, Simplified — the Node/TypeScript core: the canonical BabelQueue wire-envelope codec, contracts and dead-letter helpers.",
   "keywords": [
     "queue",
@@ -33,6 +33,16 @@
         "types": "./dist/index.d.cts",
         "default": "./dist/index.cjs"
       }
+    },
+    "./otel": {
+      "import": {
+        "types": "./dist/otel.d.ts",
+        "default": "./dist/otel.js"
+      },
+      "require": {
+        "types": "./dist/otel.d.cts",
+        "default": "./dist/otel.cjs"
+      }
     }
   },
   "main": "./dist/index.cjs",
@@ -49,12 +59,14 @@
     "build": "tsup",
     "typecheck": "tsc --noEmit",
     "lint": "eslint src test",
-    "test": "node --import tsx --test test/codec.test.ts test/dead-letter.test.ts test/conformance.test.ts test/overhead.test.ts test/idempotency.test.ts test/schema.test.ts",
+    "test": "node --import tsx --test test/codec.test.ts test/dead-letter.test.ts test/conformance.test.ts test/overhead.test.ts test/idempotency.test.ts test/schema.test.ts test/otel.test.ts",
     "coverage": "c8 --check-coverage --lines 90 --functions 90 --branches 85 --reporter=text npm test",
     "prepublishOnly": "npm run build"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/sdk-trace-base": "^2.8.0",
     "@types/node": "^22",
     "c8": "^11.0.0",
     "eslint": "^10.4.1",
@@ -65,5 +77,13 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "peerDependencies": {
+    "@opentelemetry/api": "^1.9.1"
+  },
+  "peerDependenciesMeta": {
+    "@opentelemetry/api": {
+      "optional": true
+    }
   }
 }