autotel-cloudflare 2.18.18 → 2.19.0

package/dist/index.js

@@ -1,658 +1,702 @@
-import { instrumentBindings } from './chunk-KAUHT25H.js';
-export { instrumentAI, instrumentAnalyticsEngine, instrumentBindings, instrumentBrowserRendering, instrumentD1, instrumentHyperdrive, instrumentImages, instrumentKV, instrumentQueueProducer, instrumentR2, instrumentRateLimiter, instrumentServiceBinding, instrumentVectorize } from './chunk-KAUHT25H.js';
-import { instrumentDO } from './chunk-MIDMNKDC.js';
-export { instrumentDO, instrumentWorkflow } from './chunk-MIDMNKDC.js';
-import { createWorkersLogger } from './chunk-RVVMMPWN.js';
-export { createWorkersLogger, getActorLogger, getQueueLogger, getRequestLogger, getWorkflowLogger } from './chunk-RVVMMPWN.js';
-import { wrap, unwrap, proxyExecutionContext } from './chunk-O4IYKWPJ.js';
-import { createInitialiser, getActiveConfig, shouldInstrumentPath, setConfig, WorkerTracerProvider, WorkerTracer, getServiceForPath } from 'autotel-edge';
-export * from 'autotel-edge';
-import { trace, SpanKind, propagation, context, SpanStatusCode } from '@opentelemetry/api';
-import { resourceFromAttributes } from '@opentelemetry/resources';
+import { a as getWorkflowLogger, i as getRequestLogger, n as getActorLogger, r as getQueueLogger, t as createWorkersLogger } from "./execution-logger-BxmgP8jF.js";
+import { a as wrap, i as unwrap, n as proxyExecutionContext } from "./common-DiWH6nmG.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-C10RI6Il.js";
+import { n as instrumentDO, t as instrumentWorkflow } from "./handlers-CMg9l_T-.js";
+import { WorkerTracer, WorkerTracerProvider, createInitialiser, getActiveConfig, getServiceForPath, setConfig, shouldInstrumentPath } from "autotel-edge";
+import { SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
+import { resourceFromAttributes } from "@opentelemetry/resources";
 
+export * from "autotel-edge"
+
+//#region src/global/fetch.ts
+/**
+* Global fetch() instrumentation for autotel-edge
+*
+* Automatically traces all outgoing fetch() calls with:
+* - HTTP method, URL, status code
+* - Request/response headers
+* - Automatic context propagation
+* - Error tracking
+*/
+/**
+* Gather HTTP request attributes following OpenTelemetry semantic conventions
+*/
 function gatherRequestAttributes(request) {
-  const url = new URL(request.url);
-  const config = getActiveConfig();
-  const redactQuery = config?.dataSafety?.redactQueryParams === true;
-  return {
-    "http.request.method": request.method.toUpperCase(),
-    "url.full": redactQuery ? `${url.origin}${url.pathname}` : request.url,
-    "url.scheme": url.protocol.replace(":", ""),
-    "server.address": url.host,
-    "url.path": url.pathname,
-    "url.query": redactQuery ? url.search ? "[REDACTED]" : "" : url.search,
-    "network.protocol.name": "http",
-    "user_agent.original": request.headers.get("user-agent") || void 0
-  };
+	const url = new URL(request.url);
+	const redactQuery = getActiveConfig()?.dataSafety?.redactQueryParams === true;
+	return {
+		"http.request.method": request.method.toUpperCase(),
+		"url.full": redactQuery ? `${url.origin}${url.pathname}` : request.url,
+		"url.scheme": url.protocol.replace(":", ""),
+		"server.address": url.host,
+		"url.path": url.pathname,
+		"url.query": redactQuery ? url.search ? "[REDACTED]" : "" : url.search,
+		"network.protocol.name": "http",
+		"user_agent.original": request.headers.get("user-agent") || void 0
+	};
 }
+/**
+* Gather HTTP response attributes
+*/
 function gatherResponseAttributes(response) {
-  return {
-    "http.response.status_code": response.status,
-    "http.response.body.size": response.headers.get("content-length") || void 0
-  };
+	return {
+		"http.response.status_code": response.status,
+		"http.response.body.size": response.headers.get("content-length") || void 0
+	};
 }
+/**
+* Instrument the global fetch function
+*
+* This wraps globalThis.fetch to automatically create spans for all outgoing HTTP requests.
+*
+* **Note:** This is called automatically when the library is initialized with
+* `instrumentation.instrumentGlobalFetch: true` (default).
+*/
 function instrumentGlobalFetch() {
-  const originalFetch = globalThis.fetch;
-  const instrumentedFetch = function fetch(input, init) {
-    const request = new Request(input, init);
-    if (!request.url.startsWith("http")) {
-      return originalFetch(input, init);
-    }
-    const config = getActiveConfig();
-    if (!config) {
-      return originalFetch(input, init);
-    }
-    const tracer = trace.getTracer("autotel-edge");
-    const url = new URL(request.url);
-    const spanName = `${request.method} ${url.host}`;
-    return tracer.startActiveSpan(
-      spanName,
-      {
-        kind: SpanKind.CLIENT,
-        attributes: gatherRequestAttributes(request)
-      },
-      async (span) => {
-        try {
-          const shouldIncludeContext = typeof config.fetch?.includeTraceContext === "function" ? config.fetch.includeTraceContext(request) : config.fetch?.includeTraceContext ?? true;
-          if (shouldIncludeContext) {
-            propagation.inject(context.active(), request.headers, {
-              set: (headers, key, value) => {
-                if (typeof value === "string") {
-                  headers.set(key, value);
-                }
-              }
-            });
-          }
-          const response = await originalFetch(request);
-          span.setAttributes(gatherResponseAttributes(response));
-          if (response.ok) {
-            span.setStatus({ code: SpanStatusCode.OK });
-          } else {
-            span.setStatus({ code: SpanStatusCode.ERROR });
-          }
-          return response;
-        } catch (error) {
-          span.recordException(error);
-          span.setStatus({
-            code: SpanStatusCode.ERROR,
-            message: error instanceof Error ? error.message : String(error)
-          });
-          throw error;
-        } finally {
-          span.end();
-        }
-      }
-    );
-  };
-  globalThis.fetch = instrumentedFetch;
+	const originalFetch = globalThis.fetch;
+	globalThis.fetch = function fetch(input, init) {
+		const request = new Request(input, init);
+		if (!request.url.startsWith("http")) return originalFetch(input, init);
+		const config = getActiveConfig();
+		if (!config) return originalFetch(input, init);
+		const tracer = trace.getTracer("autotel-edge");
+		const url = new URL(request.url);
+		const spanName = `${request.method} ${url.host}`;
+		return tracer.startActiveSpan(spanName, {
+			kind: SpanKind.CLIENT,
+			attributes: gatherRequestAttributes(request)
+		}, async (span) => {
+			try {
+				if (typeof config.fetch?.includeTraceContext === "function" ? config.fetch.includeTraceContext(request) : config.fetch?.includeTraceContext ?? true) propagation.inject(context.active(), request.headers, { set: (headers, key, value) => {
+					if (typeof value === "string") headers.set(key, value);
+				} });
+				const response = await originalFetch(request);
+				span.setAttributes(gatherResponseAttributes(response));
+				if (response.ok) span.setStatus({ code: SpanStatusCode.OK });
+				else span.setStatus({ code: SpanStatusCode.ERROR });
+				return response;
+			} catch (error) {
+				span.recordException(error);
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: error instanceof Error ? error.message : String(error)
+				});
+				throw error;
+			} finally {
+				span.end();
+			}
+		});
+	};
 }
