autotel-cloudflare 18.0.0 → 18.2.0

package/dist/{handlers-BRfAgfP7.d.ts → handlers-CEAD5hVy.d.ts}

@@ -1,5 +1,7 @@
 import { ConfigurationOption } from "autotel-edge";
 //#region src/handlers/durable-objects.d.ts
+/** `exception.type` of the alarm-loop signal. */
+declare const RUNAWAY_ALARM_EXCEPTION = "autotel.RunawayAlarm";
 /**
  * Instrument a Durable Object class
  *
@@ -91,4 +93,4 @@ declare function instrumentDO<C extends new (...args: any[]) => any>(doClass: C,
  */
 declare function instrumentWorkflow<C extends new (...args: any[]) => any>(workflowClass: C, workflowName: string, config: ConfigurationOption): C;
 //#endregion
-export { instrumentDO as n, instrumentWorkflow as t };
+export { RUNAWAY_ALARM_EXCEPTION as n, instrumentDO as r, instrumentWorkflow as t };

package/dist/handlers.d.ts

@@ -1,2 +1,2 @@
-import { n as instrumentDO, t as instrumentWorkflow } from "./handlers-BRfAgfP7.js";
-export { instrumentDO, instrumentWorkflow };
+import { n as RUNAWAY_ALARM_EXCEPTION, r as instrumentDO, t as instrumentWorkflow } from "./handlers-CEAD5hVy.js";
+export { RUNAWAY_ALARM_EXCEPTION, instrumentDO, instrumentWorkflow };

package/dist/handlers.js

@@ -1,3 +1,3 @@
-import { n as instrumentDO, t as instrumentWorkflow } from "./handlers-4X_6aEtg.js";
+import { n as RUNAWAY_ALARM_EXCEPTION, r as instrumentDO, t as instrumentWorkflow } from "./handlers-7NFDRZT2.js";
 
-export { instrumentDO, instrumentWorkflow };
+export { RUNAWAY_ALARM_EXCEPTION, instrumentDO, instrumentWorkflow };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { a as instrumentQueueProducer, c as instrumentAI, d as instrumentKV, f as instrumentR2, i as instrumentAnalyticsEngine, l as instrumentBindings, n as instrumentRateLimiter, o as instrumentHyperdrive, p as instrumentServiceBinding, r as instrumentImages, s as instrumentVectorize, t as instrumentBrowserRendering, u as instrumentD1 } from "./bindings-BcSPZDWF.js";
-import { n as instrumentDO, t as instrumentWorkflow } from "./handlers-BRfAgfP7.js";
+import { n as RUNAWAY_ALARM_EXCEPTION, r as instrumentDO, t as instrumentWorkflow } from "./handlers-CEAD5hVy.js";
 import { a as createWorkersLogger, c as getRequestLogger, i as WorkersLoggerOptions, l as getWorkflowLogger, n as ExecutionLogger, o as getActorLogger, r as ExecutionLoggerOptions, s as getQueueLogger, t as ExecutionLogSnapshot } from "./execution-logger-CCn9HGYC.js";
 import { n as isNativeTracingAvailable, t as getNativeTracerFromCtx } from "./native-tracing-DFaGAoR7.js";
 import { ConfigurationOption } from "autotel-edge";
