@photon-ai/otel 0.1.2 → 1.1.0

package/README.md

@@ -5,8 +5,9 @@ A DX-focused OpenTelemetry wrapper for **Bun** and **Node.js**.
 Vanilla OTel works, but the setup is verbose, the logger plumbing is awkward, and PII scrubbing is on you. `@photon-ai/otel` wraps the OTLP/HTTP stack into a few well-named functions:
 
 - **`setupOtel()`** — idempotent one-call bootstrap for traces + logs. Honors all standard `OTEL_EXPORTER_OTLP_*` env vars.
-- **`createLogger(module)`** — structured logger that writes to both the OTel logger provider and `console`, with automatic trace correlation and exception capture.
+- **`createLogger(module)`** — structured logger that writes to both the OTel logger provider and `console`, with automatic trace correlation and exception capture. Every level (`debug`/`info`/`warn`/`error`) accepts `attrs` **and** an `error`, and is gated by a configurable `LOG_LEVEL`.
 - **`withSpan(name, attrs?, fn)`** — wrap any sync or async function in a span; errors are recorded and PII in the error message is scrubbed before being attached to span status.
+- **Automatic `fetch` tracing** — `setupOtel()` wraps `globalThis.fetch` so every outbound request gets a CLIENT span and W3C trace-context headers. On **Bun** this is the only fetch instrumentation that works — the standard `diagnostics_channel`-based OTel instrumentations emit nothing for Bun's native fetch — and it behaves identically on Node.
 - **`sanitizeEmail` / `sanitizePhone` / `sanitizeErrorMessage`** — PII helpers you can reuse anywhere.
 
 OTLP/HTTP only (no gRPC, no proto). Works identically on Bun and Node ≥ 20.
@@ -34,7 +35,9 @@ const log = createLogger("server");
 
 await withSpan("handle-request", { route: "/users" }, async () => {
   log.info("processing request", { userId: 42 });
-  // ... your work
+  // Outbound fetch is traced automatically: a CLIENT span, parented to this
+  // one, with a `traceparent` header injected for the downstream service.
+  await fetch("https://api.example.com/users");
 });
 ```
 
@@ -46,7 +49,10 @@ If `OTEL_EXPORTER_OTLP_ENDPOINT` (or the `endpoint` option) is unset, `setupOtel
 | --------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
 | `setupOtel(options): OtelHandle`              | Boots OTLP/HTTP traces + logs. Idempotent. Returns `{ shutdown(): Promise<void> }`.                        |
 | `isOtelActive(): boolean`                     | Returns `true` if `setupOtel` has already run in this process.                                             |
+| `instrumentFetch(options?): FetchInstrumentation` | Wraps `globalThis.fetch` for CLIENT spans + W3C propagation. Auto-enabled by `setupOtel` when traces are configured. Returns `{ unpatch() }`. |
 | `createLogger(module): PhotonLogger`          | Returns `{ info, warn, error, debug }`. Each call emits to OTel + `console`, correlates to active span.    |
+| `setLogLevel(level): void`                    | Set the minimum level emitted (`debug`/`info`/`warn`/`error`/`silent`). `LOG_LEVEL` env still wins.        |
+| `getLogLevel(): LogLevel`                     | Current effective level after env / override / default resolution.                                        |
 | `withSpan(name, fn)`                          | Wraps `fn` (sync or async) in a span. Records exceptions and scrubs PII in error messages.                 |
 | `withSpan(name, attrs, fn)`                   | Same as above but attaches `attrs` to the span.                                                            |
 | `sanitizeEmail(input)`                        | Masks an email: `foo.bar@example.com` → `fo***@e***.com`.                                                  |
@@ -57,13 +63,42 @@ If `OTEL_EXPORTER_OTLP_ENDPOINT` (or the `endpoint` option) is unset, `setupOtel
 ### Logger signatures
 
 ```ts