+
+//#endregion
+//#region src/global/cache.ts
+/**
+* Global Cache API instrumentation for Cloudflare Workers
+*
+* Automatically traces cache operations:
+* - cache.match() - Read from cache
+* - cache.put() - Write to cache
+* - cache.delete() - Delete from cache
+*/
+/**
+* Sanitize URL for span attributes (remove query params that might contain sensitive data)
+*/
 function sanitizeURL(url) {
-  const u = new URL(url);
-  return `${u.protocol}//${u.host}${u.pathname}`;
+	const u = new URL(url);
+	return `${u.protocol}//${u.host}${u.pathname}`;
 }
+/**
+* Instrument a cache method (match, put, delete)
+*/
 function instrumentCacheMethod(fn, cacheName, operation) {
-  const handler = {
-    async apply(target, thisArg, argArray) {
-      const tracer = trace.getTracer("autotel-edge");
-      const firstArg = argArray[0];
-      const url = firstArg instanceof Request ? firstArg.url : typeof firstArg === "string" ? firstArg : void 0;
-      const spanName = `Cache ${cacheName}.${operation}`;
-      return tracer.startActiveSpan(
-        spanName,
-        {
-          kind: SpanKind.CLIENT,
-          attributes: {
-            "cache.name": cacheName,
-            "cache.operation": operation,
-            "cache.key": url ? sanitizeURL(url) : void 0
-          }
-        },
-        async (span) => {
-          try {
-            const result = await Reflect.apply(target, thisArg, argArray);
-            if (operation === "match") {
-              span.setAttribute("cache.hit", !!result);
-            }
-            span.setStatus({ code: SpanStatusCode.OK });
-            return result;
-          } catch (error) {
-            span.recordException(error);
-            span.setStatus({
-              code: SpanStatusCode.ERROR,
-              message: error instanceof Error ? error.message : String(error)
-            });
-            throw error;
-          } finally {
-            span.end();
-          }
-        }
-      );
-    }
-  };
-  return wrap(fn, handler);
+	return wrap(fn, { async apply(target, thisArg, argArray) {
+		const tracer = trace.getTracer("autotel-edge");
+		const firstArg = argArray[0];
+		const url = firstArg instanceof Request ? firstArg.url : typeof firstArg === "string" ? firstArg : void 0;
+		const spanName = `Cache ${cacheName}.${operation}`;
+		return tracer.startActiveSpan(spanName, {
+			kind: SpanKind.CLIENT,
+			attributes: {
+				"cache.name": cacheName,
+				"cache.operation": operation,
+				"cache.key": url ? sanitizeURL(url) : void 0
+			}
+		}, async (span) => {
+			try {
+				const result = await Reflect.apply(target, thisArg, argArray);
+				if (operation === "match") span.setAttribute("cache.hit", !!result);
+				span.setStatus({ code: SpanStatusCode.OK });
+				return result;
+			} catch (error) {
+				span.recordException(error);
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: error instanceof Error ? error.message : String(error)
+				});
+				throw error;
+			} finally {
+				span.end();
+			}
+		});
+	} });
 }
+/**
+* Instrument a Cache instance
+*/
 function instrumentCache(cache, cacheName) {
-  const handler = {
-    get(target, prop) {
-      const value = Reflect.get(target, prop);
-      if ((prop === "match" || prop === "put" || prop === "delete") && typeof value === "function") {
-        return instrumentCacheMethod(
-          value.bind(target),
-          cacheName,
-          prop
-        );
-      }
-      if (typeof value === "function") {
-        return value.bind(target);
-      }
-      return value;
-    }
-  };
-  return wrap(cache, handler);
+	return wrap(cache, { get(target, prop) {
+		const value = Reflect.get(target, prop);
+		if ((prop === "match" || prop === "put" || prop === "delete") && typeof value === "function") return instrumentCacheMethod(value.bind(target), cacheName, prop);
+		if (typeof value === "function") return value.bind(target);
+		return value;
+	} });
 }
+/**
+* Instrument caches.open()
+*/
 function instrumentCachesOpen(openFn) {
-  const handler = {
-    async apply(target, thisArg, argArray) {
-      const cacheName = argArray[0];
-      const cache = await Reflect.apply(target, thisArg, argArray);
-      return instrumentCache(cache, cacheName);
-    }
-  };
-  return wrap(openFn, handler);
+	return wrap(openFn, { async apply(target, thisArg, argArray) {
+		const cacheName = argArray[0];
+		return instrumentCache(await Reflect.apply(target, thisArg, argArray), cacheName);
+	} });
 }