@@ -27,7 +27,7 @@ export * from "autotel-edge";
  * })
  * ```
  */
-declare function instrument<E, Q = any, C = any>(handler: ExportedHandler<E, Q, C>, config: ConfigurationOption): ExportedHandler<E, Q, C>;
+export declare function instrument<E, Q = any, C = any>(handler: ExportedHandler<E, Q, C>, config: ConfigurationOption): ExportedHandler<E, Q, C>;
 //#endregion
 //#region src/wrappers/wrap-module.d.ts
 /**
@@ -38,7 +38,7 @@ declare function instrument<E, Q = any, C = any>(handler: ExportedHandler<E, Q,
  * @param handler The worker handler to wrap
  * @returns Instrumented handler
  */
-declare function wrapModule<E, Q = any, C = any>(config: ConfigurationOption, handler: ExportedHandler<E, Q, C>): ExportedHandler<E, Q, C>;
+export declare function wrapModule<E, Q = any, C = any>(config: ConfigurationOption, handler: ExportedHandler<E, Q, C>): ExportedHandler<E, Q, C>;
 //#endregion
 //#region src/wrappers/wrap-do.d.ts
 /**
@@ -49,7 +49,7 @@ declare function wrapModule<E, Q = any, C = any>(config: ConfigurationOption, ha
  * @param doClass The Durable Object class to wrap
  * @returns Instrumented Durable Object class
  */
-declare function wrapDurableObject<T extends DurableObject>(config: ConfigurationOption, doClass: new (state: DurableObjectState, env: any) => T): new (state: DurableObjectState, env: any) => T;
+export declare function wrapDurableObject<T extends DurableObject>(config: ConfigurationOption, doClass: new (state: DurableObjectState, env: any) => T): new (state: DurableObjectState, env: any) => T;
 //#endregion
 //#region src/wrappers/define-worker-fetch.d.ts
 type DefineWorkerFetchOptions = WorkersLoggerOptions;
@@ -59,7 +59,7 @@ type WorkerFetchHandler<E> = (request: Request, env: E, ctx: ExecutionContext, l
  *   - the handler is instrumented (spans, propagation, waitUntil export flush)
  *   - the handler receives a request-scoped logger as its fourth argument
  */
-declare function defineWorkerFetch<E = unknown>(config: ConfigurationOption, handler: WorkerFetchHandler<E>, loggerOptions?: DefineWorkerFetchOptions): {
+export declare function defineWorkerFetch<E = unknown>(config: ConfigurationOption, handler: WorkerFetchHandler<E>, loggerOptions?: DefineWorkerFetchOptions): {
   fetch: (request: Request, env: E, ctx: ExecutionContext) => Promise<Response>;
 };
 //#endregion
@@ -81,7 +81,7 @@ declare function defineWorkerFetch<E = unknown>(config: ConfigurationOption, han
  * **Note:** This is called automatically when the library is initialized with
  * `instrumentation.instrumentGlobalFetch: true` (default).
  */
-declare function instrumentGlobalFetch(): void;
+export declare function instrumentGlobalFetch(): void;
 //#endregion
 //#region src/global/cache.d.ts
 /**
@@ -100,6 +100,6 @@ declare function instrumentGlobalFetch(): void;
  * **Note:** This is called automatically when the library is initialized with
  * `instrumentation.instrumentGlobalCache: true` (default).
  */
-declare function instrumentGlobalCache(): void;
+export declare function instrumentGlobalCache(): void;
 //#endregion
-export { type DefineWorkerFetchOptions, type ExecutionLogSnapshot, type ExecutionLogger, type ExecutionLoggerOptions, type WorkerFetchHandler, type WorkersLoggerOptions, createWorkersLogger, defineWorkerFetch, getActorLogger, getNativeTracerFromCtx, getQueueLogger, getRequestLogger, getWorkflowLogger, instrument, instrumentAI, instrumentAnalyticsEngine, instrumentBindings, instrumentBrowserRendering, instrumentD1, instrumentDO, instrumentGlobalCache, instrumentGlobalFetch, instrumentHyperdrive, instrumentImages, instrumentKV, instrumentQueueProducer, instrumentR2, instrumentRateLimiter, instrumentServiceBinding, instrumentVectorize, instrumentWorkflow, isNativeTracingAvailable, wrapDurableObject, wrapModule };
+export { type DefineWorkerFetchOptions, type ExecutionLogSnapshot, type ExecutionLogger, type ExecutionLoggerOptions, RUNAWAY_ALARM_EXCEPTION, type WorkerFetchHandler, type WorkersLoggerOptions, createWorkersLogger, getActorLogger, getNativeTracerFromCtx, getQueueLogger, getRequestLogger, getWorkflowLogger, instrumentAI, instrumentAnalyticsEngine, instrumentBindings, instrumentBrowserRendering, instrumentD1, instrumentDO, instrumentHyperdrive, instrumentImages, instrumentKV, instrumentQueueProducer, instrumentR2, instrumentRateLimiter, instrumentServiceBinding, instrumentVectorize, instrumentWorkflow, isNativeTracingAvailable };

package/dist/index.js

@@ -1,11 +1,11 @@
 import { _ as trapArgs, a as asRecord, c as asString, f as member, g as readProperty, i as asNumber, n as asBoolean, r as asFunction, t as applyTrap } from "./values-BC6rdpGG.js";
 import { a as getWorkflowLogger, i as getRequestLogger, n as getActorLogger, r as getQueueLogger, t as createWorkersLogger } from "./execution-logger-6IZS5fEz.js";
-import { n as isNativeTracingAvailable, t as getNativeTracerFromCtx } from "./native-tracing-D0EyAtsF.js";
+import { n as isNativeTracingAvailable, t as getNativeTracerFromCtx } from "./native-tracing-Dgw_-i8X.js";
 import { a as unwrap, o as wrap, r as proxyExecutionContext, t as toException } from "./exception-D3xOCdBW.js";
 import { t as workerTracer } from "./tracer-z8zwRBVS.js";
 import { a as instrumentKV, c as instrumentImages, d as instrumentHyperdrive, f as instrumentVectorize, i as instrumentD1, l as instrumentAnalyticsEngine, n as instrumentRateLimiter, o as instrumentR2, p as instrumentAI, r as instrumentBindings, s as instrumentServiceBinding, t as instrumentBrowserRendering, u as instrumentQueueProducer } from "./bindings-BK2AmtNc.js";
-import { n as instrumentDO, t as instrumentWorkflow } from "./handlers-4X_6aEtg.js";
-import { WorkerTracer, WorkerTracerProvider, createInitialiser, ensureGlobalContextManager, getActiveConfig, getServiceForPath, setConfig, shouldInstrumentPath, withNativeTracer } from "autotel-edge";
+import { n as RUNAWAY_ALARM_EXCEPTION, r as instrumentDO, t as instrumentWorkflow } from "./handlers-7NFDRZT2.js";
+import { WorkerTracer, WorkerTracerProvider, createInitialiser, createNativeTraceContext, ensureGlobalContextManager, getActiveConfig, getServiceForPath, runWithNativeTraceContext, setConfig, shouldInstrumentPath, withNativeTracer, withoutNativeTracer } from "autotel-edge";
 import { SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
 import { resourceFromAttributes } from "@opentelemetry/resources";
 
@@ -516,6 +516,7 @@ function createHandlerFlow(instrumentation) {
 	};
 }
 let warnedMissingNative = false;
+let warnedLocalNative = false;
 /**
 * Resolve whether this invocation should use Cloudflare's native tracer.
 *
@@ -532,6 +533,10 @@ function resolveNativeTracer(config, ctx, trigger) {
 		warnedMissingNative = true;
 		console.warn("[autotel-cloudflare] nativeTracing is 'on' but Cloudflare native tracing was not detected. Enable observability.traces in your Wrangler config (and use a recent compatibility_date). Falling back to the autotel OTLP exporter.");
 	}
+	if (nativeTracer && mode === "auto" && !warnedLocalNative && config.spanProcessors.length > 0 && trigger instanceof Request && /^(localhost|127\.0\.0\.1|\[::1\])$/.test(new URL(trigger.url).hostname)) {
+		warnedLocalNative = true;
+		console.warn("[autotel-cloudflare] Cloudflare native tracing is on in wrangler dev, so spans go to the Local Explorer (/cdn-cgi/explorer), not your exporter. To stream to autotel-devtools, set NATIVE_TRACING=off in .dev.vars (or nativeTracing: \"off\").");
+	}
 	return nativeTracer;
 }
 /**
@@ -547,7 +552,9 @@ function resolveNativeTracer(config, ctx, trigger) {
 function runWithNativeTracing(handlerFn, trigger, env, ctx, config, nativeTracer) {
 	ensureGlobalContextManager();
 	const nativeContext = withNativeTracer(nativeTracer, setConfig(config));
-	return context.with(nativeContext, () => handlerFn(trigger, env, ctx));
+	const run = () => handlerFn(trigger, env, ctx);
+	const root = nativeTracer.getActiveSpan?.();
+	return context.with(nativeContext, () => root ? runWithNativeTraceContext(createNativeTraceContext(root, "handler", nativeTracer.correlationId), run) : run());
 }
 /**
 * Create handler proxy
@@ -559,7 +566,7 @@ function createHandlerProxy(_handler, handlerFn, initialiser, instrumentation) {
 		const nativeTracer = resolveNativeTracer(config, ctx, trigger);
 		if (nativeTracer) return runWithNativeTracing(handlerFn, trigger, env, ctx, config, nativeTracer);
 		const instrumentedEnv = instrumentBindings(env);
-		const configContext = setConfig(config);
+		const configContext = withoutNativeTracer(setConfig(config));
 		initProvider(config);
 		const flowFn = createHandlerFlow(instrumentation);
 		return context.with(configContext, () => {
@@ -589,7 +596,7 @@ function createHandlerProxyWithConfig(_handler, handlerFn, initialiser, createIn
 		const nativeTracer = resolveNativeTracer(config, ctx, trigger);
 		if (nativeTracer) return runWithNativeTracing(handlerFn, trigger, env, ctx, config, nativeTracer);
 		const instrumentedEnv = instrumentBindings(env);
-		const configContext = setConfig(config);
+		const configContext = withoutNativeTracer(setConfig(config));
 		initProvider(config);
 		const flowFn = createHandlerFlow(createInstrumentation(config));
 		return context.with(configContext, () => {
@@ -735,4 +742,4 @@ function defineWorkerFetch(config, handler, loggerOptions = {}) {
 }
 
 //#endregion
-export { createWorkersLogger, defineWorkerFetch, getActorLogger, getNativeTracerFromCtx, getQueueLogger, getRequestLogger, getWorkflowLogger, instrument, instrumentAI, instrumentAnalyticsEngine, instrumentBindings, instrumentBrowserRendering, instrumentD1, instrumentDO, instrumentGlobalCache, instrumentGlobalFetch, instrumentHyperdrive, instrumentImages, instrumentKV, instrumentQueueProducer, instrumentR2, instrumentRateLimiter, instrumentServiceBinding, instrumentVectorize, instrumentWorkflow, isNativeTracingAvailable, wrapDurableObject, wrapModule };
+export { RUNAWAY_ALARM_EXCEPTION, createWorkersLogger, defineWorkerFetch, getActorLogger, getNativeTracerFromCtx, getQueueLogger, getRequestLogger, getWorkflowLogger, instrument, instrumentAI, instrumentAnalyticsEngine, instrumentBindings, instrumentBrowserRendering, instrumentD1, instrumentDO, instrumentGlobalCache, instrumentGlobalFetch, instrumentHyperdrive, instrumentImages, instrumentKV, instrumentQueueProducer, instrumentR2, instrumentRateLimiter, instrumentServiceBinding, instrumentVectorize, instrumentWorkflow, isNativeTracingAvailable, wrapDurableObject, wrapModule };

package/dist/native-tracing-Dgw_-i8X.js

@@ -0,0 +1,67 @@
+import { WorkerTracerProvider, setDefaultNativeTracer } from "autotel-edge";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { tracing } from "cloudflare:workers";
+
+//#region src/native/native-tracing.ts
+/**
+* Cloudflare native tracing adapter
+*
+* Bridges Cloudflare Workers' built-in custom-span API
+* (`ctx.tracing.enterSpan()` / `import { tracing } from "cloudflare:workers"`)
+* to autotel-edge's runtime-agnostic {@link NativeTracer} seam.
+*
+* When a Worker has tracing enabled (`observability.traces.enabled = true` in
+* Wrangler) the runtime exposes `ctx.tracing`. The handler wrappers detect it,
+* wrap it as a {@link NativeTracer}, and install it into the active context with
+* `withNativeTracer()`. From then on every autotel `span()` / `trace()` /
+* `enterSpan()` call — including deep inside utility functions and libraries —
+* automatically routes to Cloudflare's native tracer and nests inside the
+* platform's trace waterfall (fetch / KV / R2 / D1 / handler spans), exported
+* by Cloudflare to whichever destination is configured in Wrangler.
+*
+* Code outside any wrapper (Durable Object RPC methods, entrypoints, helpers)
+* falls back to the module-level `tracing` export of `cloudflare:workers`,
+* registered below as autotel-edge's default native tracer.
+*/
+function readTracing(carrier) {
+	const tracing = carrier?.tracing;
+	return typeof tracing?.enterSpan === "function" ? tracing : void 0;
+}
+/**
+* Returns `true` when Cloudflare native custom-span tracing is available on the
+* given ExecutionContext (i.e. tracing is enabled for this Worker).
+*/
+function isNativeTracingAvailable(ctx) {
+	return readTracing(ctx) !== void 0;
+}
+/**
+* Wrap Cloudflare's `ctx.tracing` as an autotel {@link NativeTracer}, or return
+* `null` when native tracing is unavailable on this context.
+*
+* @param correlationId Optional per-request id (e.g. the `cf-ray` header)
+* surfaced as `ctx.correlationId` and a `correlation.id` span attribute, so
+* logs, custom spans, and the Cloudflare dashboard share one queryable key
+* today — before Cloudflare exposes in-code trace/span ids.
+*/
+function getNativeTracerFromCtx(ctx, correlationId) {
+	const tracing = readTracing(ctx);
+	if (!tracing) return null;
+	return {
+		correlationId,
+		enterSpan: (name, callback) => tracing.enterSpan(name, callback),
+		getActiveSpan: () => tracing.getActiveSpan?.(),
+		startSpan: tracing.startSpan && ((name) => tracing.startSpan(name)),
+		startActiveSpan: tracing.startActiveSpan && ((name, callback) => tracing.startActiveSpan(name, callback))
+	};
+}
+/**
+* The isolate-wide native tracer from `cloudflare:workers`, or `null` when the
+* runtime has no tracing API. Registered as the default so `trace()`/`span()`
+* nest in the platform waterfall even where no wrapper installed one.
+*/
+const platformNativeTracer = getNativeTracerFromCtx({ tracing });
+setDefaultNativeTracer(platformNativeTracer);
+if (platformNativeTracer) new WorkerTracerProvider([], resourceFromAttributes({})).register();
+
+//#endregion
+export { isNativeTracingAvailable as n, platformNativeTracer as r, getNativeTracerFromCtx as t };

package/dist/native.js

@@ -1,3 +1,3 @@
-import { n as isNativeTracingAvailable, t as getNativeTracerFromCtx } from "./native-tracing-D0EyAtsF.js";
+import { n as isNativeTracingAvailable, t as getNativeTracerFromCtx } from "./native-tracing-Dgw_-i8X.js";
 
 export { getNativeTracerFromCtx, isNativeTracingAvailable };

package/dist/tail.d.ts

@@ -0,0 +1,110 @@
+//#region src/tail.d.ts
+/**
+ * `autotel-cloudflare/tail`: observability for Workers with no SDK in them.
+ *
+ * A Tail Worker receives every invocation of the Workers that list it in
+ * `tail_consumers`: outcome, uncaught exceptions, console output (with the
+ * exception behind each `console.error` arg), the fetch request and response
+ * status, the version that ran. This turns each invocation into one OTLP span
+ * and its console output into OTLP logs, and sends them to any OTLP endpoint
+ * (autotel-devtools, the autotel-mcp collector, a vendor). Issues, grouping,
+ * source maps and automations then work exactly as for an instrumented app.
+ *
+ * ```ts
+ * // tail-worker/src/index.ts
+ * import { createTailHandler } from 'autotel-cloudflare/tail';
+ * export default {
+ *   tail: createTailHandler({ endpoint: (env) => env.OTLP_ENDPOINT }),
+ * };
+ * ```
+ * ```jsonc
+ * // the observed Worker's wrangler.jsonc: no code change
+ * { "tail_consumers": [{ "service": "my-tail-worker" }] }
+ * ```
+ *
+ * Dependency-free on purpose: a tail Worker runs for every invocation of
+ * everything it watches, so it should be as small as its job.
+ */
+/** The subset of Cloudflare's `TraceItem` this reads. */
+export interface TailItem {
+  event?: {
+    request?: {
+      method: string;
+      url: string;
+      headers?: Record<string, string>;
+    };
+    response?: {
+      status: number;
+    };
+    cron?: string;
+    scheduledTime?: number | Date;
+    queue?: string;
+    batchSize?: number;
+    rpcMethod?: string;
+  } | null;
+  eventTimestamp: number | null;
+  logs: Array<{
+    timestamp: number;
+    level: string;
+    message: unknown;
+    errorInfo?: Array<{
+      name: string;
+      message: string;
+      stack?: string;
+    } | null>;
+  }>;
+  exceptions: Array<{
+    timestamp: number;
+    name: string;
+    message: string;
+    stack?: string;
+  }>;
+  scriptName: string | null;
+  entrypoint?: string;
+  scriptVersion?: {
+    id?: string;
+    tag?: string;
+  };
+  tailAttributes?: Record<string, string | number | boolean>;
+  durableObjectId?: string;
+  outcome: string;
+  truncated?: boolean;
+  cpuTime?: number;
+  wallTime?: number;
+}
+export interface TailOptions {
+  /**
+   * `service.name` when the event has no `scriptName`, as in `wrangler dev`.
+   * In production every event names the Worker that produced it.
+   */
+  serviceName?: string;
+  /** Repeats of one log template per invocation before `autotel.LogFlood`. `0` disables. Default 100. */
+  logFloodThreshold?: number;
+  /** Alarm runs per Durable Object within `windowMs` before `autotel.RunawayAlarm`. `false` disables. */
+  runawayAlarm?: {
+    maxRuns: number;
+    windowMs: number;
+  } | false;
+}
+/** Collapse ids and numbers so one loop's lines share a template. */
+export declare function logTemplate(message: unknown): string;
+export interface OtlpPayloads {
+  traces: {
+    resourceSpans: unknown[];
+  };
+  logs: {
+    resourceLogs: unknown[];
+  };
+}
+/** Pure conversion: Cloudflare tail events → OTLP/JSON traces and logs. */
+export declare function tailItemsToOtlp(items: TailItem[], options?: TailOptions, now?: number): OtlpPayloads;
+export interface TailHandlerOptions<Env> extends TailOptions {
+  /** OTLP/HTTP base URL, e.g. `https://collector.example` (posts to `/v1/traces` and `/v1/logs`). */
+  endpoint: string | ((env: Env) => string | undefined);
+  headers?: Record<string, string> | ((env: Env) => Record<string, string> | undefined);
+}
+/** A Worker `tail` handler that ships every observed invocation as OTLP. */
+export declare function createTailHandler<Env = Record<string, unknown>>(options: TailHandlerOptions<Env>): (events: TailItem[], env: Env, ctx: {
+  waitUntil(promise: Promise<unknown>): void;
+}) => Promise<void>;
+//#endregion

