@devopsplaybook.io/otel-utils 1.8.0-beta.39.883f25d → 1.9.0-beta.40.3ebb823

package/README.md

@@ -8,24 +8,26 @@ Utility library that simplifies OpenTelemetry integration for Node.js services.
 npm install @devopsplaybook.io/otel-utils
 ```
 
+Requires Node.js 22 or newer (`engines` in `package.json`).
+
 ## Configuration
 
 All classes accept a `ConfigOTelInterface` object. The fields mirror environment variables in the consuming application (for example `common-utils`' `ConfigBase`); the library itself does not read `process.env`.
 
-| Field                                                     | Type                                | Default    | Description                                        |
-| --------------------------------------------------------- | ----------------------------------- | ---------- | -------------------------------------------------- |
-| `SERVICE_ID`                                              | `string`                            | —          | Service identifier (required, non-empty)           |
-| `VERSION`                                                 | `string`                            | —          | Service version (required, non-empty)              |
-| `OPENTELEMETRY_COLLECTOR_HTTP_TRACES`                     | `string?`                           | —          | OTLP HTTP endpoint for traces                      |
-| `OPENTELEMETRY_COLLECTOR_HTTP_METRICS`                    | `string?`                           | —          | OTLP HTTP endpoint for metrics                     |
-| `OPENTELEMETRY_COLLECTOR_HTTP_LOGS`                       | `string?`                           | —          | OTLP HTTP endpoint for logs                        |
-| `OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_INTERVAL_SECONDS`    | `number?`                           | `60`       | Log export interval in seconds (clamped to ≥ 1)    |
+| Field                                                     | Type                                | Default    | Description                                         |
+| --------------------------------------------------------- | ----------------------------------- | ---------- | --------------------------------------------------- |
+| `SERVICE_ID`                                              | `string`                            | —          | Service identifier (required, non-empty)            |
+| `VERSION`                                                 | `string`                            | —          | Service version (required, non-empty)               |
+| `OPENTELEMETRY_COLLECTOR_HTTP_TRACES`                     | `string?`                           | —          | OTLP HTTP endpoint for traces                       |
+| `OPENTELEMETRY_COLLECTOR_HTTP_METRICS`                    | `string?`                           | —          | OTLP HTTP endpoint for metrics                      |
+| `OPENTELEMETRY_COLLECTOR_HTTP_LOGS`                       | `string?`                           | —          | OTLP HTTP endpoint for logs                         |
+| `OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_INTERVAL_SECONDS`    | `number?`                           | `60`       | Log export interval in seconds (clamped to ≥ 1)     |
 | `OPENTELEMETRY_COLLECTOR_EXPORT_METRICS_INTERVAL_SECONDS` | `number?`                           | `60`       | Metrics export interval in seconds (clamped to ≥ 1) |
-| `OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_MAX_QUEUE_SIZE`      | `number?`                           | `2048`     | Max log records buffered before export             |
-| `OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_MAX_BATCH_SIZE`      | `number?`                           | `512`      | Max log records per export batch                   |
-| `OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_TIMEOUT_MILLIS`      | `number?`                           | `30000`    | Log export timeout in milliseconds                 |
-| `OPENTELEMETRY_CONSOLE_LOG_MODE`                          | `"always" \| "fallback" \| "never"` | `"always"` | Console mirroring mode for `ModuleLogger`          |
-| `OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER`              | `string?`                           | —          | Bearer token for collector auth                    |
+| `OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_MAX_QUEUE_SIZE`      | `number?`                           | `2048`     | Max log records buffered before export              |
+| `OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_MAX_BATCH_SIZE`      | `number?`                           | `512`      | Max log records per export batch                    |
+| `OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_TIMEOUT_MILLIS`      | `number?`                           | `30000`    | Log export timeout in milliseconds                  |
+| `OPENTELEMETRY_CONSOLE_LOG_MODE`                          | `"always" \| "fallback" \| "never"` | `"always"` | Console mirroring mode for `ModuleLogger`           |
+| `OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER`              | `string?`                           | —          | Bearer token for collector auth                     |
 
 `SERVICE_ID` and `VERSION` must be non-empty strings. `StandardTracer`/`StandardMeter` constructors and `StandardLogger.initOTel` fail fast with `[otel-utils] SERVICE_ID must be a non-empty string` / `[otel-utils] VERSION must be a non-empty string` otherwise. A failed re-initialisation of `StandardLogger` keeps the previous provider in place.
 
@@ -57,8 +59,8 @@ span.end();
 
 **Methods:**
 
-- `startSpan(name, parentSpan?, options?)` — Creates a span. Span names are sanitized to `[a-zA-Z0-9-_/]`. When neither `parentSpan` nor `options` is given, the span is `SpanKind.INTERNAL` and carries `http.request_method=BACKEND` and a synthetic `http.route` attribute. Passing `options` (e.g. `{ kind: SpanKind.SERVER }`) forwards them to the OpenTelemetry SDK instead and skips those synthetic attributes, because the caller then describes the span itself.
-- `static updateHttpHeader(context, headers?)` — Injects W3C trace context into an HTTP headers object for propagation to downstream services.
+- `startSpan(name, parentSpan?, options?)` — Creates a span and returns the SDK `Span` from `@opentelemetry/sdk-trace`. Span names are sanitized to `[a-zA-Z0-9-_/]`. `parentSpan` accepts any API `Span` (for example from `trace.getSpan(context)` or `trace.wrapSpanContext(...)`), so callers need no cast. When neither `parentSpan` nor `options` is given, the span is `SpanKind.INTERNAL` and carries `http.request.method=BACKEND` and a synthetic `http.route` attribute with the value `${serviceName}-${version}-${sanitizedSpanName}`. Passing a `parentSpan`, an `options` object (e.g. `{ kind: SpanKind.SERVER }`), or both forwards them to the OpenTelemetry SDK instead and skips those synthetic attributes, because the caller then describes the span itself. Generic HTTP dashboards that group by `http.request.method`/`http.route` count these spans as `BACKEND` requests with a synthetic route; this is intentional and consumed by otel-light.
+- `static updateHttpHeader<T extends object = Record<string, string>>(context, headers?)` — Injects the W3C trace context of `context` into an HTTP headers object for propagation to downstream services, and returns that same object (a new one when omitted). Only `traceparent` and `tracestate` are injected: the propagation context is built from the span alone, so baggage and other active-context values are **not** propagated and an existing `baggage` header is left untouched.
 - `shutdown()` — Flushes buffered spans and shuts the tracer provider down. Idempotent.
 
 ### StandardLogger
@@ -86,12 +88,12 @@ moduleLog.info("Hello world");
 
 `BatchLogRecordProcessor` buffers records in memory and exports them periodically:
 
-| Option               | Config field                                           | Default    |
-| -------------------- | ------------------------------------------------------ | ---------- |
-| `scheduledDelayMillis` | `OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_INTERVAL_SECONDS` | 60000 ms   |
-| `maxQueueSize`       | `OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_MAX_QUEUE_SIZE`   | 2048       |
-| `maxExportBatchSize` | `OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_MAX_BATCH_SIZE`   | 512        |
-| `exportTimeoutMillis` | `OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_TIMEOUT_MILLIS`  | 30000 ms   |
+| Option                 | Config field                                           | Default  |
+| ---------------------- | ------------------------------------------------------ | -------- |
+| `scheduledDelayMillis` | `OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_INTERVAL_SECONDS` | 60000 ms |
+| `maxQueueSize`         | `OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_MAX_QUEUE_SIZE`   | 2048     |
+| `maxExportBatchSize`   | `OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_MAX_BATCH_SIZE`   | 512      |
+| `exportTimeoutMillis`  | `OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_TIMEOUT_MILLIS`   | 30000 ms |
 
 A record waits up to `scheduledDelayMillis` (60 s by default) before it is exported; each export sends at most `maxExportBatchSize` (512) records with a 30 s timeout, and at most `maxQueueSize` (2048) records are buffered. Records that arrive while the queue is full are **dropped silently** — no warning or fallback is emitted. A crash or restart loses every record buffered since the last export; call `shutdown()` or use `registerShutdownHooks` (see [Graceful shutdown](#graceful-shutdown)) to flush them. Keep `maxExportBatchSize` ≤ `maxQueueSize` (the SDK clamps it otherwise).
 
@@ -109,11 +111,11 @@ await logger.initOTel({
 
 Scoped logger that prefixes all output with a module name. Every record carries a `log.module` attribute in addition to the `[module] message` body. Records are emitted to the OTel logger when one is available, and can additionally be mirrored to the console, controlled by `OPENTELEMETRY_CONSOLE_LOG_MODE`:
 
-| Mode                | Behaviour                                                                                     |
-| ------------------- | --------------------------------------------------------------------------------------------- |
-| `always` (default)  | Mirror every record to the console, whether or not OTel logging is configured.                |
-| `fallback`          | Mirror only when no OTel logger is configured (`OPENTELEMETRY_COLLECTOR_HTTP_LOGS` unset).    |
-| `never`             | Never write to the console; records only go to OTel.                                          |
+| Mode               | Behaviour                                                                                  |
+| ------------------ | ------------------------------------------------------------------------------------------ |
+| `always` (default) | Mirror every record to the console, whether or not OTel logging is configured.             |
+| `fallback`         | Mirror only when no OTel logger is configured (`OPENTELEMETRY_COLLECTOR_HTTP_LOGS` unset). |
+| `never`            | Never write to the console; records only go to OTel.                                       |
 
 Mirroring is level-aware: `info` uses `console.log`, `warn` uses `console.warn` and `error` uses `console.error` (stderr), so stderr-based alerting sees warnings and errors. An invalid mode value logs one `console.warn` and falls back to `always`. With `never`, a `ModuleLogger` writes nothing to the console even when no OTel logger is configured.
 
@@ -272,8 +274,8 @@ All three signals share the same service identity (name + version) and resource
 
 ## Dependencies
 
-- `@opentelemetry/api` / `@opentelemetry/api-logs` — OpenTelemetry API interfaces
-- `@opentelemetry/sdk-trace-node` / `@opentelemetry/sdk-trace-base` — Tracing SDK
+- `@opentelemetry/api` — OpenTelemetry API interfaces
+- `@opentelemetry/sdk-trace` — Tracing SDK
 - `@opentelemetry/sdk-metrics` — Metrics SDK
 - `@opentelemetry/sdk-logs` — Logging SDK
 - `@opentelemetry/exporter-trace-otlp-http` / `@opentelemetry/exporter-metrics-otlp-http` / `@opentelemetry/exporter-logs-otlp-http` — OTLP HTTP exporters
@@ -282,8 +284,13 @@ All three signals share the same service identity (name + version) and resource
 - `@opentelemetry/core` — W3C trace context propagation
 - `@opentelemetry/resources` / `@opentelemetry/semantic-conventions` — Resource attributes
 
+Dev-only `npm audit` advisories (such as those previously reported in the Jest toolchain via `js-yaml`/`sprintf-js`) are tracked by the regular dependency-update task, not addressed here. The current lockfile reports no vulnerabilities, with or without dev dependencies.
+
 ## Build
 
 ```bash