+/**
+* Instrument the global caches API
+*
+* This wraps globalThis.caches to automatically create spans for all cache operations.
+*
+* **Note:** This is called automatically when the library is initialized with
+* `instrumentation.instrumentGlobalCache: true` (default).
+*/
 function instrumentGlobalCache() {
-  const handler = {
-    get(target, prop) {
-      if (prop === "default") {
-        return instrumentCache(target.default, "default");
-      } else if (prop === "open") {
-        const openFn = Reflect.get(target, prop);
-        if (typeof openFn === "function") {
-          return instrumentCachesOpen(openFn.bind(target));
-        }
-      }
-      return Reflect.get(target, prop);
-    }
-  };
-  globalThis.caches = wrap(caches, handler);
+	globalThis.caches = wrap(caches, { get(target, prop) {
+		if (prop === "default") return instrumentCache(target.default, "default");
+		else if (prop === "open") {
+			const openFn = Reflect.get(target, prop);
+			if (typeof openFn === "function") return instrumentCachesOpen(openFn.bind(target));
+		}
+		return Reflect.get(target, prop);
+	} });
 }
 
-// src/wrappers/instrument.ts
-var headersGetter = {
-  get: (carrier, key) => carrier.get(key) ?? void 0,
-  keys: (carrier) => [...carrier.keys()]
+//#endregion
+//#region src/wrappers/instrument.ts
+/**
+* Handler instrumentation for Cloudflare Workers
+* 
+* Note: This file uses Cloudflare Workers types (ExportedHandler, Request, Response, etc.)
+* which are globally available via @cloudflare/workers-types when listed in tsconfig.json.
+* These types are devDependencies only - they're not runtime dependencies.
+* At runtime, Cloudflare Workers runtime provides the actual implementations.
+* 
+* Provides automatic OpenTelemetry tracing for:
+* - HTTP handlers (fetch)
+* - Scheduled/cron handlers
+* - Queue handlers (with message tracking)
+* - Email handlers
+* - Auto-instrumentation of Cloudflare bindings (KV, R2, D1, Service Bindings)
+* - Global fetch and cache instrumentation
+* - Post-processor support for span customization
+* - Tail sampling support
+* - Cold start tracking
+*/
+const headersGetter = {
+	get: (carrier, key) => carrier.get(key) ?? void 0,
+	keys: (carrier) => [...carrier.keys()]
 };
+/**
+* Create fetch handler instrumentation with config support for postProcess
+*/
+/**
+* Extract Cloudflare-specific attributes from a request
+*/
 function extractCfAttributes(request) {
-  const cf = request.cf;
-  if (!cf) return {};
-  const attrs = {};
-  const set = (key, value) => {
-    if (value !== void 0 && value !== null) {
-      attrs[key] = value;
-    }
-  };
-  set("cloudflare.colo", cf.colo);
-  const ray = request.headers.get("cf-ray");
-  if (ray) attrs["cloudflare.ray_id"] = ray;
-  set("cloudflare.country", cf.country);
-  set("cloudflare.city", cf.city);
-  set("cloudflare.region", cf.region);
-  set("cloudflare.continent", cf.continent);
-  set("cloudflare.timezone", cf.timezone);
-  set("cloudflare.latitude", cf.latitude);
-  set("cloudflare.longitude", cf.longitude);
-  set("cloudflare.asn", cf.asn);
-  set("cloudflare.as_organization", cf.asOrganization);
-  set("cloudflare.http_protocol", cf.httpProtocol);
-  set("cloudflare.tls_version", cf.tlsVersion);
-  set("cloudflare.client_tcp_rtt", cf.clientTcpRtt);
-  return attrs;
+	const cf = request.cf;
+	if (!cf) return {};
+	const attrs = {};
+	const set = (key, value) => {
+		if (value !== void 0 && value !== null) attrs[key] = value;
+	};
+	set("cloudflare.colo", cf.colo);
+	const ray = request.headers.get("cf-ray");
+	if (ray) attrs["cloudflare.ray_id"] = ray;
+	set("cloudflare.country", cf.country);
+	set("cloudflare.city", cf.city);
+	set("cloudflare.region", cf.region);
+	set("cloudflare.continent", cf.continent);
+	set("cloudflare.timezone", cf.timezone);
+	set("cloudflare.latitude", cf.latitude);
+	set("cloudflare.longitude", cf.longitude);
+	set("cloudflare.asn", cf.asn);
+	set("cloudflare.as_organization", cf.asOrganization);
+	set("cloudflare.http_protocol", cf.httpProtocol);
+	set("cloudflare.tls_version", cf.tlsVersion);
+	set("cloudflare.client_tcp_rtt", cf.clientTcpRtt);
+	return attrs;
 }
 function createFetchInstrumentation(config) {
-  return {
-    getInitialSpanInfo: (request) => {
-      const url = new URL(request.url);
-      const routeService = getServiceForPath(
-        url.pathname,
-        config.handlers.fetch.routes
-      );
-      const cfAttrs = config.extractCfAttributes === false ? {} : extractCfAttributes(request);
-      return {
-        name: `${request.method} ${url.pathname}`,
-        options: {
-          kind: SpanKind.SERVER,
-          attributes: {
-            "http.request.method": request.method,
-            "url.full": request.url,
-            ...routeService ? { "service.name": routeService, "autotel.route.service": routeService } : {},
-            ...cfAttrs
-          }
-        },
-        context: propagation.extract(context.active(), request.headers, headersGetter)
-      };
-    },
-    getAttributesFromResult: (response) => ({
-      "http.response.status_code": response.status
-    }),
-    executionSucces: (span, trigger, result) => {
-      if (result.status >= 500) {
-        span.setStatus({ code: SpanStatusCode.ERROR });
-      }
-      if (config.handlers.fetch.postProcess) {
-        const readableSpan = span;
-        config.handlers.fetch.postProcess(span, {
-          request: trigger,
-          response: result,
-          readable: readableSpan
-        });
-      }
-    }
-  };
+	return {
+		getInitialSpanInfo: (request) => {
+			const url = new URL(request.url);
+			const routeService = getServiceForPath(url.pathname, config.handlers.fetch.routes);
+			const cfAttrs = config.extractCfAttributes === false ? {} : extractCfAttributes(request);
+			return {
+				name: `${request.method} ${url.pathname}`,
+				options: {
+					kind: SpanKind.SERVER,
+					attributes: {
+						"http.request.method": request.method,
+						"url.full": request.url,
+						...routeService ? {
+							"service.name": routeService,
+							"autotel.route.service": routeService
+						} : {},
+						...cfAttrs
+					}
+				},
+				context: propagation.extract(context.active(), request.headers, headersGetter)
+			};
+		},
+		getAttributesFromResult: (response) => ({ "http.response.status_code": response.status }),
+		executionSucces: (span, trigger, result) => {
+			if (result.status >= 500) span.setStatus({ code: SpanStatusCode.ERROR });
+			if (config.handlers.fetch.postProcess) {
+				const readableSpan = span;
+				config.handlers.fetch.postProcess(span, {
+					request: trigger,
+					response: result,
+					readable: readableSpan
+				});
+			}
+		}
+	};
 }
-var scheduledInstrumentation = {
-  getInitialSpanInfo: (event) => {
-    return {
-      name: `scheduledHandler ${event.cron || "unknown"}`,
-      options: {
-        kind: SpanKind.INTERNAL,
-        attributes: {
-          "faas.trigger": "timer",
-          "faas.cron": event.cron || "unknown",
-          "faas.scheduled_time": new Date(event.scheduledTime).toISOString()
-        }
-      }
-    };
-  }
-};
+/**
+* Scheduled handler instrumentation
+*/
+const scheduledInstrumentation = { getInitialSpanInfo: (event) => {
+	return {
+		name: `scheduledHandler ${event.cron || "unknown"}`,
+		options: {
+			kind: SpanKind.INTERNAL,
+			attributes: {
+				"faas.trigger": "timer",
+				"faas.cron": event.cron || "unknown",
+				"faas.scheduled_time": new Date(event.scheduledTime).toISOString()
+			}
+		}
+	};
+} };
+/**
+* Tracks message status counts for queue processing
+*/
 var MessageStatusCount = class {
-  succeeded = 0;
-  failed = 0;
-  implicitly_acked = 0;
-  implicitly_retried = 0;
-  total;
-  constructor(total) {
-    this.total = total;
-  }
-  ack() {
-    this.succeeded = this.succeeded + 1;
-  }
-  ackRemaining() {
-    this.implicitly_acked = this.total - this.succeeded - this.failed;
-    this.succeeded = this.total - this.failed;
-  }
-  retry() {
-    this.failed = this.failed + 1;
-  }
-  retryRemaining() {
-    this.implicitly_retried = this.total - this.succeeded - this.failed;
-    this.failed = this.total - this.succeeded;
-  }
-  toAttributes() {
-    return {
-      "queue.messages_count": this.total,
-      "queue.messages_success": this.succeeded,
-      "queue.messages_failed": this.failed,
-      "queue.batch_success": this.succeeded === this.total,
-      "queue.implicitly_acked": this.implicitly_acked,
-      "queue.implicitly_retried": this.implicitly_retried
-    };
-  }
+	succeeded = 0;
+	failed = 0;
+	implicitly_acked = 0;
+	implicitly_retried = 0;
+	total;
+	constructor(total) {
+		this.total = total;
+	}
+	ack() {
+		this.succeeded = this.succeeded + 1;
+	}
+	ackRemaining() {
+		this.implicitly_acked = this.total - this.succeeded - this.failed;
+		this.succeeded = this.total - this.failed;
+	}
+	retry() {
+		this.failed = this.failed + 1;
+	}
+	retryRemaining() {
+		this.implicitly_retried = this.total - this.succeeded - this.failed;
+		this.failed = this.total - this.succeeded;
+	}
+	toAttributes() {
+		return {
+			"queue.messages_count": this.total,
+			"queue.messages_success": this.succeeded,
+			"queue.messages_failed": this.failed,
+			"queue.batch_success": this.succeeded === this.total,
+			"queue.implicitly_acked": this.implicitly_acked,
+			"queue.implicitly_retried": this.implicitly_retried
+		};
+	}
 };
+/**
+* Add event to active span
+*/
 function addQueueEvent(name, msg, delaySeconds) {
-  const attrs = {};
-  if (msg) {
-    attrs["queue.message_id"] = msg.id;
-    attrs["queue.message_timestamp"] = msg.timestamp.toISOString();
-    if ("attempts" in msg && typeof msg.attempts === "number") {
-      attrs["queue.message_attempts"] = msg.attempts;
-    }
-  }
-  if (delaySeconds !== void 0) {
-    attrs["queue.retry_delay_seconds"] = delaySeconds;
-  }
-  trace.getActiveSpan()?.addEvent(name, attrs);
+	const attrs = {};
+	if (msg) {
+		attrs["queue.message_id"] = msg.id;
+		attrs["queue.message_timestamp"] = msg.timestamp.toISOString();
+		if ("attempts" in msg && typeof msg.attempts === "number") attrs["queue.message_attempts"] = msg.attempts;
+	}
+	if (delaySeconds !== void 0) attrs["queue.retry_delay_seconds"] = delaySeconds;
+	trace.getActiveSpan()?.addEvent(name, attrs);
 }
+/**
+* Proxy a queue message to track ack/retry operations
+*/
 function proxyQueueMessage(msg, count) {
-  const msgHandler = {
-    get: (target, prop) => {
-      if (prop === "ack") {
-        const ackFn = Reflect.get(target, prop);
-        return new Proxy(ackFn, {
-          apply: (fnTarget) => {
-            addQueueEvent("messageAck", msg);
-            count.ack();
-            Reflect.apply(fnTarget, msg, []);
-          }
-        });
-      } else if (prop === "retry") {
-        const retryFn = Reflect.get(target, prop);
-        return new Proxy(retryFn, {
-          apply: (fnTarget, _thisArg, args) => {
-            const retryOptions = args[0];
-            const delaySeconds = retryOptions?.delaySeconds;
-            addQueueEvent("messageRetry", msg, delaySeconds);
-            if (retryOptions?.contentType) {
-              const span = trace.getActiveSpan();
-              if (span) {
-                span.setAttribute("queue.message.content_type", retryOptions.contentType);
-              }
-            }
-            count.retry();
-            const result = Reflect.apply(fnTarget, msg, args);
-            return result;
-          }
-        });
-      } else {
-        return Reflect.get(target, prop, msg);
-      }
-    }
-  };
-  return wrap(msg, msgHandler);
+	return wrap(msg, { get: (target, prop) => {
+		if (prop === "ack") {
+			const ackFn = Reflect.get(target, prop);
+			return new Proxy(ackFn, { apply: (fnTarget) => {
+				addQueueEvent("messageAck", msg);
+				count.ack();
+				Reflect.apply(fnTarget, msg, []);
+			} });
+		} else if (prop === "retry") {
+			const retryFn = Reflect.get(target, prop);
+			return new Proxy(retryFn, { apply: (fnTarget, _thisArg, args) => {
+				const retryOptions = args[0];
+				const delaySeconds = retryOptions?.delaySeconds;
+				addQueueEvent("messageRetry", msg, delaySeconds);
+				if (retryOptions?.contentType) {
+					const span = trace.getActiveSpan();
+					if (span) span.setAttribute("queue.message.content_type", retryOptions.contentType);
+				}
+				count.retry();
+				return Reflect.apply(fnTarget, msg, args);
+			} });
+		} else return Reflect.get(target, prop, msg);
+	} });
 }
+/**
+* Proxy MessageBatch to track ackAll/retryAll operations
+*/
 function proxyMessageBatch(batch, count) {
-  const batchHandler = {
-    get: (target, prop) => {
-      if (prop === "messages") {
-        const messages = Reflect.get(target, prop);
-        const messagesHandler = {
-          get: (target2, prop2) => {
-            if (typeof prop2 === "string" && !isNaN(parseInt(prop2))) {
-              const message = Reflect.get(target2, prop2);
-              return proxyQueueMessage(message, count);
-            } else {
-              return Reflect.get(target2, prop2);
-            }
-          }
-        };
-        return wrap(messages, messagesHandler);
-      } else if (prop === "ackAll") {
-        const ackFn = Reflect.get(target, prop);
-        return new Proxy(ackFn, {
-          apply: (fnTarget) => {
-            addQueueEvent("ackAll");
-            count.ackRemaining();
-            Reflect.apply(fnTarget, batch, []);
-          }
-        });
-      } else if (prop === "retryAll") {
-        const retryFn = Reflect.get(target, prop);
-        return new Proxy(retryFn, {
-          apply: (fnTarget, _thisArg, args) => {
-            const retryOptions = args[0];
-            const delaySeconds = retryOptions?.delaySeconds;
-            addQueueEvent("retryAll", void 0, delaySeconds);
-            count.retryRemaining();
-            Reflect.apply(fnTarget, batch, args);
-          }
-        });
-      }
-      return Reflect.get(target, prop);
-    }
-  };
-  return wrap(batch, batchHandler);
+	return wrap(batch, { get: (target, prop) => {
+		if (prop === "messages") return wrap(Reflect.get(target, prop), { get: (target, prop) => {
+			if (typeof prop === "string" && !isNaN(parseInt(prop))) return proxyQueueMessage(Reflect.get(target, prop), count);
+			else return Reflect.get(target, prop);
+		} });
+		else if (prop === "ackAll") {
+			const ackFn = Reflect.get(target, prop);
+			return new Proxy(ackFn, { apply: (fnTarget) => {
+				addQueueEvent("ackAll");
+				count.ackRemaining();
+				Reflect.apply(fnTarget, batch, []);
+			} });
+		} else if (prop === "retryAll") {
+			const retryFn = Reflect.get(target, prop);
+			return new Proxy(retryFn, { apply: (fnTarget, _thisArg, args) => {
+				const delaySeconds = args[0]?.delaySeconds;
+				addQueueEvent("retryAll", void 0, delaySeconds);
+				count.retryRemaining();
+				Reflect.apply(fnTarget, batch, args);
+			} });
+		}
+		return Reflect.get(target, prop);
+	} });
 }
+/**
+* Queue handler instrumentation with message tracking
+*/
 var QueueInstrumentation = class {
-  count;
-  getInitialSpanInfo(batch) {
-    return {
-      name: `queueHandler ${batch.queue || "unknown"}`,
-      options: {
-        kind: SpanKind.CONSUMER,
-        attributes: {
-          "faas.trigger": "pubsub",
-          "queue.name": batch.queue || "unknown"
-        }
-      }
-    };
-  }
-  instrumentTrigger(batch) {
-    this.count = new MessageStatusCount(batch.messages.length);
-    return proxyMessageBatch(batch, this.count);
-  }
-  executionSucces(span, _trigger, _result) {
-    if (this.count) {
-      this.count.ackRemaining();
-      span.setAttributes(this.count.toAttributes());
-    }
-  }
-  executionFailed(span, _trigger, _error) {
-    if (this.count) {
-      this.count.retryRemaining();
-      span.setAttributes(this.count.toAttributes());
-    }
-  }
+	count;
+	getInitialSpanInfo(batch) {
+		return {
+			name: `queueHandler ${batch.queue || "unknown"}`,
+			options: {
+				kind: SpanKind.CONSUMER,
+				attributes: {
+					"faas.trigger": "pubsub",
+					"queue.name": batch.queue || "unknown"
+				}
+			}
+		};
+	}
+	instrumentTrigger(batch) {
+		this.count = new MessageStatusCount(batch.messages.length);
+		return proxyMessageBatch(batch, this.count);
+	}
+	executionSucces(span, _trigger, _result) {
+		if (this.count) {
+			this.count.ackRemaining();
+			span.setAttributes(this.count.toAttributes());
+		}
+	}
+	executionFailed(span, _trigger, _error) {
+		if (this.count) {
+			this.count.retryRemaining();
+			span.setAttributes(this.count.toAttributes());
+		}
+	}
 };
+/**
+* Converts email headers into OpenTelemetry attributes.
+* When dataSafety.emailHeaderAllowlist is configured, only allowed headers are captured.
+*/
 function headerAttributes(message) {
-  const attrs = {};
-  if (message.headers instanceof Headers) {
-    const config = getActiveConfig();
-    const allowlist = config?.dataSafety?.emailHeaderAllowlist;
-    for (const [key, value] of message.headers.entries()) {
-      if (allowlist && !allowlist.includes(key.toLowerCase())) {
-        continue;
-      }
-      attrs[`email.header.${key}`] = value;
-    }
-  }
-  return attrs;
+	const attrs = {};
+	if (message.headers instanceof Headers) {
+		const allowlist = getActiveConfig()?.dataSafety?.emailHeaderAllowlist;
+		for (const [key, value] of message.headers.entries()) {
+			if (allowlist && !allowlist.includes(key.toLowerCase())) continue;
+			attrs[`email.header.${key}`] = value;
+		}
+	}
+	return attrs;
 }
-var emailInstrumentation = {
-  getInitialSpanInfo: (message) => {
-    const attributes = {
-      "faas.trigger": "other",
-      "messaging.destination.name": message.to || "unknown"
-    };
-    if ("headers" in message && message.headers instanceof Headers) {
-      const messageId = message.headers.get("Message-Id");
-      if (messageId) {
-        attributes["rpc.message.id"] = messageId;
-      }
-      Object.assign(attributes, headerAttributes(message));
-    }
-    return {
-      name: `emailHandler ${message.to || "unknown"}`,
-      options: {
-        kind: SpanKind.CONSUMER,
-        attributes
-      }
-    };
-  }
-};
+/**
+* Email handler instrumentation
+*/
+const emailInstrumentation = { getInitialSpanInfo: (message) => {
+	const attributes = {
+		"faas.trigger": "other",
+		"messaging.destination.name": message.to || "unknown"
+	};
+	if ("headers" in message && message.headers instanceof Headers) {
+		const messageId = message.headers.get("Message-Id");
+		if (messageId) attributes["rpc.message.id"] = messageId;
+		Object.assign(attributes, headerAttributes(message));
+	}
+	return {
+		name: `emailHandler ${message.to || "unknown"}`,
+		options: {
+			kind: SpanKind.CONSUMER,
+			attributes
+		}
+	};
+} };
+/**
+* Export spans after request completes
+*/
 async function exportSpans(traceId, tracker, ctx) {
-  const tracer = trace.getTracer("autotel-edge");
-  if (tracer instanceof WorkerTracer) {
-    try {
-      const ctxWithScheduler = ctx;
-      if (ctxWithScheduler.scheduler) {
-        await ctxWithScheduler.scheduler.wait(1);
-      }
-      await tracker?.wait();
-      await tracer.forceFlush(traceId);
-    } catch (error) {
-      console.error("[autotel-edge] Failed to export spans:", error);
-    }
-  }
+	const tracer = trace.getTracer("autotel-edge");
+	if (tracer instanceof WorkerTracer) try {
+		const ctxWithScheduler = ctx;
+		if (ctxWithScheduler.scheduler) await ctxWithScheduler.scheduler.wait(1);
+		await tracker?.wait();
+		await tracer.forceFlush(traceId);
+	} catch (error) {
+		console.error("[autotel-edge] Failed to export spans:", error);
+	}
 }
+/**
+* Create handler flow with instrumentation
+*/
 function createHandlerFlow(instrumentation) {
-  return (handlerFn, [trigger, env, context$1]) => {
-    const { ctx: proxiedCtx, tracker } = proxyExecutionContext(context$1);
-    const tracer = trace.getTracer("autotel-edge");
-    const { name, options, context: spanContext } = instrumentation.getInitialSpanInfo(trigger);
-    if (options.attributes) {
-      options.attributes["faas.coldstart"] = coldStart;
-    } else {
-      options.attributes = { "faas.coldstart": coldStart };
-    }
-    coldStart = false;
-    const parentContext = spanContext || context.active();
-    const instrumentedTrigger = instrumentation.instrumentTrigger ? instrumentation.instrumentTrigger(trigger) : trigger;
-    return tracer.startActiveSpan(name, options, parentContext, async (span) => {
-      try {
-        const result = await handlerFn(instrumentedTrigger, env, proxiedCtx);
-        if (instrumentation.getAttributesFromResult) {
-          const attributes = instrumentation.getAttributesFromResult(result);
-          span.setAttributes(attributes);
-        }
-        span.setStatus({ code: SpanStatusCode.OK });
-        if (instrumentation.executionSucces) {
-          instrumentation.executionSucces(span, trigger, result);
-        }
-        return result;
-      } catch (error) {
-        span.recordException(error);
-        span.setStatus({
-          code: SpanStatusCode.ERROR,
-          message: error instanceof Error ? error.message : String(error)
-        });
-        if (instrumentation.executionFailed) {
-          instrumentation.executionFailed(span, trigger, error);
-        }
-        throw error;
-      } finally {
-        span.end();
-        context$1.waitUntil(exportSpans(span.spanContext().traceId, tracker, context$1));
-      }
-    });
-  };
+	return (handlerFn, [trigger, env, context$1]) => {
+		const { ctx: proxiedCtx, tracker } = proxyExecutionContext(context$1);
+		const tracer = trace.getTracer("autotel-edge");
+		const { name, options, context: spanContext } = instrumentation.getInitialSpanInfo(trigger);
+		if (options.attributes) options.attributes["faas.coldstart"] = coldStart;
+		else options.attributes = { "faas.coldstart": coldStart };
+		coldStart = false;
+		const parentContext = spanContext || context.active();
+		const instrumentedTrigger = instrumentation.instrumentTrigger ? instrumentation.instrumentTrigger(trigger) : trigger;
+		return tracer.startActiveSpan(name, options, parentContext, async (span) => {
+			try {
+				const result = await handlerFn(instrumentedTrigger, env, proxiedCtx);
+				if (instrumentation.getAttributesFromResult) {
+					const attributes = instrumentation.getAttributesFromResult(result);
+					span.setAttributes(attributes);
+				}
+				span.setStatus({ code: SpanStatusCode.OK });
+				if (instrumentation.executionSucces) instrumentation.executionSucces(span, trigger, result);
+				return result;
+			} catch (error) {
+				span.recordException(error);
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: error instanceof Error ? error.message : String(error)
+				});
+				if (instrumentation.executionFailed) instrumentation.executionFailed(span, trigger, error);
+				throw error;
+			} finally {
+				span.end();
+				context$1.waitUntil(exportSpans(span.spanContext().traceId, tracker, context$1));
+			}
+		});
+	};
 }
