autotel-cloudflare 18.0.0 → 18.1.0

package/dist/{handlers-4X_6aEtg.js → handlers-a5qrd5nR.js}

@@ -1,7 +1,8 @@
 import { _ as trapArgs, f as member, r as asFunction } from "./values-BC6rdpGG.js";
+import { r as platformNativeTracer } from "./native-tracing-DjyDA54H.js";
 import { o as wrap, t as toException } from "./exception-D3xOCdBW.js";
 import { t as workerTracer } from "./tracer-z8zwRBVS.js";
-import { createInitialiser, setConfig } from "autotel-edge";
+import { createInitialiser, nativeRecordException, setConfig, withoutNativeTracer } from "autotel-edge";
 import { SpanKind, SpanStatusCode, context, propagation } from "@opentelemetry/api";
 
 //#region src/handlers/durable-objects.ts
@@ -24,13 +25,55 @@ function isColdStart$1(doClass) {
 	}
 	return false;
 }
+/** `exception.type` of the alarm-loop signal. */
+const RUNAWAY_ALARM_EXCEPTION = "autotel.RunawayAlarm";
+const alarmRuns = /* @__PURE__ */ new Map();
+/**
+* Note one alarm run. Returns the `autotel.RunawayAlarm` exception when the
+* object's alarm has run more than `maxRuns` times within `windowMs`, at most
+* once per window.
+*/
+function checkRunawayAlarm(id, config, now = Date.now()) {
+	if (config === false) return void 0;
+	const maxRuns = config?.maxRuns ?? 10;
+	const windowMs = config?.windowMs ?? 6e4;
+	const key = id.toString();
+	const entry = alarmRuns.get(key) ?? { times: [] };
+	alarmRuns.set(key, entry);
+	entry.times = entry.times.filter((t) => now - t < windowMs);
+	entry.times.push(now);
+	if (entry.times.length > maxRuns + 1) entry.times.shift();
+	if (entry.times.length <= maxRuns) return void 0;
+	if (entry.firedAt !== void 0 && now - entry.firedAt < windowMs) return;
+	entry.firedAt = now;
+	const error = /* @__PURE__ */ new Error(`Durable Object ${id.name || key} alarm ran ${entry.times.length} times in ${windowMs / 1e3}s`);
+	error.name = RUNAWAY_ALARM_EXCEPTION;
+	return error;
+}
+/**
+* Native tracing mode: shadow the instance's `alarm` with a Proxy over the
+* original, so the runaway check lands on Cloudflare's alarm span. The
+* instance itself stays unproxied (private fields keep working).
+*/
+function watchNativeAlarm(doInstance, id, config) {
+	const alarm = asFunction(member(doInstance, "alarm"));
+	if (!alarm || config === false) return;
+	doInstance.alarm = new Proxy(alarm, { apply(target, thisArg, args) {
+		const runaway = checkRunawayAlarm(id, config);
+		if (runaway) {
+			const span = platformNativeTracer?.getActiveSpan?.();
+			if (span) nativeRecordException(span, runaway);
+		}
+		return Reflect.apply(target, thisArg, args);
+	} });
+}
 /**
 * Instrument a Durable Object fetch method
 */
 function instrumentDOFetch(fetchFn, id, doClass) {
 	return async function instrumentedFetch(request) {
 		const tracer = workerTracer("autotel-edge");
-		const parentContext = propagation.extract(context.active(), request.headers);
+		const parentContext = propagation.extract(withoutNativeTracer(), request.headers);
 		const url = new URL(request.url);
 		const spanName = `DO ${id.name || id.toString()}: ${request.method} ${url.pathname}`;
 		return tracer.startActiveSpan(spanName, {
@@ -66,7 +109,7 @@ function instrumentDOFetch(fetchFn, id, doClass) {
 /**
 * Instrument a Durable Object alarm method
 */
-function instrumentDOAlarm(alarmFn, id, doClass) {
+function instrumentDOAlarm(alarmFn, id, doClass, runawayAlarm) {
 	return async function instrumentedAlarm() {
 		const tracer = workerTracer("autotel-edge");
 		const spanName = `DO ${id.name || id.toString()}: alarm`;
@@ -78,7 +121,9 @@ function instrumentDOAlarm(alarmFn, id, doClass) {
 				"faas.trigger": "timer",
 				"faas.coldstart": isColdStart$1(doClass)
 			}
-		}, async (span) => {
+		}, withoutNativeTracer(), async (span) => {
+			const runaway = checkRunawayAlarm(id, runawayAlarm);
+			if (runaway) span.recordException(runaway);
 			try {
 				await alarmFn.call(this);
 				span.setStatus({ code: SpanStatusCode.OK });
@@ -98,12 +143,12 @@ function instrumentDOAlarm(alarmFn, id, doClass) {
 /**
 * Instrument a Durable Object instance
 */
-function instrumentDOInstance(doInstance, state, _env, doClass) {
+function instrumentDOInstance(doInstance, state, doClass, runawayAlarm) {
 	return wrap(doInstance, { get(target, prop) {
 		const value = member(target, prop);
 		const method = asFunction(value);
 		if (prop === "fetch" && method) return instrumentDOFetch(method.bind(target), state.id, doClass);
-		if (prop === "alarm" && method) return instrumentDOAlarm(method.bind(target), state.id, doClass);
+		if (prop === "alarm" && method) return instrumentDOAlarm(method.bind(target), state.id, doClass, runawayAlarm);
 		return method ? method.bind(target) : value;
 	} });
 }
@@ -158,9 +203,14 @@ function instrumentDO(doClass, config) {
 		};
 		const doConfig = initialiser(env, trigger);
 		const context$2 = setConfig(doConfig);
-		return instrumentDOInstance(context.with(context$2, () => {
+		const doInstance = context.with(context$2, () => {
 			return new target(state, env);
-		}), state, env, doClass);
+		});
+		if (platformNativeTracer && doConfig.nativeTracing !== "off") {
+			watchNativeAlarm(doInstance, state.id, doConfig.runawayAlarm);
+			return doInstance;
+		}
+		return instrumentDOInstance(doInstance, state, doClass, doConfig.runawayAlarm);
 	} });
 }
 
@@ -292,7 +342,7 @@ function instrumentWorkflowRun(runFn, workflowName, workflowClass) {
 				"faas.trigger": "workflow",
 				"faas.coldstart": isColdStart(workflowClass)
 			}
-		}, async (span) => {
+		}, withoutNativeTracer(), async (span) => {
 			try {
 				const result = await runFn.call(this, event, instrumentedStep);
 				span.setStatus({ code: SpanStatusCode.OK });
@@ -311,6 +361,31 @@ function instrumentWorkflowRun(runFn, workflowName, workflowClass) {
 	};
 }
 /**
+* Native tracing: Cloudflare traces the run and step RPC calls but not step
+* names, so wrap only `step.do()` in a named native span.
+*/
+function nativeWorkflowInstance(workflowInstance, workflowName, tracer) {
+	return wrap(workflowInstance, { get(target, prop) {
+		const value = member(target, prop);
+		const method = asFunction(value);
+		if (prop !== "run" || !method) return method ? method.bind(target) : value;
+		return (event, step) => method.call(target, event, wrap(step, { get(stepTarget, stepProp) {
+			const stepValue = member(stepTarget, stepProp);
+			const stepMethod = asFunction(stepValue);
+			if (stepProp !== "do" || !stepMethod) return stepValue;
+			return (...args) => {
+				const [stepName] = trapArgs(args);
+				return tracer.enterSpan(`Workflow ${workflowName}: ${stepName}`, (span) => {
+					span.setAttribute("workflow.name", workflowName);
+					span.setAttribute("workflow.step.name", stepName);
+					span.setAttribute("workflow.instance_id", event.instanceId);
+					return Reflect.apply(stepMethod, stepTarget, args);
+				});
+			};
+		} }));
+	} });
+}
+/**
 * Instrument a Workflow instance
 */
 function instrumentWorkflowInstance(workflowInstance, workflowName, workflowClass) {
@@ -374,11 +449,13 @@ function instrumentWorkflow(workflowClass, workflowName, config) {
 			name: workflowName
 		});
 		const context$1 = setConfig(workflowConfig);
-		return instrumentWorkflowInstance(context.with(context$1, () => {
+		const workflowInstance = context.with(context$1, () => {
 			return new target(...args);
-		}), workflowName, workflowClass);
+		});
+		if (platformNativeTracer && workflowConfig.nativeTracing !== "off") return nativeWorkflowInstance(workflowInstance, workflowName, platformNativeTracer);
+		return instrumentWorkflowInstance(workflowInstance, workflowName, workflowClass);
 	} });
 }
 
 //#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-a5qrd5nR.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-DjyDA54H.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-a5qrd5nR.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-DjyDA54H.js

@@ -0,0 +1,63 @@
+import { setDefaultNativeTracer } from "autotel-edge";
+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?.()
+	};
+}
+/**
+* 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);
+
+//#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-DjyDA54H.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