autotel-cloudflare 17.0.0 → 18.1.0

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 {  };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autotel-cloudflare",
-  "version": "17.0.0",
+  "version": "18.1.0",
   "description": "The #1 OpenTelemetry package for Cloudflare Workers - complete bindings coverage, native CF OTel integration, advanced sampling",
   "type": "module",
   "main": "./dist/index.js",
@@ -47,6 +47,10 @@
       "types": "./dist/native.d.ts",
       "import": "./dist/native.js"
     },
+    "./tail": {
+      "types": "./dist/tail.d.ts",
+      "import": "./dist/tail.js"
+    },
     "./parse-error": {
       "types": "./dist/parse-error.d.ts",
       "import": "./dist/parse-error.js"
@@ -80,9 +84,9 @@
     "@opentelemetry/resources": "^2.11.0"
   },
   "peerDependencies": {
-    "@cloudflare/workers-types": "^5.20260728.1",
-    "autotel-edge": "5.1.1",
-    "autotel-genai": "0.14.0"
+    "@cloudflare/workers-types": "^5.20260928.1",
+    "autotel-edge": "6.0.0",
+    "autotel-genai": "0.15.1"
   },
   "peerDependenciesMeta": {
     "autotel-edge": {
@@ -93,16 +97,16 @@
     }
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^5.20260728.1",
+    "@cloudflare/workers-types": "^5.20260928.1",
     "@opentelemetry/context-async-hooks": "^2.11.0",
-    "@types/node": "^26.1.2",
-    "autotel-edge": "5.1.1",
-    "autotel-genai": "0.14.0",
+    "@types/node": "^26.6.3",
+    "autotel-edge": "6.0.0",
+    "autotel-genai": "0.15.1",
     "rimraf": "^6.1.3",
-    "tsdown": "^0.22.14",
-    "typescript": "^6.0.3",
-    "vitest": "^4.1.10",
-    "vitest-mock-extended": "^5.1.0"
+    "tsdown": "^0.23.0",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.2",
+    "vitest-mock-extended": "^5.1.1"
   },
   "repository": {
     "type": "git",
@@ -116,8 +120,8 @@
   "scripts": {
     "build": "tsdown",
     "dev": "tsdown --watch",
-    "lint": "eslint src/**/*.ts",
-    "lint:fix": "eslint src/**/*.ts --fix",
+    "lint": "oxlint -c oxlint.json --disable-nested-config src",
+    "lint:fix": "pnpm lint --fix",
     "type-check": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",

package/dist/native-tracing-D0EyAtsF.js

@@ -1,32 +0,0 @@
-//#region src/native/native-tracing.ts
-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)
-	};
-}
-
-//#endregion
-export { isNativeTracingAvailable as n, getNativeTracerFromCtx as t };