+/**
+* Create handler proxy
+*/
 function createHandlerProxy(_handler, handlerFn, initialiser, instrumentation) {
-  return (trigger, env, ctx) => {
-    const config = initialiser(env, trigger);
-    if (config.instrumentation.disabled) {
-      return handlerFn(trigger, env, ctx);
-    }
-    const instrumentedEnv = instrumentBindings(env);
-    const configContext = setConfig(config);
-    initProvider(config);
-    const flowFn = createHandlerFlow(instrumentation);
-    return context.with(configContext, () => {
-      return flowFn(handlerFn, [trigger, instrumentedEnv, ctx]);
-    });
-  };
+	return (trigger, env, ctx) => {
+		const config = initialiser(env, trigger);
+		if (config.instrumentation.disabled) return handlerFn(trigger, env, ctx);
+		const instrumentedEnv = instrumentBindings(env);
+		const configContext = setConfig(config);
+		initProvider(config);
+		const flowFn = createHandlerFlow(instrumentation);
+		return context.with(configContext, () => {
+			return flowFn(handlerFn, [
+				trigger,
+				instrumentedEnv,
+				ctx
+			]);
+		});
+	};
 }
+/**
+* Create handler proxy with dynamic instrumentation (for fetch with postProcess)
+*/
 function createHandlerProxyWithConfig(_handler, handlerFn, initialiser, createInstrumentation) {
-  return (trigger, env, ctx) => {
-    const config = initialiser(env, trigger);
-    if (config.instrumentation.disabled) {
-      return handlerFn(trigger, env, ctx);
-    }
-    if (trigger instanceof Request) {
-      const pathname = new URL(trigger.url).pathname;
-      const fetchCfg = config.handlers.fetch;
-      if (!shouldInstrumentPath(pathname, {
-        include: fetchCfg.include,
-        exclude: fetchCfg.exclude
-      })) {
-        return handlerFn(trigger, env, ctx);
-      }
-    }
-    const instrumentedEnv = instrumentBindings(env);
-    const configContext = setConfig(config);
-    initProvider(config);
-    const instrumentation = createInstrumentation(config);
-    const flowFn = createHandlerFlow(instrumentation);
-    return context.with(configContext, () => {
-      return flowFn(handlerFn, [trigger, instrumentedEnv, ctx]);
-    });
-  };
+	return (trigger, env, ctx) => {
+		const config = initialiser(env, trigger);
+		if (config.instrumentation.disabled) return handlerFn(trigger, env, ctx);
+		if (trigger instanceof Request) {
+			const pathname = new URL(trigger.url).pathname;
+			const fetchCfg = config.handlers.fetch;
+			if (!shouldInstrumentPath(pathname, {
+				include: fetchCfg.include,
+				exclude: fetchCfg.exclude
+			})) return handlerFn(trigger, env, ctx);
+		}
+		const instrumentedEnv = instrumentBindings(env);
+		const configContext = setConfig(config);
+		initProvider(config);
+		const flowFn = createHandlerFlow(createInstrumentation(config));
+		return context.with(configContext, () => {
+			return flowFn(handlerFn, [
+				trigger,
+				instrumentedEnv,
+				ctx
+			]);
+		});
+	};
 }