package/dist/tail.js

@@ -0,0 +1,249 @@
+//#region src/tail.ts
+/**
+* `autotel-cloudflare/tail`: observability for Workers with no SDK in them.
+*
+* A Tail Worker receives every invocation of the Workers that list it in
+* `tail_consumers`: outcome, uncaught exceptions, console output (with the
+* exception behind each `console.error` arg), the fetch request and response
+* status, the version that ran. This turns each invocation into one OTLP span
+* and its console output into OTLP logs, and sends them to any OTLP endpoint
+* (autotel-devtools, the autotel-mcp collector, a vendor). Issues, grouping,
+* source maps and automations then work exactly as for an instrumented app.
+*
+* ```ts
+* // tail-worker/src/index.ts
+* import { createTailHandler } from 'autotel-cloudflare/tail';
+* export default {
+*   tail: createTailHandler({ endpoint: (env) => env.OTLP_ENDPOINT }),
+* };
+* ```
+* ```jsonc
+* // the observed Worker's wrangler.jsonc: no code change
+* { "tail_consumers": [{ "service": "my-tail-worker" }] }
+* ```
+*
+* Dependency-free on purpose: a tail Worker runs for every invocation of
+* everything it watches, so it should be as small as its job.
+*/
+/** `exception.type` autotel uses for its log-flood and runaway-alarm reports. */
+const LOG_FLOOD = "autotel.LogFlood";
+const RUNAWAY_ALARM = "autotel.RunawayAlarm";
+function anyValue(value) {
+	if (typeof value === "boolean") return { boolValue: value };
+	if (typeof value === "number") return Number.isInteger(value) ? { intValue: String(value) } : { doubleValue: value };
+	return { stringValue: typeof value === "string" ? value : JSON.stringify(value) };
+}
+function attrs(record) {
+	return Object.entries(record).filter(([, value]) => value !== void 0 && value !== null && value !== "").map(([key, value]) => ({
+		key,
+		value: anyValue(value)
+	}));
+}
+const nanos = (ms) => `${Math.round(ms)}000000`;
+function hex(bytes) {
+	const buffer = new Uint8Array(bytes);
+	crypto.getRandomValues(buffer);
+	return [...buffer].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+/** Join the caller's trace when the request carried a W3C `traceparent`. */
+function parentOf(headers) {
+	const header = headers?.traceparent ?? headers?.Traceparent;
+	const match = header && /^00-([0-9a-f]{32})-([0-9a-f]{16})-[0-9a-f]{2}$/.exec(header);
+	return match ? {
+		traceId: match[1],
+		parentSpanId: match[2]
+	} : void 0;
+}
+function format(message) {
+	return (Array.isArray(message) ? message : [message]).map((part) => typeof part === "string" ? part : JSON.stringify(part)).join(" ").slice(0, 2e3);
+}
+/** Collapse ids and numbers so one loop's lines share a template. */
+function logTemplate(message) {
+	return format(message).replaceAll(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, "<uuid>").replaceAll(/\b(?=[0-9a-f]*\d)[0-9a-f]{8,}\b/gi, "<hex>").replaceAll(/\d+/g, "<n>");
+}
+const SEVERITY = {
+	debug: [5, "DEBUG"],
+	log: [9, "INFO"],
+	info: [9, "INFO"],
+	warn: [13, "WARN"],
+	error: [17, "ERROR"]
+};
+/**
+* Alarm runs per Durable Object, per isolate: best effort, as long as a tail
+* isolate lives. Keyed by when each alarm *ran* (the invocation's timestamp),
+* never when the tail received it: events arrive batched, late and out of order.
+*/
+const alarmRuns = /* @__PURE__ */ new Map();
+function alarmTimestamp(item, now) {
+	const scheduled = item.event?.scheduledTime;
+	return item.eventTimestamp ?? (scheduled instanceof Date ? scheduled.getTime() : scheduled) ?? now;
+}
+function runawayAlarm(item, options, now) {
+	const limits = options.runawayAlarm ?? {
+		maxRuns: 10,
+		windowMs: 6e4
+	};
+	if (!limits || !item.durableObjectId || item.event?.scheduledTime === void 0 || item.event.cron !== void 0) return;
+	const at = alarmTimestamp(item, now);
+	const state = alarmRuns.get(item.durableObjectId) ?? { runs: [] };
+	const newest = Math.max(at, ...state.runs);
+	state.runs = [...state.runs, at].filter((t) => newest - t < 2 * limits.windowMs).sort((a, b) => a - b).slice(-1e3);
+	if (alarmRuns.size > 1e3 && !alarmRuns.has(item.durableObjectId)) alarmRuns.clear();
+	alarmRuns.set(item.durableObjectId, state);
+	let busiest = 0;
+	for (const startAt of state.runs) {
+		if (startAt > at || at - startAt >= limits.windowMs) continue;
+		const count = state.runs.filter((t) => t >= startAt && t - startAt < limits.windowMs).length;
+		busiest = Math.max(busiest, count);
+	}
+	if (busiest <= limits.maxRuns) return void 0;
+	if (state.reportedAt !== void 0 && Math.abs(at - state.reportedAt) < limits.windowMs) return;
+	state.reportedAt = at;
+	return `Durable Object ${item.durableObjectId} alarm ran ${busiest} times in ${limits.windowMs / 1e3}s`;
+}
+function spanName(item) {
+	const event = item.event;
+	if (event?.request) try {
+		return `${event.request.method} ${new URL(event.request.url).pathname}`;
+	} catch {
+		return event.request.method;
+	}
+	if (event?.cron !== void 0) return `scheduled ${event.cron}`;
+	if (event?.queue) return `queue ${event.queue}`;
+	if (event?.rpcMethod) return `rpc ${event.rpcMethod}`;
+	if (item.durableObjectId && event?.scheduledTime !== void 0) return "alarm";
+	return item.entrypoint ?? "invocation";
+}
+/** Pure conversion: Cloudflare tail events → OTLP/JSON traces and logs. */
+function tailItemsToOtlp(items, options = {}, now = Date.now()) {
+	const resourceSpans = [];
+	const resourceLogs = [];
+	const threshold = options.logFloodThreshold ?? 100;
+	for (const item of items) {
+		const start = item.eventTimestamp ?? item.logs[0]?.timestamp ?? now;
+		const end = start + Math.max(item.wallTime ?? 0, 0);
+		const parent = parentOf(item.event?.request?.headers);
+		const traceId = parent?.traceId ?? hex(16);
+		const spanId = hex(8);
+		const status = item.event?.response?.status;
+		const failed = item.outcome !== "ok" || item.exceptions.length > 0;
+		const exceptionEvent = (time, name, message, stack) => ({
+			name: "exception",
+			timeUnixNano: nanos(time),
+			attributes: attrs({
+				"exception.type": name,
+				"exception.message": message,
+				"exception.stacktrace": stack
+			})
+		});
+		const events = item.exceptions.map((e) => exceptionEvent(e.timestamp, e.name, e.message, e.stack));
+		const templates = /* @__PURE__ */ new Map();
+		for (const log of item.logs) {
+			if (log.level === "error") {
+				const errors = (log.errorInfo ?? []).filter((e) => e !== null);
+				if (errors.length > 0) for (const e of errors) events.push(exceptionEvent(log.timestamp, e.name, e.message, e.stack));
+				else events.push(exceptionEvent(log.timestamp, "Error", format(log.message).slice(0, 500)));
+			}
+			if (threshold > 0) {
+				const template = logTemplate(log.message);
+				const count = (templates.get(template) ?? 0) + 1;
+				templates.set(template, count);
+				if (count === threshold + 1) events.push(exceptionEvent(log.timestamp, LOG_FLOOD, `"${template.slice(0, 120)}" logged ${threshold}+ times in one invocation`));
+			}
+		}
+		const runaway = runawayAlarm(item, options, now);
+		if (runaway) events.push(exceptionEvent(start, RUNAWAY_ALARM, runaway));
+		const resource = { attributes: attrs({
+			"service.name": item.scriptName ?? options.serviceName ?? "worker",
+			"service.version": item.scriptVersion?.tag ?? item.scriptVersion?.id,
+			"cloudflare.script_version.id": item.scriptVersion?.id,
+			"cloud.provider": "cloudflare",
+			"cloud.platform": "cloudflare.workers",
+			"telemetry.sdk.name": "autotel-cloudflare/tail"
+		}) };
+		let url;
+		try {
+			url = item.event?.request ? new URL(item.event.request.url) : void 0;
+		} catch {
+			url = void 0;
+		}
+		resourceSpans.push({
+			resource,
+			scopeSpans: [{
+				scope: { name: "autotel-cloudflare/tail" },
+				spans: [{
+					traceId,
+					spanId,
+					...parent ? { parentSpanId: parent.parentSpanId } : {},
+					name: spanName(item),
+					kind: item.event?.request ? 2 : 1,
+					startTimeUnixNano: nanos(start),
+					endTimeUnixNano: nanos(end),
+					attributes: attrs({
+						...item.tailAttributes,
+						"http.request.method": item.event?.request?.method,
+						"url.full": item.event?.request?.url,
+						"url.path": url?.pathname,
+						"http.response.status_code": status,
+						"cloudflare.outcome": item.outcome,
+						"cloudflare.entrypoint": item.entrypoint,
+						"cloudflare.durable_object.id": item.durableObjectId,
+						"cloudflare.cpu_time_ms": item.cpuTime,
+						"cloudflare.truncated": item.truncated || void 0,
+						"faas.trigger": item.event?.request ? "http" : item.event?.cron === void 0 ? item.event?.queue ? "pubsub" : "other" : "timer"
+					}),
+					events,
+					status: failed ? {
+						code: 2,
+						message: item.exceptions[0]?.message ?? `outcome: ${item.outcome}`
+					} : { code: 0 }
+				}]
+			}]
+		});
+		if (item.logs.length > 0) resourceLogs.push({
+			resource,
+			scopeLogs: [{
+				scope: { name: "autotel-cloudflare/tail" },
+				logRecords: item.logs.map((log) => {
+					const [severityNumber, severityText] = SEVERITY[log.level] ?? [9, "INFO"];
+					return {
+						timeUnixNano: nanos(log.timestamp),
+						severityNumber,
+						severityText,
+						body: { stringValue: format(log.message) },
+						traceId,
+						spanId
+					};
+				})
+			}]
+		});
+	}
+	return {
+		traces: { resourceSpans },
+		logs: { resourceLogs }
+	};
+}
+/** A Worker `tail` handler that ships every observed invocation as OTLP. */
+function createTailHandler(options) {
+	return async (events, env, ctx) => {
+		const endpoint = typeof options.endpoint === "function" ? options.endpoint(env) : options.endpoint;
+		if (!endpoint || events.length === 0) return;
+		const headers = {
+			"content-type": "application/json",
+			...typeof options.headers === "function" ? options.headers(env) : options.headers
+		};
+		const { traces, logs } = tailItemsToOtlp(events, options);
+		const base = endpoint.replace(/\/+$/, "").replace(/\/v1\/(traces|logs)$/, "");
+		const send = (path, body) => fetch(`${base}${path}`, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(body)
+		}).then((res) => {
+			if (!res.ok) console.warn(`[autotel-cloudflare/tail] ${path} → HTTP ${res.status}`);
+		});
+		ctx.waitUntil(Promise.all([send("/v1/traces", traces), logs.resourceLogs.length > 0 ? send("/v1/logs", logs) : void 0]).catch((error) => console.warn("[autotel-cloudflare/tail] export failed", error)));
+	};
+}
+
+//#endregion
+export { createTailHandler, logTemplate, tailItemsToOtlp };

package/dist/testing.d.ts

@@ -1 +1 @@
-export * from "autotel-edge/testing";
+export type * from "autotel-edge/testing";

package/dist/testing.js

@@ -1,3 +1 @@
-export * from "autotel-edge/testing"
-
 export {  };