-log.info(message, attrs?);
-log.warn(message, attrs?);
-log.error(message, attrs?, error?); // only error() accepts an exception
-log.debug(message, attrs?);
+log.debug(message, attrs?, error?);
+log.info(message, attrs?, error?);
+log.warn(message, attrs?, error?); // attach the exception that caused a retry
+log.error(message, attrs?, error?);
 ```
 
-`attrs` is `Record<string, string | number | boolean | undefined>`. `undefined` values are dropped.
+Every level takes the same `(message, attrs?, error?)` shape — attach an exception to a
+`warn`/`info`/`debug`, not just `error`. `attrs` is
+`Record<string, string | number | boolean | undefined>`; `undefined` values are dropped.
+
+An `Error` is recorded as `exception.type` / `exception.message` / `exception.stacktrace`
+on the OTLP record (per the OTel exception semantic convention); a non-`Error` throw is
+coerced so at least `exception.message` is preserved.
+
+Each call also prints a single human-readable console line — `[module] LEVEL message
+{ ...attrs }` plus the raw error (so the runtime renders the full stack) — routed to
+`console.debug` / `console.info` / `console.warn` / `console.error` by severity. Both
+sinks share one level gate.
+
+### Log level
+
+Logs below the active level are dropped from **both** OTLP and the console. The level is
+resolved fresh on every call, so changes take effect immediately:
+
+1. `LOG_LEVEL` env var (`debug` | `info` | `warn` | `error` | `silent`) — wins if set.
+2. `setLogLevel(level)` or `setupOtel({ logLevel })`.
+3. Default: `debug` in development (`DEPLOYMENT_ENV` unset or `development`), `info` otherwise.
+
+```ts
+import { setLogLevel } from "@photon-ai/otel";
+
+setLogLevel("warn"); // debug + info now suppressed everywhere
+// or set LOG_LEVEL=warn in the environment, which overrides the call above
+```
+
+`"silent"` suppresses everything, including errors.
 
 ## Configuration
 
@@ -75,7 +110,32 @@ Standard OpenTelemetry env vars always take precedence over `SetupOtelOptions`:
 | `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`      | Full traces URL (overrides the base for traces).        |
 | `OTEL_EXPORTER_OTLP_LOGS_ENDPOINT`        | Full logs URL (overrides the base for logs).            |
 | `OTEL_EXPORTER_OTLP_HEADERS`              | `key=value,key=value` headers; merged with `options.headers` (env wins). |
-| `DEPLOYMENT_ENV`                          | Attached as `deployment.environment` resource attribute. Defaults to `development`. |
+| `DEPLOYMENT_ENV`                          | Attached as `deployment.environment` resource attribute. Defaults to `development`. Also drives the default log level. |
+| `LOG_LEVEL`                               | Minimum log level: `debug` \| `info` \| `warn` \| `error` \| `silent`. Overrides `setLogLevel()` / `setupOtel({ logLevel })`. |
+
+## Automatic fetch instrumentation
+
+`setupOtel()` patches `globalThis.fetch` to emit a CLIENT span per outbound request, carrying
+W3C `traceparent` (and baggage) headers so traces continue across services. Each span is named by
+HTTP method (`GET`, `POST`, …) and carries `http.request.method`, `url.full`, `server.address`,
+`server.port`, and `http.response.status_code`; `4xx`/`5xx` responses and thrown network errors are
+marked `ERROR`. This covers **outbound** requests only — inbound `Bun.serve`/Elysia server spans are
+separate (see [Framework integration](#framework-integration)).
+
+- **Default:** on when a traces endpoint is configured. Pass `instrumentFetch: false` to disable, or
+  `instrumentFetch: true` to force it on even without an endpoint.
+- **Filter URLs:** `instrumentFetch: { ignore: (url) => url.includes("/healthz") }`. Your own OTLP
+  endpoint is always excluded automatically, so the exporter never traces itself.
+- **Why Bun needs this:** Bun's native `fetch` emits no `diagnostics_channel` events, so
+  `@opentelemetry/instrumentation-undici` / `-http` — and `opentelemetry-instrumentation-fetch-node`,
+  which is itself `diagnostics_channel`-based — produce no spans. Wrapping the global is the only
+  mechanism that works, and it behaves identically on Node.
+- **Caveat:** `url.full` includes the query string. If your URLs carry secrets there, use `ignore`
+  or redact upstream.
+
+`setupOtel()` also installs a global W3C trace-context + baggage propagator (previously none was
+registered) — that is what makes the outbound `traceparent` injection, and any manual propagation,
+actually take effect.
 
 ## Running on Node vs Bun
 

package/dist/index.d.ts

@@ -1,9 +1,48 @@
+interface InstrumentFetchOptions {
+    /**
+     * Return `true` to skip instrumenting a request whose absolute URL is passed
+     * in. Useful to drop noisy endpoints or URLs that carry secrets in their
+     * query string. The request is still performed — only the span is skipped.
+     */
+    ignore?: (url: string) => boolean;
+}
+interface FetchInstrumentation {
+    /** Restore the original `globalThis.fetch`. Safe to call more than once. */
+    unpatch(): void;
+}
+/**
+ * Wrap `globalThis.fetch` so every outbound request produces a CLIENT span and
+ * carries W3C trace context to the downstream service.
+ *
+ * On Bun this is the only fetch instrumentation that works: Bun's native fetch
+ * emits no `diagnostics_channel` events, so the standard `instrumentation-undici`
+ * / `instrumentation-http` (and `opentelemetry-instrumentation-fetch-node`,
+ * which is itself diagnostics_channel-based) produce no spans. It works
+ * identically on Node, where `globalThis.fetch` is undici-backed.
+ *
+ * Idempotent: a second call does not stack another wrapper. Returns a handle
+ * whose `unpatch()` restores the original fetch.
+ */
+declare function instrumentFetch(options?: InstrumentFetchOptions): FetchInstrumentation;
+
 type LogAttrs = Record<string, string | number | boolean | undefined>;
+/**
+ * Minimum severity that gets emitted (to both the OTLP record and the console).
+ * `"silent"` suppresses everything, including errors.
+ */
+type LogLevel = "debug" | "info" | "warn" | "error" | "silent";
+/**
+ * Programmatically set the minimum log level. Takes effect immediately for
+ * subsequent logs. `LOG_LEVEL` env var still wins if set.
+ */
+declare function setLogLevel(level: LogLevel): void;
+/** Current effective log level, after env / override / default resolution. */
+declare function getLogLevel(): LogLevel;
 interface PhotonLogger {
-    debug(message: string, attrs?: LogAttrs): void;
+    debug(message: string, attrs?: LogAttrs, error?: unknown): void;
     error(message: string, attrs?: LogAttrs, error?: unknown): void;
-    info(message: string, attrs?: LogAttrs): void;
-    warn(message: string, attrs?: LogAttrs): void;
+    info(message: string, attrs?: LogAttrs, error?: unknown): void;
+    warn(message: string, attrs?: LogAttrs, error?: unknown): void;
 }
 declare function createLogger(module: string): PhotonLogger;
 
@@ -41,6 +80,23 @@ interface SetupOtelOptions {
      * conflicts.
      */
     headers?: Record<string, string>;
+    /**
+     * Auto-instrument outbound `globalThis.fetch` with CLIENT spans and W3C
+     * trace-context propagation. On Bun this is the only fetch instrumentation
+     * that works (diagnostics_channel-based instrumentations emit nothing on
+     * Bun's native fetch); it works identically on Node.
+     *
+     * `true` enables with defaults; pass an object to filter URLs via `ignore`.
+     * Defaults to enabled when a traces endpoint is configured. Pass `false` to
+     * disable.
+     */
+    instrumentFetch?: boolean | InstrumentFetchOptions;
+    /**
+     * Minimum log level emitted by `createLogger()` (to both OTLP and console).
+     * The `LOG_LEVEL` env var still takes precedence. Defaults to `debug` in
+     * development and `info` otherwise.
+     */
+    logLevel?: LogLevel;
     /**
      * Extra resource attributes attached to every span/log alongside
      * `service.name` / `service.version`.
@@ -74,4 +130,4 @@ declare const PHOTON_OTEL_VERSION = "0.1.0";
 declare function withSpan<T>(name: string, fn: () => Promise<T> | T): Promise<T>;
 declare function withSpan<T>(name: string, attrs: LogAttrs, fn: () => Promise<T> | T): Promise<T>;
 
-export { type LogAttrs, type OtelHandle, PHOTON_OTEL_VERSION, type PhotonLogger, type SetupOtelOptions, createLogger, isOtelActive, sanitizeEmail, sanitizeErrorMessage, sanitizePhone, setupOtel, withSpan };
+export { type FetchInstrumentation, type InstrumentFetchOptions, type LogAttrs, type LogLevel, type OtelHandle, PHOTON_OTEL_VERSION, type PhotonLogger, type SetupOtelOptions, createLogger, getLogLevel, instrumentFetch, isOtelActive, sanitizeEmail, sanitizeErrorMessage, sanitizePhone, setLogLevel, setupOtel, withSpan };

package/dist/index.js

@@ -1,11 +1,250 @@
-// src/logger.ts
-import { context as otelContext } from "@opentelemetry/api";
-import { logs, SeverityNumber } from "@opentelemetry/api-logs";
+// src/instrument-fetch.ts
+import {
+  context,
+  propagation,
+  SpanKind,
+  SpanStatusCode,
+  trace
+} from "@opentelemetry/api";
+import {
+  ATTR_ERROR_TYPE,
+  ATTR_HTTP_REQUEST_METHOD,
+  ATTR_HTTP_RESPONSE_STATUS_CODE,
+  ATTR_SERVER_ADDRESS,
+  ATTR_SERVER_PORT,
+  ATTR_URL_FULL
+} from "@opentelemetry/semantic-conventions";
+
+// src/sanitize.ts
+var PHONE_PATTERN = /\+?\d[\d\s()\-.]{6,18}\d/g;
+var EMAIL_PATTERN = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g;
+function sanitizePhone(input) {
+  const hasPlus = input.startsWith("+");
+  const digits = input.replace(/\D/g, "");
+  if (digits.length < 8) {
+    return hasPlus ? "+xxxx" : "xxxx";
+  }
+  const head = digits.slice(0, 3);
+  const tail = digits.slice(-4);
+  const middleLength = digits.length - head.length - tail.length;
+  return `${hasPlus ? "+" : ""}${head}${"x".repeat(middleLength)}${tail}`;
+}
+function sanitizeEmail(input) {
+  const atIndex = input.lastIndexOf("@");
+  if (atIndex < 1) {
+    return "***";
+  }
+  const local = input.slice(0, atIndex);
+  const domain = input.slice(atIndex + 1);
+  const dotIndex = domain.lastIndexOf(".");
+  if (dotIndex < 1) {
+    return "***";
+  }
+  const localHead = local.slice(0, 2);
+  const domainHead = domain.slice(0, 1);
+  const tld = domain.slice(dotIndex);
+  return `${localHead}***@${domainHead}***${tld}`;
+}
+function sanitizeErrorMessage(input) {
+  return input.replace(EMAIL_PATTERN, (match) => sanitizeEmail(match)).replace(PHONE_PATTERN, (match) => sanitizePhone(match));
+}
 
 // src/version.ts
 var PHOTON_OTEL_VERSION = "0.1.0";
 
+// src/instrument-fetch.ts
+var PATCH_MARKER = /* @__PURE__ */ Symbol.for("@photon-ai/otel.fetch.original");
+var HTTP_ERROR_STATUS_MIN = 400;
+var DEFAULT_PORTS = { "https:": 443, "http:": 80 };
+var scopedTracer;
+function getTracer() {
+  if (!scopedTracer) {
+    scopedTracer = trace.getTracer("@photon-ai/otel", PHOTON_OTEL_VERSION);
+  }
+  return scopedTracer;
+}
+function setGlobalFetch(fn) {
+  globalThis.fetch = fn;
+}
+function getPatchOriginal(fn) {
+  return fn[PATCH_MARKER];
+}
+function setPatchOriginal(fn, original) {
+  fn[PATCH_MARKER] = original;
+}
+function preserveProps(from, to) {
+  for (const key of Object.getOwnPropertyNames(from)) {
+    if (key in to) {
+      continue;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(from, key);
+    if (descriptor) {
+      Object.defineProperty(to, key, descriptor);
+    }
+  }
+}
+function resolveRequestMeta(input, init) {
+  if (input instanceof Request) {
+    return { method: input.method, url: input.url };
+  }
+  const url = typeof input === "string" ? input : input.toString();
+  return { method: init?.method ?? "GET", url };
+}
+function resolvePort(parsed) {
+  if (parsed.port) {
+    return Number(parsed.port);
+  }
+  return DEFAULT_PORTS[parsed.protocol];
+}
+function toAttributes(attrs) {
+  const out = {};
+  for (const [key, value] of Object.entries(attrs)) {
+    if (value !== void 0) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function fetchAttributes(method, url) {
+  const attrs = {
+    [ATTR_HTTP_REQUEST_METHOD]: method,
+    [ATTR_URL_FULL]: url
+  };
+  try {
+    const parsed = new URL(url);
+    attrs[ATTR_SERVER_ADDRESS] = parsed.hostname || void 0;
+    attrs[ATTR_SERVER_PORT] = resolvePort(parsed);
+  } catch {
+  }
+  return toAttributes(attrs);
+}
+function buildPropagatedHeaders(input, init) {
+  const headers = new Headers(
+    input instanceof Request ? input.headers : void 0
+  );
+  if (init?.headers) {
+    for (const [key, value] of new Headers(init.headers).entries()) {
+      headers.set(key, value);
+    }
+  }
+  propagation.inject(context.active(), headers, {
+    set: (carrier, key, value) => {
+      carrier.set(key, value);
+    }
+  });
+  return headers;
+}
+function callOriginal(original, input, init, headers) {
+  if (input instanceof Request) {
+    if (input.bodyUsed) {
+      for (const [key, value] of headers.entries()) {
+        input.headers.set(key, value);
+      }
+      return original(input, init);
+    }
+    return original(new Request(input, { ...init, headers }));
+  }
+  return original(input, { ...init, headers });
+}
+function buildWrappedFetch(original, options) {
+  return (input, init) => {
+    const { method, url } = resolveRequestMeta(input, init);
+    if (options?.ignore?.(url)) {
+      return original(input, init);
+    }
+    const name = method.toUpperCase();
+    return getTracer().startActiveSpan(
+      name,
+      { kind: SpanKind.CLIENT },
+      async (span) => {
+        span.setAttributes(fetchAttributes(name, url));
+        try {
+          const headers = buildPropagatedHeaders(input, init);
+          const response = await callOriginal(original, input, init, headers);
+          span.setAttribute(ATTR_HTTP_RESPONSE_STATUS_CODE, response.status);
+          span.setStatus({
+            code: response.status >= HTTP_ERROR_STATUS_MIN ? SpanStatusCode.ERROR : SpanStatusCode.OK
+          });
+          return response;
+        } catch (err) {
+          span.recordException(err);
+          const errorObj = err instanceof Error ? err : void 0;
+          span.setAttribute(
+            ATTR_ERROR_TYPE,
+            errorObj?.constructor.name ?? typeof err
+          );
+          span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: errorObj ? sanitizeErrorMessage(errorObj.message) : sanitizeErrorMessage(String(err))
+          });
+          throw err;
+        } finally {
+          span.end();
+        }
+      }
+    );
+  };
+}
+function instrumentFetch(options) {
+  const current = globalThis.fetch;
+  const existingOriginal = getPatchOriginal(current);
+  if (existingOriginal) {
+    return {
+      unpatch() {
+        if (globalThis.fetch === current) {
+          setGlobalFetch(existingOriginal);
+        }
+      }
+    };
+  }
+  const original = current;
+  const wrapped = buildWrappedFetch(original, options);
+  preserveProps(original, wrapped);
+  setPatchOriginal(wrapped, original);
+  setGlobalFetch(wrapped);
+  return {
+    unpatch() {
+      if (globalThis.fetch === wrapped) {
+        setGlobalFetch(original);
+      }
+    }
+  };
+}
+
 // src/logger.ts
+import { context as otelContext } from "@opentelemetry/api";
+import { logs, SeverityNumber } from "@opentelemetry/api-logs";
+var LEVEL_SEVERITY = {
+  debug: SeverityNumber.DEBUG,
+  // 5
+  info: SeverityNumber.INFO,
+  // 9
+  warn: SeverityNumber.WARN,
+  // 13
+  error: SeverityNumber.ERROR,
+  // 17
+  silent: Number.POSITIVE_INFINITY
+};
+var levelOverride;
+function envLevel() {
+  const raw = process.env.LOG_LEVEL?.toLowerCase();
+  if (raw && raw in LEVEL_SEVERITY) {
+    return raw;
+  }
+  return;
+}
+function defaultLevel() {
+  return (process.env.DEPLOYMENT_ENV ?? "development") === "development" ? "debug" : "info";
+}
+function resolveLevel() {
+  return envLevel() ?? levelOverride ?? defaultLevel();
+}
+function setLogLevel(level) {
+  levelOverride = level;
+}
+function getLogLevel() {
+  return resolveLevel();
+}
 var scopedLogger;
 function getLogger() {
   if (!scopedLogger) {
@@ -25,10 +264,26 @@ function filterUndefined(attrs) {
   }
   return out;
 }
+function consoleFor(severityNumber) {
+  if (severityNumber >= SeverityNumber.ERROR) {
+    return console.error;
+  }
+  if (severityNumber >= SeverityNumber.WARN) {
+    return console.warn;
+  }
+  if (severityNumber >= SeverityNumber.INFO) {
+    return console.info;
+  }
+  return console.debug;
+}
 function emit(severityNumber, severityText, module, message, attrs, error) {
+  if (severityNumber < LEVEL_SEVERITY[resolveLevel()]) {
+    return;
+  }
+  const userAttrs = filterUndefined(attrs);
   const attributes = {
     "log.module": module,
-    ...filterUndefined(attrs)
+    ...userAttrs
   };
   if (error instanceof Error) {
     attributes["exception.type"] = error.name;
@@ -36,6 +291,9 @@ function emit(severityNumber, severityText, module, message, attrs, error) {
     if (error.stack) {
       attributes["exception.stacktrace"] = error.stack;
     }
+  } else if (error !== void 0) {
+    attributes["exception.type"] = typeof error;
+    attributes["exception.message"] = String(error);
   }
   getLogger().emit({
     severityNumber,
@@ -44,60 +302,33 @@ function emit(severityNumber, severityText, module, message, attrs, error) {
     attributes,
     context: otelContext.active()
   });
-  const prefix = `[${module}]`;
-  if (severityNumber >= SeverityNumber.ERROR) {
-    console.error(prefix, message, ...error ? [error] : []);
-  } else {
-    console.log(prefix, message);
+  const extras = [];
+  if (Object.keys(userAttrs).length > 0) {
+    extras.push(userAttrs);
   }
+  if (error !== void 0) {
+    extras.push(error);
+  }
+  consoleFor(severityNumber)(`[${module}]`, severityText, message, ...extras);
 }
 function createLogger(module) {
   return {
-    info: (message, attrs) => emit(SeverityNumber.INFO, "INFO", module, message, attrs),
-    warn: (message, attrs) => emit(SeverityNumber.WARN, "WARN", module, message, attrs),
-    error: (message, attrs, error) => emit(SeverityNumber.ERROR, "ERROR", module, message, attrs, error),
-    debug: (message, attrs) => emit(SeverityNumber.DEBUG, "DEBUG", module, message, attrs)
+    debug: (message, attrs, error) => emit(SeverityNumber.DEBUG, "DEBUG", module, message, attrs, error),
+    info: (message, attrs, error) => emit(SeverityNumber.INFO, "INFO", module, message, attrs, error),
+    warn: (message, attrs, error) => emit(SeverityNumber.WARN, "WARN", module, message, attrs, error),
+    error: (message, attrs, error) => emit(SeverityNumber.ERROR, "ERROR", module, message, attrs, error)
   };
 }
 
-// src/sanitize.ts
-var PHONE_PATTERN = /\+?\d[\d\s()\-.]{6,18}\d/g;
-var EMAIL_PATTERN = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g;
-function sanitizePhone(input) {
-  const hasPlus = input.startsWith("+");
-  const digits = input.replace(/\D/g, "");
-  if (digits.length < 8) {
-    return hasPlus ? "+xxxx" : "xxxx";
-  }
-  const head = digits.slice(0, 3);
-  const tail = digits.slice(-4);
-  const middleLength = digits.length - head.length - tail.length;
-  return `${hasPlus ? "+" : ""}${head}${"x".repeat(middleLength)}${tail}`;
-}
-function sanitizeEmail(input) {
-  const atIndex = input.lastIndexOf("@");
-  if (atIndex < 1) {
-    return "***";
-  }
-  const local = input.slice(0, atIndex);
-  const domain = input.slice(atIndex + 1);
-  const dotIndex = domain.lastIndexOf(".");
-  if (dotIndex < 1) {
-    return "***";
-  }
-  const localHead = local.slice(0, 2);
-  const domainHead = domain.slice(0, 1);
-  const tld = domain.slice(dotIndex);
-  return `${localHead}***@${domainHead}***${tld}`;
-}
-function sanitizeErrorMessage(input) {
-  return input.replace(EMAIL_PATTERN, (match) => sanitizeEmail(match)).replace(PHONE_PATTERN, (match) => sanitizePhone(match));
-}
-
 // src/setup.ts
-import { context, trace } from "@opentelemetry/api";
+import { context as context2, propagation as propagation2, trace as trace2 } from "@opentelemetry/api";
 import { logs as logs2 } from "@opentelemetry/api-logs";
 import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
+import {
+  CompositePropagator,
+  W3CBaggagePropagator,
+  W3CTraceContextPropagator
+} from "@opentelemetry/core";
 import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { resourceFromAttributes } from "@opentelemetry/resources";
@@ -145,10 +376,49 @@ function resolveLogsEndpoint(base) {
   const generic = process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? base;
   return generic ? `${generic.replace(TRAILING_SLASH, "")}/v1/logs` : void 0;
 }
+function otlpEndpointKey(url) {
+  try {
+    const parsed = new URL(url);
+    return `${parsed.origin}${parsed.pathname.replace(TRAILING_SLASH, "")}`;
+  } catch {
+    return;
+  }
+}
+function otlpEndpointKeysOf(tracesEndpoint, logsEndpoint) {
+  const keys = [];
+  for (const endpoint of [tracesEndpoint, logsEndpoint]) {
+    if (!endpoint) {
+      continue;
+    }
+    const key = otlpEndpointKey(endpoint);
+    if (key) {
+      keys.push(key);
+    }
+  }
+  return keys;
+}
+function startFetchInstrumentation(option, hasTraces, tracesEndpoint, logsEndpoint) {
+  const want = option ?? hasTraces;
+  if (!want) {
+    return;
+  }
+  const userOptions = typeof option === "object" ? option : void 0;
+  const otlpEndpointKeys = otlpEndpointKeysOf(tracesEndpoint, logsEndpoint);
+  return instrumentFetch({
+    ignore: (url) => {
+      const key = otlpEndpointKey(url);
+      const isOtlpEndpoint = key !== void 0 && otlpEndpointKeys.includes(key);
+      return isOtlpEndpoint || (userOptions?.ignore?.(url) ?? false);
+    }
+  });
+}
 function setupOtel(options) {
   if (activeHandle) {
     return activeHandle;
   }
+  if (options.logLevel) {
+    setLogLevel(options.logLevel);
+  }
   const tracesEndpoint = resolveTracesEndpoint(options.endpoint);
   const logsEndpoint = resolveLogsEndpoint(options.endpoint);
   const mergedHeaders = {
@@ -162,7 +432,15 @@ function setupOtel(options) {
     "deployment.environment": process.env.DEPLOYMENT_ENV ?? "development",
     ...options.resourceAttributes
   });
-  context.setGlobalContextManager(new AsyncLocalStorageContextManager());
+  context2.setGlobalContextManager(new AsyncLocalStorageContextManager());
+  propagation2.setGlobalPropagator(
+    new CompositePropagator({
+      propagators: [
+        new W3CTraceContextPropagator(),
+        new W3CBaggagePropagator()
+      ]
+    })
+  );
   const traceProcessors = tracesEndpoint ? [
     new BatchSpanProcessor(
       new OTLPTraceExporter({
@@ -175,7 +453,13 @@ function setupOtel(options) {
     resource,
     spanProcessors: traceProcessors
   });
-  trace.setGlobalTracerProvider(tracerProvider);
+  trace2.setGlobalTracerProvider(tracerProvider);
+  const fetchInstrumentation = startFetchInstrumentation(
+    options.instrumentFetch,
+    traceProcessors.length > 0,
+    tracesEndpoint,
+    logsEndpoint
+  );
   const logProcessors = logsEndpoint ? [
     new BatchLogRecordProcessor(
       new OTLPLogExporter({
@@ -191,6 +475,7 @@ function setupOtel(options) {
   logs2.setGlobalLoggerProvider(loggerProvider);
   const handle = {
     async shutdown() {
+      fetchInstrumentation?.unpatch();
       await Promise.allSettled([
         tracerProvider.shutdown(),
         loggerProvider.shutdown()
@@ -207,17 +492,17 @@ function isOtelActive() {
 
 // src/with-span.ts
 import {
-  SpanStatusCode,
-  trace as trace2
+  SpanStatusCode as SpanStatusCode2,
+  trace as trace3
 } from "@opentelemetry/api";
-var scopedTracer;
-function getTracer() {
-  if (!scopedTracer) {
-    scopedTracer = trace2.getTracer("@photon-ai/otel", PHOTON_OTEL_VERSION);
+var scopedTracer2;
+function getTracer2() {
+  if (!scopedTracer2) {
+    scopedTracer2 = trace3.getTracer("@photon-ai/otel", PHOTON_OTEL_VERSION);
   }
-  return scopedTracer;
+  return scopedTracer2;
 }
-function toAttributes(attrs) {
+function toAttributes2(attrs) {
   const out = {};
   for (const [k, v] of Object.entries(attrs)) {
     if (v !== void 0) {
@@ -232,20 +517,20 @@ function withSpan(name, attrsOrFn, maybeFn) {
     throw new Error("withSpan: function argument is required");
   }
   const attrs = typeof attrsOrFn === "function" ? void 0 : attrsOrFn;
-  return getTracer().startActiveSpan(name, async (span) => {
+  return getTracer2().startActiveSpan(name, async (span) => {
     if (attrs) {
-      span.setAttributes(toAttributes(attrs));
+      span.setAttributes(toAttributes2(attrs));
     }
     try {
       const result = await fn();
-      span.setStatus({ code: SpanStatusCode.OK });
+      span.setStatus({ code: SpanStatusCode2.OK });
       return result;
     } catch (err) {
       span.recordException(err);
       const errorObj = err instanceof Error ? err : void 0;
       span.setAttribute("error.type", errorObj?.constructor.name ?? typeof err);
       span.setStatus({
-        code: SpanStatusCode.ERROR,
+        code: SpanStatusCode2.ERROR,
         message: errorObj ? sanitizeErrorMessage(errorObj.message) : sanitizeErrorMessage(String(err))
       });
       throw err;
@@ -257,10 +542,13 @@ function withSpan(name, attrsOrFn, maybeFn) {
 export {
   PHOTON_OTEL_VERSION,
   createLogger,
+  getLogLevel,
+  instrumentFetch,
   isOtelActive,
   sanitizeEmail,
   sanitizeErrorMessage,
   sanitizePhone,
+  setLogLevel,
   setupOtel,
   withSpan
 };

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/logger.ts","../src/version.ts","../src/sanitize.ts","../src/setup.ts","../src/with-span.ts"],"sourcesContent":["import { context as otelContext } from \"@opentelemetry/api\";\nimport { type Logger, logs, SeverityNumber } from \"@opentelemetry/api-logs\";\nimport { PHOTON_OTEL_VERSION } from \"./version\";\n\nexport type LogAttrs = Record<string, string | number | boolean | undefined>;\n\nlet scopedLogger: Logger | undefined;\n\nfunction getLogger(): Logger {\n  if (!scopedLogger) {\n    scopedLogger = logs.getLogger(\"@photon-ai/otel\", PHOTON_OTEL_VERSION);\n  }\n  return scopedLogger;\n}\n\nfunction filterUndefined(\n  attrs?: LogAttrs\n): Record<string, string | number | boolean> {\n  if (!attrs) {\n    return {};\n  }\n  const out: Record<string, string | number | boolean> = {};\n  for (const [k, v] of Object.entries(attrs)) {\n    if (v !== undefined) {\n      out[k] = v;\n    }\n  }\n  return out;\n}\n\nfunction emit(\n  severityNumber: SeverityNumber,\n  severityText: string,\n  module: string,\n  message: string,\n  attrs?: LogAttrs,\n  error?: unknown\n): void {\n  const attributes: Record<string, string | number | boolean> = {\n    \"log.module\": module,\n    ...filterUndefined(attrs),\n  };\n\n  if (error instanceof Error) {\n    attributes[\"exception.type\"] = error.name;\n    attributes[\"exception.message\"] = error.message;\n    if (error.stack) {\n      attributes[\"exception.stacktrace\"] = error.stack;\n    }\n  }\n\n  getLogger().emit({\n    severityNumber,\n    severityText,\n    body: message,\n    attributes,\n    context: otelContext.active(),\n  });\n\n  const prefix = `[${module}]`;\n  if (severityNumber >= SeverityNumber.ERROR) {\n    console.error(prefix, message, ...(error ? [error] : []));\n  } else {\n    console.log(prefix, message);\n  }\n}\n\nexport interface PhotonLogger {\n  debug(message: string, attrs?: LogAttrs): void;\n  error(message: string, attrs?: LogAttrs, error?: unknown): void;\n  info(message: string, attrs?: LogAttrs): void;\n  warn(message: string, attrs?: LogAttrs): void;\n}\n\nexport function createLogger(module: string): PhotonLogger {\n  return {\n    info: (message, attrs) =>\n      emit(SeverityNumber.INFO, \"INFO\", module, message, attrs),\n    warn: (message, attrs) =>\n      emit(SeverityNumber.WARN, \"WARN\", module, message, attrs),\n    error: (message, attrs, error) =>\n      emit(SeverityNumber.ERROR, \"ERROR\", module, message, attrs, error),\n    debug: (message, attrs) =>\n      emit(SeverityNumber.DEBUG, \"DEBUG\", module, message, attrs),\n  };\n}\n","export const PHOTON_OTEL_VERSION = \"0.1.0\";\n","// E.164-ish phone match: optional `+`, 7–15 digits with optional separators.\nconst PHONE_PATTERN = /\\+?\\d[\\d\\s()\\-.]{6,18}\\d/g;\nconst EMAIL_PATTERN = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}/g;\n\n/**\n * Mask a phone number, keeping the leading `+` (if any) plus the first 3 digits\n * and the last 4 digits visible. Example: `+13315553374` -> `+133xxxxx3374`.\n *\n * Inputs that don't have enough digits to safely mask are returned as\n * `xxxx` to avoid leaking the entire short value.\n */\nexport function sanitizePhone(input: string): string {\n  const hasPlus = input.startsWith(\"+\");\n  const digits = input.replace(/\\D/g, \"\");\n  if (digits.length < 8) {\n    return hasPlus ? \"+xxxx\" : \"xxxx\";\n  }\n  const head = digits.slice(0, 3);\n  const tail = digits.slice(-4);\n  const middleLength = digits.length - head.length - tail.length;\n  return `${hasPlus ? \"+\" : \"\"}${head}${\"x\".repeat(middleLength)}${tail}`;\n}\n\n/**\n * Mask an email address, keeping the first 2 chars of the local part, the\n * first char of the domain, and the TLD. Example:\n * `foo.bar@example.com` -> `fo***@e***.com`.\n */\nexport function sanitizeEmail(input: string): string {\n  const atIndex = input.lastIndexOf(\"@\");\n  if (atIndex < 1) {\n    return \"***\";\n  }\n  const local = input.slice(0, atIndex);\n  const domain = input.slice(atIndex + 1);\n  const dotIndex = domain.lastIndexOf(\".\");\n  if (dotIndex < 1) {\n    return \"***\";\n  }\n  const localHead = local.slice(0, 2);\n  const domainHead = domain.slice(0, 1);\n  const tld = domain.slice(dotIndex);\n  return `${localHead}***@${domainHead}***${tld}`;\n}\n\n/**\n * Replace every phone number and email address inside a free-form string with\n * its sanitized form. Used to scrub `Error.message` values before attaching\n * them to span status.\n */\nexport function sanitizeErrorMessage(input: string): string {\n  return input\n    .replace(EMAIL_PATTERN, (match) => sanitizeEmail(match))\n    .replace(PHONE_PATTERN, (match) => sanitizePhone(match));\n}\n","import { context, trace } from \"@opentelemetry/api\";\nimport { logs } from \"@opentelemetry/api-logs\";\nimport { AsyncLocalStorageContextManager } from \"@opentelemetry/context-async-hooks\";\nimport { OTLPLogExporter } from \"@opentelemetry/exporter-logs-otlp-http\";\nimport { OTLPTraceExporter } from \"@opentelemetry/exporter-trace-otlp-http\";\nimport { resourceFromAttributes } from \"@opentelemetry/resources\";\nimport {\n  BatchLogRecordProcessor,\n  LoggerProvider,\n} from \"@opentelemetry/sdk-logs\";\nimport {\n  BasicTracerProvider,\n  BatchSpanProcessor,\n} from \"@opentelemetry/sdk-trace-base\";\n\nexport interface SetupOtelOptions {\n  /**\n   * Default OTLP/HTTP base endpoint (e.g. `https://otel.example.com`). The\n   * `/v1/traces` and `/v1/logs` paths are appended automatically. Standard\n   * `OTEL_EXPORTER_OTLP_*` env vars always take precedence.\n   */\n  endpoint?: string;\n  /**\n   * Default OTLP headers (e.g. `{ Authorization: \"Basic ...\" }`). Merged with\n   * any headers parsed from `OTEL_EXPORTER_OTLP_HEADERS`; env values win on\n   * conflicts.\n   */\n  headers?: Record<string, string>;\n  /**\n   * Extra resource attributes attached to every span/log alongside\n   * `service.name` / `service.version`.\n   */\n  resourceAttributes?: Record<string, string | number | boolean>;\n  serviceName: string;\n  serviceVersion?: string;\n}\n\nexport interface OtelHandle {\n  shutdown(): Promise<void>;\n}\n\nlet activeHandle: OtelHandle | undefined;\n\nconst TRAILING_SLASH = /\\/$/;\n\nfunction parseEnvHeaders(raw: string | undefined): Record<string, string> {\n  if (!raw) {\n    return {};\n  }\n  const out: Record<string, string> = {};\n  for (const pair of raw.split(\",\")) {\n    const eq = pair.indexOf(\"=\");\n    if (eq <= 0) {\n      continue;\n    }\n    const key = pair.slice(0, eq).trim();\n    const value = pair.slice(eq + 1).trim();\n    if (key) {\n      out[key] = value;\n    }\n  }\n  return out;\n}\n\nfunction resolveTracesEndpoint(base: string | undefined): string | undefined {\n  const traces = process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT;\n  if (traces) {\n    return traces;\n  }\n  const generic = process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? base;\n  return generic\n    ? `${generic.replace(TRAILING_SLASH, \"\")}/v1/traces`\n    : undefined;\n}\n\nfunction resolveLogsEndpoint(base: string | undefined): string | undefined {\n  const logsEndpoint = process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT;\n  if (logsEndpoint) {\n    return logsEndpoint;\n  }\n  const generic = process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? base;\n  return generic ? `${generic.replace(TRAILING_SLASH, \"\")}/v1/logs` : undefined;\n}\n\n/**\n * Boot an OTLP/HTTP-based OpenTelemetry pipeline (traces + logs).\n *\n * Idempotent: calling twice in the same process is a no-op on the second\n * call, so libraries can safely invoke this without clobbering an app-level\n * OTel setup that ran earlier.\n *\n * Standard `OTEL_EXPORTER_OTLP_*` env vars override the `endpoint` and\n * `headers` arguments — this matches the OpenTelemetry SDK config spec.\n */\nexport function setupOtel(options: SetupOtelOptions): OtelHandle {\n  if (activeHandle) {\n    return activeHandle;\n  }\n\n  const tracesEndpoint = resolveTracesEndpoint(options.endpoint);\n  const logsEndpoint = resolveLogsEndpoint(options.endpoint);\n  const mergedHeaders = {\n    ...options.headers,\n    ...parseEnvHeaders(process.env.OTEL_EXPORTER_OTLP_HEADERS),\n  };\n  const hasHeaders = Object.keys(mergedHeaders).length > 0;\n\n  const resource = resourceFromAttributes({\n    \"service.name\": options.serviceName,\n    ...(options.serviceVersion\n      ? { \"service.version\": options.serviceVersion }\n      : {}),\n    \"deployment.environment\": process.env.DEPLOYMENT_ENV ?? \"development\",\n    ...options.resourceAttributes,\n  });\n\n  context.setGlobalContextManager(new AsyncLocalStorageContextManager());\n\n  const traceProcessors = tracesEndpoint\n    ? [\n        new BatchSpanProcessor(\n          new OTLPTraceExporter({\n            url: tracesEndpoint,\n            headers: hasHeaders ? mergedHeaders : undefined,\n          })\n        ),\n      ]\n    : [];\n\n  const tracerProvider = new BasicTracerProvider({\n    resource,\n    spanProcessors: traceProcessors,\n  });\n  trace.setGlobalTracerProvider(tracerProvider);\n\n  const logProcessors = logsEndpoint\n    ? [\n        new BatchLogRecordProcessor(\n          new OTLPLogExporter({\n            url: logsEndpoint,\n            headers: hasHeaders ? mergedHeaders : undefined,\n          })\n        ),\n      ]\n    : [];\n\n  const loggerProvider = new LoggerProvider({\n    resource,\n    processors: logProcessors,\n  });\n  logs.setGlobalLoggerProvider(loggerProvider);\n\n  const handle: OtelHandle = {\n    async shutdown() {\n      await Promise.allSettled([\n        tracerProvider.shutdown(),\n        loggerProvider.shutdown(),\n      ]);\n      activeHandle = undefined;\n    },\n  };\n\n  activeHandle = handle;\n  return handle;\n}\n\n/**\n * Read-only accessor for tests / debug paths that need to know whether\n * `setupOtel` has already run in this process.\n */\nexport function isOtelActive(): boolean {\n  return activeHandle !== undefined;\n}\n","import {\n  type Attributes,\n  SpanStatusCode,\n  type Tracer,\n  trace,\n} from \"@opentelemetry/api\";\nimport type { LogAttrs } from \"./logger\";\nimport { sanitizeErrorMessage } from \"./sanitize\";\nimport { PHOTON_OTEL_VERSION } from \"./version\";\n\nlet scopedTracer: Tracer | undefined;\n\nfunction getTracer(): Tracer {\n  if (!scopedTracer) {\n    scopedTracer = trace.getTracer(\"@photon-ai/otel\", PHOTON_OTEL_VERSION);\n  }\n  return scopedTracer;\n}\n\nfunction toAttributes(attrs: LogAttrs): Attributes {\n  const out: Attributes = {};\n  for (const [k, v] of Object.entries(attrs)) {\n    if (v !== undefined) {\n      out[k] = v;\n    }\n  }\n  return out;\n}\n\nexport function withSpan<T>(name: string, fn: () => Promise<T> | T): Promise<T>;\nexport function withSpan<T>(\n  name: string,\n  attrs: LogAttrs,\n  fn: () => Promise<T> | T\n): Promise<T>;\nexport function withSpan<T>(\n  name: string,\n  attrsOrFn: LogAttrs | (() => Promise<T> | T),\n  maybeFn?: () => Promise<T> | T\n): Promise<T> {\n  const fn = typeof attrsOrFn === \"function\" ? attrsOrFn : maybeFn;\n  if (!fn) {\n    throw new Error(\"withSpan: function argument is required\");\n  }\n  const attrs = typeof attrsOrFn === \"function\" ? undefined : attrsOrFn;\n\n  return getTracer().startActiveSpan(name, async (span) => {\n    if (attrs) {\n      span.setAttributes(toAttributes(attrs));\n    }\n    try {\n      const result = await fn();\n      span.setStatus({ code: SpanStatusCode.OK });\n      return result;\n    } catch (err) {\n      span.recordException(err as Error);\n      const errorObj = err instanceof Error ? err : undefined;\n      span.setAttribute(\"error.type\", errorObj?.constructor.name ?? typeof err);\n      span.setStatus({\n        code: SpanStatusCode.ERROR,\n        message: errorObj\n          ? sanitizeErrorMessage(errorObj.message)\n          : sanitizeErrorMessage(String(err)),\n      });\n      throw err;\n    } finally {\n      span.end();\n    }\n  });\n}\n"],"mappings":"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","names":["logs","trace","trace"]}
+{"version":3,"sources":["../src/instrument-fetch.ts","../src/sanitize.ts","../src/version.ts","../src/logger.ts","../src/setup.ts","../src/with-span.ts"],"sourcesContent":["import {\n  type Attributes,\n  context,\n  propagation,\n  SpanKind,\n  SpanStatusCode,\n  type Tracer,\n  trace,\n} from \"@opentelemetry/api\";\nimport {\n  ATTR_ERROR_TYPE,\n  ATTR_HTTP_REQUEST_METHOD,\n  ATTR_HTTP_RESPONSE_STATUS_CODE,\n  ATTR_SERVER_ADDRESS,\n  ATTR_SERVER_PORT,\n  ATTR_URL_FULL,\n} from \"@opentelemetry/semantic-conventions\";\nimport { sanitizeErrorMessage } from \"./sanitize\";\nimport { PHOTON_OTEL_VERSION } from \"./version\";\n\nexport interface InstrumentFetchOptions {\n  /**\n   * Return `true` to skip instrumenting a request whose absolute URL is passed\n   * in. Useful to drop noisy endpoints or URLs that carry secrets in their\n   * query string. The request is still performed — only the span is skipped.\n   */\n  ignore?: (url: string) => boolean;\n}\n\nexport interface FetchInstrumentation {\n  /** Restore the original `globalThis.fetch`. Safe to call more than once. */\n  unpatch(): void;\n}\n\ntype FetchInput = Parameters<typeof fetch>[0];\ntype FetchInit = Parameters<typeof fetch>[1];\ntype FetchFn = (input: FetchInput, init?: FetchInit) => Promise<Response>;\n\n/**\n * Stored on the wrapper via the global symbol registry (`Symbol.for`) so the\n * double-wrap guard holds even when two copies of this module load — which can\n * happen because the `bun` export condition serves `src/` while `default`\n * serves `dist/`.\n */\nconst PATCH_MARKER = Symbol.for(\"@photon-ai/otel.fetch.original\");\n\nconst HTTP_ERROR_STATUS_MIN = 400;\nconst DEFAULT_PORTS: Record<string, number> = { \"https:\": 443, \"http:\": 80 };\n\nlet scopedTracer: Tracer | undefined;\n\nfunction getTracer(): Tracer {\n  if (!scopedTracer) {\n    scopedTracer = trace.getTracer(\"@photon-ai/otel\", PHOTON_OTEL_VERSION);\n  }\n  return scopedTracer;\n}\n\nfunction setGlobalFetch(fn: FetchFn): void {\n  // `preconnect` (Bun) is copied onto wrappers by preserveProps; the cast just\n  // tells TypeScript the runtime object satisfies the full `fetch` type.\n  globalThis.fetch = fn as typeof fetch;\n}\n\nfunction getPatchOriginal(fn: FetchFn): FetchFn | undefined {\n  return (fn as unknown as Record<symbol, FetchFn | undefined>)[PATCH_MARKER];\n}\n\nfunction setPatchOriginal(fn: FetchFn, original: FetchFn): void {\n  (fn as unknown as Record<symbol, FetchFn>)[PATCH_MARKER] = original;\n}\n\n/** Copy extra own properties (e.g. Bun's `fetch.preconnect`) onto the wrapper. */\nfunction preserveProps(from: FetchFn, to: FetchFn): void {\n  for (const key of Object.getOwnPropertyNames(from)) {\n    if (key in to) {\n      continue;\n    }\n    const descriptor = Object.getOwnPropertyDescriptor(from, key);\n    if (descriptor) {\n      Object.defineProperty(to, key, descriptor);\n    }\n  }\n}\n\nfunction resolveRequestMeta(\n  input: FetchInput,\n  init: FetchInit\n): { method: string; url: string } {\n  if (input instanceof Request) {\n    return { method: input.method, url: input.url };\n  }\n  const url = typeof input === \"string\" ? input : input.toString();\n  return { method: init?.method ?? \"GET\", url };\n}\n\nfunction resolvePort(parsed: URL): number | undefined {\n  if (parsed.port) {\n    return Number(parsed.port);\n  }\n  return DEFAULT_PORTS[parsed.protocol];\n}\n\nfunction toAttributes(attrs: Attributes): Attributes {\n  const out: Attributes = {};\n  for (const [key, value] of Object.entries(attrs)) {\n    if (value !== undefined) {\n      out[key] = value;\n    }\n  }\n  return out;\n}\n\nfunction fetchAttributes(method: string, url: string): Attributes {\n  const attrs: Attributes = {\n    [ATTR_HTTP_REQUEST_METHOD]: method,\n    [ATTR_URL_FULL]: url,\n  };\n  try {\n    const parsed = new URL(url);\n    attrs[ATTR_SERVER_ADDRESS] = parsed.hostname || undefined;\n    attrs[ATTR_SERVER_PORT] = resolvePort(parsed);\n  } catch {\n    // Unparseable URL: leave server.* unset rather than failing the request.\n  }\n  return toAttributes(attrs);\n}\n\n/** Build the outgoing headers and inject the active trace context into them. */\nfunction buildPropagatedHeaders(input: FetchInput, init: FetchInit): Headers {\n  const headers = new Headers(\n    input instanceof Request ? input.headers : undefined\n  );\n  if (init?.headers) {\n    for (const [key, value] of new Headers(init.headers).entries()) {\n      headers.set(key, value);\n    }\n  }\n  propagation.inject(context.active(), headers, {\n    set: (carrier, key, value) => {\n      carrier.set(key, value);\n    },\n  });\n  return headers;\n}\n\nfunction callOriginal(\n  original: FetchFn,\n  input: FetchInput,\n  init: FetchInit,\n  headers: Headers\n): Promise<Response> {\n  if (input instanceof Request) {\n    // A consumed Request's body can't be rebuilt, but its headers stay mutable\n    // (verified on both Bun and Node) — inject the propagated context in place\n    // so trace headers still flow without reconstructing the unusable Request.\n    if (input.bodyUsed) {\n      for (const [key, value] of headers.entries()) {\n        input.headers.set(key, value);\n      }\n      return original(input, init);\n    }\n    return original(new Request(input, { ...init, headers }));\n  }\n  return original(input, { ...init, headers });\n}\n\nfunction buildWrappedFetch(\n  original: FetchFn,\n  options?: InstrumentFetchOptions\n): FetchFn {\n  return (input, init) => {\n    const { method, url } = resolveRequestMeta(input, init);\n    if (options?.ignore?.(url)) {\n      return original(input, init);\n    }\n    const name = method.toUpperCase();\n    return getTracer().startActiveSpan(\n      name,\n      { kind: SpanKind.CLIENT },\n      async (span) => {\n        span.setAttributes(fetchAttributes(name, url));\n        try {\n          const headers = buildPropagatedHeaders(input, init);\n          const response = await callOriginal(original, input, init, headers);\n          span.setAttribute(ATTR_HTTP_RESPONSE_STATUS_CODE, response.status);\n          span.setStatus({\n            code:\n              response.status >= HTTP_ERROR_STATUS_MIN\n                ? SpanStatusCode.ERROR\n                : SpanStatusCode.OK,\n          });\n          return response;\n        } catch (err) {\n          span.recordException(err as Error);\n          const errorObj = err instanceof Error ? err : undefined;\n          span.setAttribute(\n            ATTR_ERROR_TYPE,\n            errorObj?.constructor.name ?? typeof err\n          );\n          span.setStatus({\n            code: SpanStatusCode.ERROR,\n            message: errorObj\n              ? sanitizeErrorMessage(errorObj.message)\n              : sanitizeErrorMessage(String(err)),\n          });\n          throw err;\n        } finally {\n          span.end();\n        }\n      }\n    );\n  };\n}\n\n/**\n * Wrap `globalThis.fetch` so every outbound request produces a CLIENT span and\n * carries W3C trace context to the downstream service.\n *\n * On Bun this is the only fetch instrumentation that works: Bun's native fetch\n * emits no `diagnostics_channel` events, so the standard `instrumentation-undici`\n * / `instrumentation-http` (and `opentelemetry-instrumentation-fetch-node`,\n * which is itself diagnostics_channel-based) produce no spans. It works\n * identically on Node, where `globalThis.fetch` is undici-backed.\n *\n * Idempotent: a second call does not stack another wrapper. Returns a handle\n * whose `unpatch()` restores the original fetch.\n */\nexport function instrumentFetch(\n  options?: InstrumentFetchOptions\n): FetchInstrumentation {\n  const current: FetchFn = globalThis.fetch;\n  const existingOriginal = getPatchOriginal(current);\n  if (existingOriginal) {\n    return {\n      unpatch() {\n        if (globalThis.fetch === current) {\n          setGlobalFetch(existingOriginal);\n        }\n      },\n    };\n  }\n\n  const original = current;\n  const wrapped = buildWrappedFetch(original, options);\n  preserveProps(original, wrapped);\n  setPatchOriginal(wrapped, original);\n  setGlobalFetch(wrapped);\n\n  return {\n    unpatch() {\n      if (globalThis.fetch === wrapped) {\n        setGlobalFetch(original);\n      }\n    },\n  };\n}\n","// E.164-ish phone match: optional `+`, 7–15 digits with optional separators.\nconst PHONE_PATTERN = /\\+?\\d[\\d\\s()\\-.]{6,18}\\d/g;\nconst EMAIL_PATTERN = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}/g;\n\n/**\n * Mask a phone number, keeping the leading `+` (if any) plus the first 3 digits\n * and the last 4 digits visible. Example: `+13315553374` -> `+133xxxxx3374`.\n *\n * Inputs that don't have enough digits to safely mask are returned as\n * `xxxx` to avoid leaking the entire short value.\n */\nexport function sanitizePhone(input: string): string {\n  const hasPlus = input.startsWith(\"+\");\n  const digits = input.replace(/\\D/g, \"\");\n  if (digits.length < 8) {\n    return hasPlus ? \"+xxxx\" : \"xxxx\";\n  }\n  const head = digits.slice(0, 3);\n  const tail = digits.slice(-4);\n  const middleLength = digits.length - head.length - tail.length;\n  return `${hasPlus ? \"+\" : \"\"}${head}${\"x\".repeat(middleLength)}${tail}`;\n}\n\n/**\n * Mask an email address, keeping the first 2 chars of the local part, the\n * first char of the domain, and the TLD. Example:\n * `foo.bar@example.com` -> `fo***@e***.com`.\n */\nexport function sanitizeEmail(input: string): string {\n  const atIndex = input.lastIndexOf(\"@\");\n  if (atIndex < 1) {\n    return \"***\";\n  }\n  const local = input.slice(0, atIndex);\n  const domain = input.slice(atIndex + 1);\n  const dotIndex = domain.lastIndexOf(\".\");\n  if (dotIndex < 1) {\n    return \"***\";\n  }\n  const localHead = local.slice(0, 2);\n  const domainHead = domain.slice(0, 1);\n  const tld = domain.slice(dotIndex);\n  return `${localHead}***@${domainHead}***${tld}`;\n}\n\n/**\n * Replace every phone number and email address inside a free-form string with\n * its sanitized form. Used to scrub `Error.message` values before attaching\n * them to span status.\n */\nexport function sanitizeErrorMessage(input: string): string {\n  return input\n    .replace(EMAIL_PATTERN, (match) => sanitizeEmail(match))\n    .replace(PHONE_PATTERN, (match) => sanitizePhone(match));\n}\n","export const PHOTON_OTEL_VERSION = \"0.1.0\";\n","import { context as otelContext } from \"@opentelemetry/api\";\nimport { type Logger, logs, SeverityNumber } from \"@opentelemetry/api-logs\";\nimport { PHOTON_OTEL_VERSION } from \"./version\";\n\nexport type LogAttrs = Record<string, string | number | boolean | undefined>;\n\n/**\n * Minimum severity that gets emitted (to both the OTLP record and the console).\n * `\"silent\"` suppresses everything, including errors.\n */\nexport type LogLevel = \"debug\" | \"info\" | \"warn\" | \"error\" | \"silent\";\n\nconst LEVEL_SEVERITY: Record<LogLevel, number> = {\n  debug: SeverityNumber.DEBUG, // 5\n  info: SeverityNumber.INFO, // 9\n  warn: SeverityNumber.WARN, // 13\n  error: SeverityNumber.ERROR, // 17\n  silent: Number.POSITIVE_INFINITY,\n};\n\nlet levelOverride: LogLevel | undefined;\n\nfunction envLevel(): LogLevel | undefined {\n  const raw = process.env.LOG_LEVEL?.toLowerCase();\n  if (raw && raw in LEVEL_SEVERITY) {\n    return raw as LogLevel;\n  }\n  return;\n}\n\nfunction defaultLevel(): LogLevel {\n  return (process.env.DEPLOYMENT_ENV ?? \"development\") === \"development\"\n    ? \"debug\"\n    : \"info\";\n}\n\n/**\n * Resolve the active level fresh on each call so that `LOG_LEVEL` changes and\n * `setLogLevel()` both take effect immediately. Resolution order (env wins, to\n * match the rest of the package's config story):\n *   1. `LOG_LEVEL` env var\n *   2. `setLogLevel()` / `setupOtel({ logLevel })`\n *   3. environment-driven default (`debug` in development, `info` otherwise)\n */\nfunction resolveLevel(): LogLevel {\n  return envLevel() ?? levelOverride ?? defaultLevel();\n}\n\n/**\n * Programmatically set the minimum log level. Takes effect immediately for\n * subsequent logs. `LOG_LEVEL` env var still wins if set.\n */\nexport function setLogLevel(level: LogLevel): void {\n  levelOverride = level;\n}\n\n/** Current effective log level, after env / override / default resolution. */\nexport function getLogLevel(): LogLevel {\n  return resolveLevel();\n}\n\nlet scopedLogger: Logger | undefined;\n\nfunction getLogger(): Logger {\n  if (!scopedLogger) {\n    scopedLogger = logs.getLogger(\"@photon-ai/otel\", PHOTON_OTEL_VERSION);\n  }\n  return scopedLogger;\n}\n\nfunction filterUndefined(\n  attrs?: LogAttrs\n): Record<string, string | number | boolean> {\n  if (!attrs) {\n    return {};\n  }\n  const out: Record<string, string | number | boolean> = {};\n  for (const [k, v] of Object.entries(attrs)) {\n    if (v !== undefined) {\n      out[k] = v;\n    }\n  }\n  return out;\n}\n\nfunction consoleFor(\n  severityNumber: SeverityNumber\n): (...args: unknown[]) => void {\n  if (severityNumber >= SeverityNumber.ERROR) {\n    return console.error;\n  }\n  if (severityNumber >= SeverityNumber.WARN) {\n    return console.warn;\n  }\n  if (severityNumber >= SeverityNumber.INFO) {\n    return console.info;\n  }\n  return console.debug;\n}\n\nfunction emit(\n  severityNumber: SeverityNumber,\n  severityText: string,\n  module: string,\n  message: string,\n  attrs?: LogAttrs,\n  error?: unknown\n): void {\n  // Single gate: drop sub-threshold logs before they reach OTLP or the console.\n  if (severityNumber < LEVEL_SEVERITY[resolveLevel()]) {\n    return;\n  }\n\n  const userAttrs = filterUndefined(attrs);\n  const attributes: Record<string, string | number | boolean> = {\n    \"log.module\": module,\n    ...userAttrs,\n  };\n\n  if (error instanceof Error) {\n    attributes[\"exception.type\"] = error.name;\n    attributes[\"exception.message\"] = error.message;\n    if (error.stack) {\n      attributes[\"exception.stacktrace\"] = error.stack;\n    }\n  } else if (error !== undefined) {\n    // Don't silently drop non-Error throws (strings, plain objects, etc.).\n    attributes[\"exception.type\"] = typeof error;\n    attributes[\"exception.message\"] = String(error);\n  }\n\n  getLogger().emit({\n    severityNumber,\n    severityText,\n    body: message,\n    attributes,\n    context: otelContext.active(),\n  });\n\n  // Console: `[module] LEVEL message { ...attrs }` plus the raw error so the\n  // runtime renders the full stack and pretty-prints the attribute bag.\n  const extras: unknown[] = [];\n  if (Object.keys(userAttrs).length > 0) {\n    extras.push(userAttrs);\n  }\n  if (error !== undefined) {\n    extras.push(error);\n  }\n  consoleFor(severityNumber)(`[${module}]`, severityText, message, ...extras);\n}\n\nexport interface PhotonLogger {\n  debug(message: string, attrs?: LogAttrs, error?: unknown): void;\n  error(message: string, attrs?: LogAttrs, error?: unknown): void;\n  info(message: string, attrs?: LogAttrs, error?: unknown): void;\n  warn(message: string, attrs?: LogAttrs, error?: unknown): void;\n}\n\nexport function createLogger(module: string): PhotonLogger {\n  return {\n    debug: (message, attrs, error) =>\n      emit(SeverityNumber.DEBUG, \"DEBUG\", module, message, attrs, error),\n    info: (message, attrs, error) =>\n      emit(SeverityNumber.INFO, \"INFO\", module, message, attrs, error),\n    warn: (message, attrs, error) =>\n      emit(SeverityNumber.WARN, \"WARN\", module, message, attrs, error),\n    error: (message, attrs, error) =>\n      emit(SeverityNumber.ERROR, \"ERROR\", module, message, attrs, error),\n  };\n}\n","import { context, propagation, trace } from \"@opentelemetry/api\";\nimport { logs } from \"@opentelemetry/api-logs\";\nimport { AsyncLocalStorageContextManager } from \"@opentelemetry/context-async-hooks\";\nimport {\n  CompositePropagator,\n  W3CBaggagePropagator,\n  W3CTraceContextPropagator,\n} from \"@opentelemetry/core\";\nimport { OTLPLogExporter } from \"@opentelemetry/exporter-logs-otlp-http\";\nimport { OTLPTraceExporter } from \"@opentelemetry/exporter-trace-otlp-http\";\nimport { resourceFromAttributes } from \"@opentelemetry/resources\";\nimport {\n  BatchLogRecordProcessor,\n  LoggerProvider,\n} from \"@opentelemetry/sdk-logs\";\nimport {\n  BasicTracerProvider,\n  BatchSpanProcessor,\n} from \"@opentelemetry/sdk-trace-base\";\nimport {\n  type FetchInstrumentation,\n  type InstrumentFetchOptions,\n  instrumentFetch,\n} from \"./instrument-fetch\";\nimport { type LogLevel, setLogLevel } from \"./logger\";\n\nexport interface SetupOtelOptions {\n  /**\n   * Default OTLP/HTTP base endpoint (e.g. `https://otel.example.com`). The\n   * `/v1/traces` and `/v1/logs` paths are appended automatically. Standard\n   * `OTEL_EXPORTER_OTLP_*` env vars always take precedence.\n   */\n  endpoint?: string;\n  /**\n   * Default OTLP headers (e.g. `{ Authorization: \"Basic ...\" }`). Merged with\n   * any headers parsed from `OTEL_EXPORTER_OTLP_HEADERS`; env values win on\n   * conflicts.\n   */\n  headers?: Record<string, string>;\n  /**\n   * Auto-instrument outbound `globalThis.fetch` with CLIENT spans and W3C\n   * trace-context propagation. On Bun this is the only fetch instrumentation\n   * that works (diagnostics_channel-based instrumentations emit nothing on\n   * Bun's native fetch); it works identically on Node.\n   *\n   * `true` enables with defaults; pass an object to filter URLs via `ignore`.\n   * Defaults to enabled when a traces endpoint is configured. Pass `false` to\n   * disable.\n   */\n  instrumentFetch?: boolean | InstrumentFetchOptions;\n  /**\n   * Minimum log level emitted by `createLogger()` (to both OTLP and console).\n   * The `LOG_LEVEL` env var still takes precedence. Defaults to `debug` in\n   * development and `info` otherwise.\n   */\n  logLevel?: LogLevel;\n  /**\n   * Extra resource attributes attached to every span/log alongside\n   * `service.name` / `service.version`.\n   */\n  resourceAttributes?: Record<string, string | number | boolean>;\n  serviceName: string;\n  serviceVersion?: string;\n}\n\nexport interface OtelHandle {\n  shutdown(): Promise<void>;\n}\n\nlet activeHandle: OtelHandle | undefined;\n\nconst TRAILING_SLASH = /\\/$/;\n\nfunction parseEnvHeaders(raw: string | undefined): Record<string, string> {\n  if (!raw) {\n    return {};\n  }\n  const out: Record<string, string> = {};\n  for (const pair of raw.split(\",\")) {\n    const eq = pair.indexOf(\"=\");\n    if (eq <= 0) {\n      continue;\n    }\n    const key = pair.slice(0, eq).trim();\n    const value = pair.slice(eq + 1).trim();\n    if (key) {\n      out[key] = value;\n    }\n  }\n  return out;\n}\n\nfunction resolveTracesEndpoint(base: string | undefined): string | undefined {\n  const traces = process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT;\n  if (traces) {\n    return traces;\n  }\n  const generic = process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? base;\n  return generic\n    ? `${generic.replace(TRAILING_SLASH, \"\")}/v1/traces`\n    : undefined;\n}\n\nfunction resolveLogsEndpoint(base: string | undefined): string | undefined {\n  const logsEndpoint = process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT;\n  if (logsEndpoint) {\n    return logsEndpoint;\n  }\n  const generic = process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? base;\n  return generic ? `${generic.replace(TRAILING_SLASH, \"\")}/v1/logs` : undefined;\n}\n\n/**\n * Normalize a URL to an `origin + path` key (trailing slash stripped) for exact\n * self-trace matching. Returns `undefined` for unparseable URLs.\n */\nfunction otlpEndpointKey(url: string): string | undefined {\n  try {\n    const parsed = new URL(url);\n    return `${parsed.origin}${parsed.pathname.replace(TRAILING_SLASH, \"\")}`;\n  } catch {\n    return;\n  }\n}\n\nfunction otlpEndpointKeysOf(\n  tracesEndpoint: string | undefined,\n  logsEndpoint: string | undefined\n): string[] {\n  const keys: string[] = [];\n  for (const endpoint of [tracesEndpoint, logsEndpoint]) {\n    if (!endpoint) {\n      continue;\n    }\n    const key = otlpEndpointKey(endpoint);\n    if (key) {\n      keys.push(key);\n    }\n  }\n  return keys;\n}\n\n/**\n * Patch `globalThis.fetch` unless disabled. Defaults to on when a traces\n * pipeline is configured. Always excludes our own OTLP endpoints so the\n * exporter's traffic is never self-traced (matters on Node, where the OTLP\n * exporter can use fetch).\n */\nfunction startFetchInstrumentation(\n  option: boolean | InstrumentFetchOptions | undefined,\n  hasTraces: boolean,\n  tracesEndpoint: string | undefined,\n  logsEndpoint: string | undefined\n): FetchInstrumentation | undefined {\n  const want = option ?? hasTraces;\n  if (!want) {\n    return;\n  }\n  const userOptions = typeof option === \"object\" ? option : undefined;\n  const otlpEndpointKeys = otlpEndpointKeysOf(tracesEndpoint, logsEndpoint);\n  return instrumentFetch({\n    ignore: (url) => {\n      const key = otlpEndpointKey(url);\n      const isOtlpEndpoint =\n        key !== undefined && otlpEndpointKeys.includes(key);\n      return isOtlpEndpoint || (userOptions?.ignore?.(url) ?? false);\n    },\n  });\n}\n\n/**\n * Boot an OTLP/HTTP-based OpenTelemetry pipeline (traces + logs).\n *\n * Idempotent: calling twice in the same process is a no-op on the second\n * call, so libraries can safely invoke this without clobbering an app-level\n * OTel setup that ran earlier.\n *\n * Standard `OTEL_EXPORTER_OTLP_*` env vars override the `endpoint` and\n * `headers` arguments — this matches the OpenTelemetry SDK config spec.\n */\nexport function setupOtel(options: SetupOtelOptions): OtelHandle {\n  if (activeHandle) {\n    return activeHandle;\n  }\n\n  if (options.logLevel) {\n    setLogLevel(options.logLevel);\n  }\n\n  const tracesEndpoint = resolveTracesEndpoint(options.endpoint);\n  const logsEndpoint = resolveLogsEndpoint(options.endpoint);\n  const mergedHeaders = {\n    ...options.headers,\n    ...parseEnvHeaders(process.env.OTEL_EXPORTER_OTLP_HEADERS),\n  };\n  const hasHeaders = Object.keys(mergedHeaders).length > 0;\n\n  const resource = resourceFromAttributes({\n    \"service.name\": options.serviceName,\n    ...(options.serviceVersion\n      ? { \"service.version\": options.serviceVersion }\n      : {}),\n    \"deployment.environment\": process.env.DEPLOYMENT_ENV ?? \"development\",\n    ...options.resourceAttributes,\n  });\n\n  context.setGlobalContextManager(new AsyncLocalStorageContextManager());\n  propagation.setGlobalPropagator(\n    new CompositePropagator({\n      propagators: [\n        new W3CTraceContextPropagator(),\n        new W3CBaggagePropagator(),\n      ],\n    })\n  );\n\n  const traceProcessors = tracesEndpoint\n    ? [\n        new BatchSpanProcessor(\n          new OTLPTraceExporter({\n            url: tracesEndpoint,\n            headers: hasHeaders ? mergedHeaders : undefined,\n          })\n        ),\n      ]\n    : [];\n\n  const tracerProvider = new BasicTracerProvider({\n    resource,\n    spanProcessors: traceProcessors,\n  });\n  trace.setGlobalTracerProvider(tracerProvider);\n\n  const fetchInstrumentation = startFetchInstrumentation(\n    options.instrumentFetch,\n    traceProcessors.length > 0,\n    tracesEndpoint,\n    logsEndpoint\n  );\n\n  const logProcessors = logsEndpoint\n    ? [\n        new BatchLogRecordProcessor(\n          new OTLPLogExporter({\n            url: logsEndpoint,\n            headers: hasHeaders ? mergedHeaders : undefined,\n          })\n        ),\n      ]\n    : [];\n\n  const loggerProvider = new LoggerProvider({\n    resource,\n    processors: logProcessors,\n  });\n  logs.setGlobalLoggerProvider(loggerProvider);\n\n  const handle: OtelHandle = {\n    async shutdown() {\n      fetchInstrumentation?.unpatch();\n      await Promise.allSettled([\n        tracerProvider.shutdown(),\n        loggerProvider.shutdown(),\n      ]);\n      activeHandle = undefined;\n    },\n  };\n\n  activeHandle = handle;\n  return handle;\n}\n\n/**\n * Read-only accessor for tests / debug paths that need to know whether\n * `setupOtel` has already run in this process.\n */\nexport function isOtelActive(): boolean {\n  return activeHandle !== undefined;\n}\n","import {\n  type Attributes,\n  SpanStatusCode,\n  type Tracer,\n  trace,\n} from \"@opentelemetry/api\";\nimport type { LogAttrs } from \"./logger\";\nimport { sanitizeErrorMessage } from \"./sanitize\";\nimport { PHOTON_OTEL_VERSION } from \"./version\";\n\nlet scopedTracer: Tracer | undefined;\n\nfunction getTracer(): Tracer {\n  if (!scopedTracer) {\n    scopedTracer = trace.getTracer(\"@photon-ai/otel\", PHOTON_OTEL_VERSION);\n  }\n  return scopedTracer;\n}\n\nfunction toAttributes(attrs: LogAttrs): Attributes {\n  const out: Attributes = {};\n  for (const [k, v] of Object.entries(attrs)) {\n    if (v !== undefined) {\n      out[k] = v;\n    }\n  }\n  return out;\n}\n\nexport function withSpan<T>(name: string, fn: () => Promise<T> | T): Promise<T>;\nexport function withSpan<T>(\n  name: string,\n  attrs: LogAttrs,\n  fn: () => Promise<T> | T\n): Promise<T>;\nexport function withSpan<T>(\n  name: string,\n  attrsOrFn: LogAttrs | (() => Promise<T> | T),\n  maybeFn?: () => Promise<T> | T\n): Promise<T> {\n  const fn = typeof attrsOrFn === \"function\" ? attrsOrFn : maybeFn;\n  if (!fn) {\n    throw new Error(\"withSpan: function argument is required\");\n  }\n  const attrs = typeof attrsOrFn === \"function\" ? undefined : attrsOrFn;\n\n  return getTracer().startActiveSpan(name, async (span) => {\n    if (attrs) {\n      span.setAttributes(toAttributes(attrs));\n    }\n    try {\n      const result = await fn();\n      span.setStatus({ code: SpanStatusCode.OK });\n      return result;\n    } catch (err) {\n      span.recordException(err as Error);\n      const errorObj = err instanceof Error ? err : undefined;\n      span.setAttribute(\"error.type\", errorObj?.constructor.name ?? typeof err);\n      span.setStatus({\n        code: SpanStatusCode.ERROR,\n        message: errorObj\n          ? sanitizeErrorMessage(errorObj.message)\n          : sanitizeErrorMessage(String(err)),\n      });\n      throw err;\n    } finally {\n      span.end();\n    }\n  });\n}\n"],"mappings":"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","names":["context","propagation","trace","logs","context","propagation","trace","logs","SpanStatusCode","trace","scopedTracer","getTracer","trace","toAttributes","SpanStatusCode"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@photon-ai/otel",
-  "version": "0.1.2",
+  "version": "1.1.0",
   "description": "DX-focused OpenTelemetry wrapper for Bun and Node.js: one-call setup, structured logging, span helper, and built-in PII scrubbing.",
   "type": "module",
   "main": "./dist/index.js",
@@ -20,11 +20,13 @@
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/api-logs": "^0.218.0",
     "@opentelemetry/context-async-hooks": "^2.7.1",
+    "@opentelemetry/core": "^2.7.1",
     "@opentelemetry/exporter-logs-otlp-http": "^0.218.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.218.0",
     "@opentelemetry/resources": "^2.7.1",
     "@opentelemetry/sdk-logs": "^0.218.0",
-    "@opentelemetry/sdk-trace-base": "^2.7.1"
+    "@opentelemetry/sdk-trace-base": "^2.7.1",
+    "@opentelemetry/semantic-conventions": "^1.41.1"
   },
   "peerDependencies": {
     "typescript": "^5 || ^6.0.0"