-var providerInitialized = false;
-var coldStart = true;
+let providerInitialized = false;
+let coldStart = true;
+/**
+* Initialize the tracer provider
+*/
 function initProvider(config) {
-  if (providerInitialized) return;
-  if (config.instrumentation.instrumentGlobalFetch) {
-    instrumentGlobalFetch();
-  }
-  if (config.instrumentation.instrumentGlobalCache) {
-    instrumentGlobalCache();
-  }
-  propagation.setGlobalPropagator(config.propagator);
-  const resource = resourceFromAttributes({
-    "service.name": config.service.name,
-    "service.version": config.service.version,
-    "service.namespace": config.service.namespace,
-    "cloud.provider": "cloudflare",
-    "cloud.platform": "cloudflare.workers",
-    "telemetry.sdk.name": "autotel-edge",
-    "telemetry.sdk.language": "js"
-  });
-  const provider = new WorkerTracerProvider(config.spanProcessors, resource);
-  provider.register();
-  const tracer = trace.getTracer("autotel-edge");
-  tracer.setHeadSampler(config.sampling.headSampler);
-  providerInitialized = true;
+	if (providerInitialized) return;
+	if (config.instrumentation.instrumentGlobalFetch) instrumentGlobalFetch();
+	if (config.instrumentation.instrumentGlobalCache) instrumentGlobalCache();
+	propagation.setGlobalPropagator(config.propagator);
+	const resource = resourceFromAttributes({
+		"service.name": config.service.name,
+		"service.version": config.service.version,
+		"service.namespace": config.service.namespace,
+		"cloud.provider": "cloudflare",
+		"cloud.platform": "cloudflare.workers",
+		"telemetry.sdk.name": "autotel-edge",
+		"telemetry.sdk.language": "js"
+	});
+	new WorkerTracerProvider(config.spanProcessors, resource).register();
+	trace.getTracer("autotel-edge").setHeadSampler(config.sampling.headSampler);
+	providerInitialized = true;
 }