-npm run build   # tsc → dist/
+npm ci          # install the locked dependencies
+npm run build   # tsc → dist/, then type-check the specs
+npm run lint    # oxlint + Prettier check
+npm test        # Jest unit tests with coverage
 ```

package/dist/src/StandardLogger.js

@@ -63,7 +63,9 @@ class StandardLogger {
         return this.logger;
     }
     createModuleLogger(moduleName) {
-        return new ModuleLogger_1.ModuleLogger(moduleName, this, { consoleMode: this.consoleMode });
+        return new ModuleLogger_1.ModuleLogger(moduleName, this, {
+            consoleMode: this.consoleMode,
+        });
     }
     registerGlobalProvider() {
         if (globalLoggerProvider) {

package/dist/src/StandardTracer.d.ts

@@ -26,8 +26,14 @@ export declare class StandardTracer {
     private shutdownPromise?;
     constructor(config: ConfigOTelInterface);
     shutdown(): Promise<void>;
-    startSpan(name: string, parentSpan?: Span, options?: StandardTracerStartSpanOptions): Span;
-    static updateHttpHeader(context: ApiSpan, headers?: {}): any;
+    startSpan(name: string, parentSpan?: ApiSpan, options?: StandardTracerStartSpanOptions): Span;
+    /**
+     * Injects the W3C trace context of `context` into `headers` and returns it.
+     *
+     * The propagation context is built from the span alone (ROOT_CONTEXT), so
+     * only traceparent/tracestate are injected; baggage is not propagated.
+     */
+    static updateHttpHeader<T extends object = Record<string, string>>(context: ApiSpan, headers?: T): T;
     private registerGlobalProvider;
     private doShutdown;
 }

package/dist/src/StandardTracer.js

@@ -68,11 +68,14 @@ class StandardTracer {
         span.setAttribute(semantic_conventions_1.ATTR_HTTP_ROUTE, `${this.serviceName}-${this.serviceVersion}-${sanitizedName}`);
         return span;
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    /**
+     * Injects the W3C trace context of `context` into `headers` and returns it.
+     *
+     * The propagation context is built from the span alone (ROOT_CONTEXT), so
+     * only traceparent/tracestate are injected; baggage is not propagated.
+     */
     static updateHttpHeader(context, headers = {}) {
-        StandardTracer.PROPAGATOR.inject(api_1.trace.setSpanContext(api_1.ROOT_CONTEXT, context.spanContext()), 
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        headers, api_1.defaultTextMapSetter);
+        StandardTracer.PROPAGATOR.inject(api_1.trace.setSpanContext(api_1.ROOT_CONTEXT, context.spanContext()), headers, api_1.defaultTextMapSetter);
         return headers;
     }
     registerGlobalProvider() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devopsplaybook.io/otel-utils",
-  "version": "1.8.0-beta.39.883f25d",
+  "version": "1.9.0-beta.40.3ebb823",
   "description": "Utility to simplify integration with Open Telemetry",
   "keywords": [
     "Open",
@@ -14,11 +14,24 @@
   "type": "commonjs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
   "scripts": {
     "build": "tsc && tsc -p tsconfig.spec.json --noEmit",
-    "lint": "oxlint src",
-    "test": "jest --coverage",
-    "dependencies": ""
+    "format": "prettier --write .",
+    "lint": "oxlint index.ts src && prettier --check .",
+    "test": "jest --coverage"
   },
   "dependencies": {
     "@opentelemetry/api": "^1.10.0",
@@ -39,9 +52,9 @@
     "@swc/jest": "^0.2.39",
     "@types/jest": "^30.0.0",
     "@types/node": "^26.6.5",
-    "@types/sqlite3": "^5.1.0",
     "jest": "^30.5.2",
     "oxlint": "^1.89.0",
+    "prettier": "^3.9.10",
     "typescript": "^7.0.2"
   },
   "publishConfig": {

package/.github/workflows/main-build.yml

@@ -1,16 +0,0 @@
-name: Main Build
-
-on:
-  push:
-    branches: ["main"]
-
-  workflow_dispatch:
-
-jobs:
-  npm-merge:
-    uses: devopsplaybook-io/common-utils/.github/workflows/reusable-npm-merge.yml@main
-    with:
-      npm_package_name: "@devopsplaybook.io/otel-utils"
-      node_version: "22"
-    secrets:
-      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.github/workflows/pr-check.yml

@@ -1,25 +0,0 @@
-name: PR Check
-
-on:
-  pull_request:
-    branches: ["main"]
-
-  workflow_dispatch:
-
-concurrency:
-  group: pr-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read
-  pull-requests: write
-  issues: write
-
-jobs:
-  npm-pr:
-    uses: devopsplaybook-io/common-utils/.github/workflows/reusable-npm-pr.yml@main
-    with:
-      npm_package_name: "@devopsplaybook.io/otel-utils"
-      node_version: "22"
-    secrets:
-      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package/index.ts

@@ -1,7 +0,0 @@
-export * from "./src/models/ConfigOTelInterface";
-export * from "./src/models/StandardLoggerInterface";
-export * from "./src/ModuleLogger";
-export * from "./src/ShutdownHooks";
-export * from "./src/StandardLogger";
-export * from "./src/StandardMeter";
-export * from "./src/StandardTracer";

package/jest.config.js

@@ -1,17 +0,0 @@
-module.exports = {
-  moduleFileExtensions: ["ts", "js"],
-  transform: {
-    "^.+\\.(ts|tsx)$": [
-      "@swc/jest",
-      {
-        jsc: {
-          target: "es2019",
-        },
-      },
-    ],
-  },
-  coverageProvider: "v8",
-  testMatch: ["/**/src/**/*.spec.(ts|js)"],
-  testPathIgnorePatterns: ["/node_modules/", "/dist/"],
-  testEnvironment: "node",
-};

package/prettierrc.json

@@ -1,5 +0,0 @@
-{
-  "tabWidth": 2,
-  "semi": true,
-  "singleQuote": false
-}

package/src/ModuleLogger.spec.ts

@@ -1,253 +0,0 @@
-import type { Span } from "@opentelemetry/api";
-import {
-  SeverityNumber,
-  type Logger as OTelLogger,
-} from "@opentelemetry/api";
-import { ModuleLogger, type ModuleLoggerOptions } from "./ModuleLogger";
-import type { StandardLoggerInterface } from "./models/StandardLoggerInterface";
-
-describe("ModuleLogger", () => {
-  let logSpy: jest.SpyInstance;
-  let warnSpy: jest.SpyInstance;
-  let errorSpy: jest.SpyInstance;
-  let emit: jest.Mock;
-
-  beforeEach(() => {
-    emit = jest.fn();
-    logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
-    warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
-    errorSpy = jest.spyOn(console, "error").mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    logSpy.mockRestore();
-    warnSpy.mockRestore();
-    errorSpy.mockRestore();
-  });
-
-  function createLogger(
-    getLogger: () => OTelLogger | undefined,
-  ): StandardLoggerInterface {
-    return { getLogger };
-  }
-
-  function loggerWithEmit(options?: ModuleLoggerOptions): ModuleLogger {
-    const fakeLogger = { emit } as unknown as OTelLogger;
-    return new ModuleLogger("billing", createLogger(() => fakeLogger), options);
-  }
-
-  function lastAttributes(): Record<string, unknown> {
-    const record = emit.mock.calls[emit.mock.calls.length - 1][0] as {
-      attributes: Record<string, unknown>;
-    };
-    return record.attributes;
-  }
-
-  function expectOnlyDefinedAttributes(): void {
-    for (const [key, value] of Object.entries(lastAttributes())) {
-      expect({ key, defined: value !== undefined }).toEqual({
-        key,
-        defined: true,
-      });
-    }
-  }
-
-  it("logs info to console.log and the OTel logger with the module attribute", () => {
-    loggerWithEmit().info("hello");
-
-    expect(logSpy).toHaveBeenCalledWith("[info] [billing] hello");
-    expect(warnSpy).not.toHaveBeenCalled();
-    expect(errorSpy).not.toHaveBeenCalled();
-    expect(emit).toHaveBeenCalledWith({
-      severityNumber: SeverityNumber.INFO,
-      severityText: "info",
-      body: "[billing] hello",
-      attributes: { "log.type": "custom", "log.module": "billing" },
-    });
-  });
-
-  it("mirrors warnings through console.warn", () => {
-    loggerWithEmit().warn("careful");
-
-    expect(warnSpy).toHaveBeenCalledWith("[warn] [billing] careful");
-    expect(logSpy).not.toHaveBeenCalled();
-    expect(errorSpy).not.toHaveBeenCalled();
-    expect(emit).toHaveBeenCalledWith(
-      expect.objectContaining({
-        severityNumber: SeverityNumber.WARN,
-        severityText: "warn",
-        body: "[billing] careful",
-      }),
-    );
-  });
-
-  it("mirrors errors through console.error", () => {
-    loggerWithEmit().error("failed");
-
-    expect(errorSpy).toHaveBeenCalledWith("[error] [billing] failed");
-    expect(logSpy).not.toHaveBeenCalled();
-  });
-
-  it("logs errors without duplicating the stack in the record body", () => {
-    const error = new Error("boom");
-    loggerWithEmit().error("request failed", error);
-
-    expect(emit).toHaveBeenCalledWith({
-      severityNumber: SeverityNumber.ERROR,
-      severityText: "error",
-      body: "[billing] request failed",
-      attributes: {
-        "log.type": "custom",
-        "log.module": "billing",
-        "exception.type": "Error",
-        "exception.message": "boom",
-        "exception.stacktrace": error.stack,
-      },
-    });
-  });
-
-  it("normalises a string error instead of losing its message", () => {
-    loggerWithEmit().error("failed", "string-error");
-
-    const attributes = lastAttributes();
-    expect(attributes["exception.type"]).toBe("Error");
-    expect(attributes["exception.message"]).toBe("string-error");
-    expect(typeof attributes["exception.stacktrace"]).toBe("string");
-    expectOnlyDefinedAttributes();
-  });
-
-  it("serialises a plain object error", () => {
-    loggerWithEmit().error("failed", { code: 42 });
-
-    const attributes = lastAttributes();
-    expect(attributes["exception.type"]).toBe("Error");
-    expect(attributes["exception.message"]).toBe('{"code":42}');
-    expect(typeof attributes["exception.stacktrace"]).toBe("string");
-    expectOnlyDefinedAttributes();
-  });
-
-  it("adds no exception attributes without an error", () => {
-    loggerWithEmit().error("failed");
-    expect(lastAttributes()).toEqual({
-      "log.type": "custom",
-      "log.module": "billing",
-    });
-
-    loggerWithEmit().error("failed", null);
-    expect(lastAttributes()).toEqual({
-      "log.type": "custom",
-      "log.module": "billing",
-    });
-  });
-
-  it("omits exception.stacktrace when the error has no stack", () => {
-    const error = new Error("no stack");
-    delete error.stack;
-
-    loggerWithEmit().error("failed", error);
-
-    const attributes = lastAttributes();
-    expect(attributes["exception.type"]).toBe("Error");
-    expect(attributes["exception.message"]).toBe("no stack");
-    expect(attributes).not.toHaveProperty("exception.stacktrace");
-    expectOnlyDefinedAttributes();
-  });
-
-  it("treats a span passed as the second argument as context", () => {
-    const span = {
-      spanContext: () => ({ spanId: "span-1", traceId: "trace-1" }),
-    } as unknown as Span;
-
-    loggerWithEmit().error("failed", span);
-
-    expect(errorSpy).toHaveBeenCalledWith("[error] [billing] failed");
-    expect(lastAttributes()).toEqual({
-      "log.type": "custom",
-      "log.module": "billing",
-      "span.id": "span-1",
-      "trace.id": "trace-1",
-    });
-  });
-
-  it("adds span and trace ids when a span context is provided", () => {
-    const span = {
-      spanContext: () => ({ spanId: "span-1", traceId: "trace-1" }),
-    } as unknown as Span;
-
-    loggerWithEmit().info("inside a span", span);
-
-    expect(emit).toHaveBeenCalledWith(
-      expect.objectContaining({
-        attributes: expect.objectContaining({
-          "span.id": "span-1",
-          "trace.id": "trace-1",
-        }),
-      }),
-    );
-  });
-
-  it("combines exception attributes with a span context", () => {
-    const span = {
-      spanContext: () => ({ spanId: "span-2", traceId: "trace-2" }),
-    } as unknown as Span;
-
-    loggerWithEmit().error("failed", new Error("boom"), span);
-
-    const attributes = lastAttributes();
-    expect(attributes["exception.message"]).toBe("boom");
-    expect(attributes["span.id"]).toBe("span-2");
-    expect(attributes["trace.id"]).toBe("trace-2");
-    expectOnlyDefinedAttributes();
-  });
-
-  describe("console modes", () => {
-    it("always mirrors with and without an OTel logger", () => {
-      loggerWithEmit({ consoleMode: "always" }).info("with logger");
-      expect(logSpy).toHaveBeenCalledWith("[info] [billing] with logger");
-      expect(emit).toHaveBeenCalledTimes(1);
-
-      const withoutLogger = new ModuleLogger(
-        "billing",
-        createLogger(() => undefined),
-        { consoleMode: "always" },
-      );
-      withoutLogger.info("without logger");
-      expect(logSpy).toHaveBeenCalledWith(
-        "[info] [billing] without logger",
-      );
-      expect(emit).toHaveBeenCalledTimes(1);
-    });
-
-    it("fallback mirrors only when no OTel logger is available", () => {
-      loggerWithEmit({ consoleMode: "fallback" }).info("with logger");
-      expect(logSpy).not.toHaveBeenCalled();
-      expect(emit).toHaveBeenCalledTimes(1);
-
-      const withoutLogger = new ModuleLogger(
-        "billing",
-        createLogger(() => undefined),
-        { consoleMode: "fallback" },
-      );
-      withoutLogger.warn("without logger");
-      expect(warnSpy).toHaveBeenCalledWith(
-        "[warn] [billing] without logger",
-      );
-    });
-
-    it("never disables console output while records are still emitted", () => {
-      loggerWithEmit({ consoleMode: "never" }).error("silent");
-
-      expect(logSpy).not.toHaveBeenCalled();
-      expect(warnSpy).not.toHaveBeenCalled();
-      expect(errorSpy).not.toHaveBeenCalled();
-      expect(emit).toHaveBeenCalledWith(
-        expect.objectContaining({ severityText: "error" }),
-      );
-    });
-
-    it("defaults to always when no options are given", () => {
-      new ModuleLogger("billing", createLogger(() => undefined)).info("legacy");
-      expect(logSpy).toHaveBeenCalledWith("[info] [billing] legacy");
-    });
-  });
-});