+/**
+* Instrument a Cloudflare Workers handler
+*
+* @example
+* ```typescript
+* import { instrument } from 'autotel-edge'
+*
+* const handler = {
+*   async fetch(request, env, ctx) {
+*     return new Response('Hello World')
+*   }
+* }
+*
+* export default instrument(handler, {
+*   exporter: {
+*     url: env.OTLP_ENDPOINT,
+*     headers: { 'x-api-key': env.API_KEY }
+*   },
+*   service: { name: 'my-worker' }
+* })
+* ```
+*/
 function instrument(handler, config) {
-  const initialiser = createInitialiser(config);
-  if (handler.fetch) {
-    const fetcher = unwrap(handler.fetch);
-    handler.fetch = createHandlerProxyWithConfig(
-      handler,
-      fetcher,
-      initialiser,
-      createFetchInstrumentation
-    );
-  }
-  if (handler.scheduled) {
-    const scheduled = unwrap(handler.scheduled);
-    handler.scheduled = createHandlerProxy(
-      handler,
-      scheduled,
-      initialiser,
-      scheduledInstrumentation
-    );
-  }
-  if (handler.queue) {
-    const queue = unwrap(handler.queue);
-    handler.queue = createHandlerProxy(
-      handler,
-      queue,
-      initialiser,
-      new QueueInstrumentation()
-    );
-  }
-  if (handler.email) {
-    const email = unwrap(handler.email);
-    handler.email = createHandlerProxy(
-      handler,
-      email,
-      initialiser,
-      emailInstrumentation
-    );
-  }
-  return handler;
+	const initialiser = createInitialiser(config);
+	if (handler.fetch) handler.fetch = createHandlerProxyWithConfig(handler, unwrap(handler.fetch), initialiser, createFetchInstrumentation);
+	if (handler.scheduled) handler.scheduled = createHandlerProxy(handler, unwrap(handler.scheduled), initialiser, scheduledInstrumentation);
+	if (handler.queue) handler.queue = createHandlerProxy(handler, unwrap(handler.queue), initialiser, new QueueInstrumentation());
+	if (handler.email) handler.email = createHandlerProxy(handler, unwrap(handler.email), initialiser, emailInstrumentation);
+	return handler;
 }
 
-// src/wrappers/wrap-module.ts
+//#endregion
+//#region src/wrappers/wrap-module.ts
+/**
+* workers-honeycomb-logger style wrapper API
+*
+* @example
+* ```typescript
+* import { wrapModule } from 'autotel-cloudflare'
+*
+* const handler = {
+*   async fetch(req, env, ctx) {
+*     return new Response('Hello')
+*   }
+* }
+*
+* export default wrapModule(
+*   { service: { name: 'my-worker' } },
+*   handler
+* )
+* ```
+*/
+/**
+* Wrap a Cloudflare Workers module-style handler
+* Alternative API style inspired by workers-honeycomb-logger
+*
+* @param config Configuration (can be static object or function)
+* @param handler The worker handler to wrap
+* @returns Instrumented handler
+*/
 function wrapModule(config, handler) {
-  return instrument(handler, config);
+	return instrument(handler, config);
 }
 
-// src/wrappers/wrap-do.ts
+//#endregion
+//#region src/wrappers/wrap-do.ts
+/**
+* Durable Object wrapper
+*
+* @example
+* ```typescript
+* import { wrapDurableObject } from 'autotel-cloudflare'
+*
+* class Counter implements DurableObject {
+*   async fetch(request: Request) {
+*     return new Response('count')
+*   }
+* }
+*
+* export default wrapDurableObject({ service: { name: 'counter-do' } }, Counter)
+* ```
+*/
+/**
+* Wrap a Durable Object class with instrumentation
+* Alternative API style inspired by workers-honeycomb-logger
+*
+* @param config Configuration (can be static object or function)
+* @param doClass The Durable Object class to wrap
+* @returns Instrumented Durable Object class
+*/
 function wrapDurableObject(config, doClass) {
-  return instrumentDO(doClass, config);
+	return instrumentDO(doClass, config);
 }
 
-// src/wrappers/define-worker-fetch.ts
+//#endregion
+//#region src/wrappers/define-worker-fetch.ts
+/**
+* Wrap a Workers fetch handler so:
+*   - the handler is instrumented (spans, propagation, waitUntil export flush)
+*   - the handler receives a request-scoped logger as its fourth argument
+*/
 function defineWorkerFetch(config, handler, loggerOptions = {}) {
-  const wrapped = instrument(
-    {
-      fetch(request, env, ctx) {
-        const log = createWorkersLogger(request, loggerOptions);
-        return handler(request, env, ctx, log);
-      }
-    },
-    config
-  );
-  return {
-    fetch(request, env, ctx) {
-      return Promise.resolve(
-        wrapped.fetch(request, env, ctx)
-      );
-    }
-  };
+	const wrapped = instrument({ fetch(request, env, ctx) {
+		return handler(request, env, ctx, createWorkersLogger(request, loggerOptions));
+	} }, config);
+	return { fetch(request, env, ctx) {
+		return Promise.resolve(wrapped.fetch(request, env, ctx));
+	} };
 }
 
-export { defineWorkerFetch, instrument, instrumentGlobalCache, instrumentGlobalFetch, wrapDurableObject, wrapModule };
-//# sourceMappingURL=index.js.map
+//#endregion
+export { createWorkersLogger, defineWorkerFetch, getActorLogger, getQueueLogger, getRequestLogger, getWorkflowLogger, instrument, instrumentAI, instrumentAnalyticsEngine, instrumentBindings, instrumentBrowserRendering, instrumentD1, instrumentDO, instrumentGlobalCache, instrumentGlobalFetch, instrumentHyperdrive, instrumentImages, instrumentKV, instrumentQueueProducer, instrumentR2, instrumentRateLimiter, instrumentServiceBinding, instrumentVectorize, instrumentWorkflow, wrapDurableObject, wrapModule };
 //# sourceMappingURL=index.js.map