autotel-cloudflare 2.18.18 → 2.19.0

package/dist/actors.js

@@ -1,1030 +1,1034 @@
-import { wrap } from './chunk-O4IYKWPJ.js';
-import { propagation, SpanKind, SpanStatusCode, context, trace } from '@opentelemetry/api';
-import { createInitialiser, setConfig } from 'autotel-edge';
+import { a as wrap } from "./common-DiWH6nmG.js";
+import { createInitialiser, setConfig } from "autotel-edge";
+import { SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
 
-function getTracer() {
-  return trace.getTracer("autotel-cloudflare-actors");
+//#region src/actors/storage.ts
+/**
+* Actor storage instrumentation
+*
+* Traces operations on actor.storage including SQL queries
+*/
+/**
+* Get the tracer instance
+*/
+function getTracer$4() {
+	return trace.getTracer("autotel-cloudflare-actors");
 }
+/**
+* Instrument Actor storage for tracing
+*
+* Captures:
+* - SQL query operations
+* - Key-value operations (if available)
+*/
 function instrumentActorStorage(storage, actorInstance, actorClass) {
-  if (!storage || typeof storage !== "object") {
-    return storage;
-  }
-  const actorClassName = actorClass.name || "Actor";
-  const actorName = actorInstance.name || actorClassName;
-  const storageHandler = {
-    get(target, prop) {
-      const value = Reflect.get(target, prop);
-      if (prop === "exec" && typeof value === "function") {
-        return function instrumentedExec(query, ...params) {
-          const tracer = getTracer();
-          const spanName = `Actor ${actorName}: storage.exec`;
-          return tracer.startActiveSpan(
-            spanName,
-            {
-              kind: SpanKind.CLIENT,
-              attributes: {
-                "actor.name": actorName,
-                "actor.class": actorClassName,
-                "db.system": "sqlite",
-                "db.operation": "exec",
-                "db.statement": query,
-                "db.statement.params_count": params.length
-              }
-            },
-            (span) => {
-              try {
-                const result = value.call(target, query, ...params);
-                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();
-              }
-            }
-          );
-        };
-      }
-      if (prop === "query" && typeof value === "function") {
-        return function instrumentedQuery(query, ...params) {
-          const tracer = getTracer();
-          const spanName = `Actor ${actorName}: storage.query`;
-          return tracer.startActiveSpan(
-            spanName,
-            {
-              kind: SpanKind.CLIENT,
-              attributes: {
-                "actor.name": actorName,
-                "actor.class": actorClassName,
-                "db.system": "sqlite",
-                "db.operation": "query",
-                "db.statement": query,
-                "db.statement.params_count": params.length
-              }
-            },
-            (span) => {
-              try {
-                const result = value.call(target, query, ...params);
-                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();
-              }
-            }
-          );
-        };
-      }
-      if (prop === "get" && typeof value === "function") {
-        return async function instrumentedGet(key) {
-          const tracer = getTracer();
-          const spanName = `Actor ${actorName}: storage.get`;
-          return tracer.startActiveSpan(
-            spanName,
-            {
-              kind: SpanKind.CLIENT,
-              attributes: {
-                "actor.name": actorName,
-                "actor.class": actorClassName,
-                "db.system": "durable_object_storage",
-                "db.operation": "get",
-                "db.key": key
-              }
-            },
-            async (span) => {
-              try {
-                const result = await value.call(target, key);
-                span.setAttributes({
-                  "db.result.found": result !== null && result !== void 0
-                });
-                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();
-              }
-            }
-          );
-        };
-      }
-      if (prop === "put" && typeof value === "function") {
-        return async function instrumentedPut(key, val) {
-          const tracer = getTracer();
-          const spanName = `Actor ${actorName}: storage.put`;
-          return tracer.startActiveSpan(
-            spanName,
-            {
-              kind: SpanKind.CLIENT,
-              attributes: {
-                "actor.name": actorName,
-                "actor.class": actorClassName,
-                "db.system": "durable_object_storage",
-                "db.operation": "put",
-                "db.key": key,
-                "db.value_type": typeof val
-              }
-            },
-            async (span) => {
-              try {
-                await value.call(target, key, val);
-                span.setStatus({ code: SpanStatusCode.OK });
-              } catch (error) {
-                span.recordException(error);
-                span.setStatus({
-                  code: SpanStatusCode.ERROR,
-                  message: error instanceof Error ? error.message : String(error)
-                });
-                throw error;
-              } finally {
-                span.end();
-              }
-            }
-          );
-        };
-      }
-      if (prop === "delete" && typeof value === "function") {
-        return async function instrumentedDelete(key) {
-          const tracer = getTracer();
-          const spanName = `Actor ${actorName}: storage.delete`;
-          return tracer.startActiveSpan(
-            spanName,
-            {
-              kind: SpanKind.CLIENT,
-              attributes: {
-                "actor.name": actorName,
-                "actor.class": actorClassName,
-                "db.system": "durable_object_storage",
-                "db.operation": "delete",
-                "db.key": key
-              }
-            },
-            async (span) => {
-              try {
-                const result = await value.call(target, key);
-                span.setAttributes({
-                  "db.result.deleted": 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();
-              }
-            }
-          );
-        };
-      }
-      if (typeof value === "function") {
-        return value.bind(target);
-      }
-      return value;
-    }
-  };
-  return wrap(storage, storageHandler);
+	if (!storage || typeof storage !== "object") return storage;
+	const actorClassName = actorClass.name || "Actor";
+	const actorName = actorInstance.name || actorClassName;
+	return wrap(storage, { get(target, prop) {
+		const value = Reflect.get(target, prop);
+		if (prop === "exec" && typeof value === "function") return function instrumentedExec(query, ...params) {
+			const tracer = getTracer$4();
+			const spanName = `Actor ${actorName}: storage.exec`;
+			return tracer.startActiveSpan(spanName, {
+				kind: SpanKind.CLIENT,
+				attributes: {
+					"actor.name": actorName,
+					"actor.class": actorClassName,
+					"db.system": "sqlite",
+					"db.operation": "exec",
+					"db.statement": query,
+					"db.statement.params_count": params.length
+				}
+			}, (span) => {
+				try {
+					const result = value.call(target, query, ...params);
+					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();
+				}
+			});
+		};
+		if (prop === "query" && typeof value === "function") return function instrumentedQuery(query, ...params) {
+			const tracer = getTracer$4();
+			const spanName = `Actor ${actorName}: storage.query`;
+			return tracer.startActiveSpan(spanName, {
+				kind: SpanKind.CLIENT,
+				attributes: {
+					"actor.name": actorName,
+					"actor.class": actorClassName,
+					"db.system": "sqlite",
+					"db.operation": "query",
+					"db.statement": query,
+					"db.statement.params_count": params.length
+				}
+			}, (span) => {
+				try {
+					const result = value.call(target, query, ...params);
+					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();
+				}
+			});
+		};
+		if (prop === "get" && typeof value === "function") return async function instrumentedGet(key) {
+			const tracer = getTracer$4();
+			const spanName = `Actor ${actorName}: storage.get`;
+			return tracer.startActiveSpan(spanName, {
+				kind: SpanKind.CLIENT,
+				attributes: {
+					"actor.name": actorName,
+					"actor.class": actorClassName,
+					"db.system": "durable_object_storage",
+					"db.operation": "get",
+					"db.key": key
+				}
+			}, async (span) => {
+				try {
+					const result = await value.call(target, key);
+					span.setAttributes({ "db.result.found": result !== null && result !== void 0 });
+					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();
+				}
+			});
+		};
+		if (prop === "put" && typeof value === "function") return async function instrumentedPut(key, val) {
+			const tracer = getTracer$4();
+			const spanName = `Actor ${actorName}: storage.put`;
+			return tracer.startActiveSpan(spanName, {
+				kind: SpanKind.CLIENT,
+				attributes: {
+					"actor.name": actorName,
+					"actor.class": actorClassName,
+					"db.system": "durable_object_storage",
+					"db.operation": "put",
+					"db.key": key,
+					"db.value_type": typeof val
+				}
+			}, async (span) => {
+				try {
+					await value.call(target, key, val);
+					span.setStatus({ code: SpanStatusCode.OK });
+				} catch (error) {
+					span.recordException(error);
+					span.setStatus({
+						code: SpanStatusCode.ERROR,
+						message: error instanceof Error ? error.message : String(error)
+					});
+					throw error;
+				} finally {
+					span.end();
+				}
+			});
+		};
+		if (prop === "delete" && typeof value === "function") return async function instrumentedDelete(key) {
+			const tracer = getTracer$4();
+			const spanName = `Actor ${actorName}: storage.delete`;
+			return tracer.startActiveSpan(spanName, {
+				kind: SpanKind.CLIENT,
+				attributes: {
+					"actor.name": actorName,
+					"actor.class": actorClassName,
+					"db.system": "durable_object_storage",
+					"db.operation": "delete",
+					"db.key": key
+				}
+			}, async (span) => {
+				try {
+					const result = await value.call(target, key);
+					span.setAttributes({ "db.result.deleted": 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();
+				}
+			});
+		};
+		if (typeof value === "function") return value.bind(target);
+		return value;
+	} });
 }
-function getTracer2() {
-  return trace.getTracer("autotel-cloudflare-actors");
+
+//#endregion
+//#region src/actors/alarms.ts
+/**
+* Actor alarms instrumentation
+*
+* Traces operations on actor.alarms
+*/
+/**
+* Get the tracer instance
+*/
+function getTracer$3() {
+	return trace.getTracer("autotel-cloudflare-actors");
 }
+/**
+* Instrument Actor alarms for tracing
+*
+* Captures:
+* - set: Schedule a single alarm
+* - setMultiple: Schedule multiple alarms
+* - cancel: Cancel an alarm
+* - cancelAll: Cancel all alarms
+*/
 function instrumentActorAlarms(alarms, actorInstance, actorClass) {
-  if (!alarms || typeof alarms !== "object") {
-    return alarms;
-  }
-  const actorClassName = actorClass.name || "Actor";
-  const actorName = actorInstance.name || actorClassName;
-  const alarmsHandler = {
-    get(target, prop) {
-      const value = Reflect.get(target, prop);
-      if (prop === "set" && typeof value === "function") {
-        return async function instrumentedSet(...args) {
-          const tracer = getTracer2();
-          const spanName = `Actor ${actorName}: alarms.set`;
-          const alarmAttributes = {
-            "actor.name": actorName,
-            "actor.class": actorClassName,
-            "alarm.operation": "set"
-          };
-          if (args.length > 0) {
-            const firstArg = args[0];
-            if (typeof firstArg === "number") {
-              alarmAttributes["alarm.delay_ms"] = firstArg;
-            } else if (firstArg instanceof Date) {
-              alarmAttributes["alarm.scheduled_time"] = firstArg.toISOString();
-            } else if (typeof firstArg === "string") {
-              alarmAttributes["alarm.cron"] = firstArg;
-            }
-          }
-          return tracer.startActiveSpan(
-            spanName,
-            {
-              kind: SpanKind.CLIENT,
-              attributes: alarmAttributes
-            },
-            async (span) => {
-              try {
-                const result = await value.apply(target, args);
-                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();
-              }
-            }
-          );
-        };
-      }
-      if (prop === "setMultiple" && typeof value === "function") {
-        return async function instrumentedSetMultiple(alarmDefs) {
-          const tracer = getTracer2();
-          const spanName = `Actor ${actorName}: alarms.setMultiple`;
-          return tracer.startActiveSpan(
-            spanName,
-            {
-              kind: SpanKind.CLIENT,
-              attributes: {
-                "actor.name": actorName,
-                "actor.class": actorClassName,
-                "alarm.operation": "setMultiple",
-                "alarm.count": Array.isArray(alarmDefs) ? alarmDefs.length : 0
-              }
-            },
-            async (span) => {
-              try {
-                const result = await value.call(target, alarmDefs);
-                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();
-              }
-            }
-          );
-        };
-      }
-      if (prop === "cancel" && typeof value === "function") {
-        return async function instrumentedCancel(alarmId) {
-          const tracer = getTracer2();
-          const spanName = `Actor ${actorName}: alarms.cancel`;
-          return tracer.startActiveSpan(
-            spanName,
-            {
-              kind: SpanKind.CLIENT,
-              attributes: {
-                "actor.name": actorName,
-                "actor.class": actorClassName,
-                "alarm.operation": "cancel",
-                "alarm.id": alarmId
-              }
-            },
-            async (span) => {
-              try {
-                const result = await value.call(target, alarmId);
-                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();
-              }
-            }
-          );
-        };
-      }
-      if (prop === "cancelAll" && typeof value === "function") {
-        return async function instrumentedCancelAll() {
-          const tracer = getTracer2();
-          const spanName = `Actor ${actorName}: alarms.cancelAll`;
-          return tracer.startActiveSpan(
-            spanName,
-            {
-              kind: SpanKind.CLIENT,
-              attributes: {
-                "actor.name": actorName,
-                "actor.class": actorClassName,
-                "alarm.operation": "cancelAll"
-              }
-            },
-            async (span) => {
-              try {
-                const result = await value.call(target);
-                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();
-              }
-            }
-          );
-        };
-      }
-      if (typeof value === "function") {
-        return value.bind(target);
-      }
-      return value;
-    }
-  };
-  return wrap(alarms, alarmsHandler);
+	if (!alarms || typeof alarms !== "object") return alarms;
+	const actorClassName = actorClass.name || "Actor";
+	const actorName = actorInstance.name || actorClassName;
+	return wrap(alarms, { get(target, prop) {
+		const value = Reflect.get(target, prop);
+		if (prop === "set" && typeof value === "function") return async function instrumentedSet(...args) {
+			const tracer = getTracer$3();
+			const spanName = `Actor ${actorName}: alarms.set`;
+			const alarmAttributes = {
+				"actor.name": actorName,
+				"actor.class": actorClassName,
+				"alarm.operation": "set"
+			};
+			if (args.length > 0) {
+				const firstArg = args[0];
+				if (typeof firstArg === "number") alarmAttributes["alarm.delay_ms"] = firstArg;
+				else if (firstArg instanceof Date) alarmAttributes["alarm.scheduled_time"] = firstArg.toISOString();
+				else if (typeof firstArg === "string") alarmAttributes["alarm.cron"] = firstArg;
+			}
+			return tracer.startActiveSpan(spanName, {
+				kind: SpanKind.CLIENT,
+				attributes: alarmAttributes
+			}, async (span) => {
+				try {
+					const result = await value.apply(target, args);
+					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();
+				}
+			});
+		};
+		if (prop === "setMultiple" && typeof value === "function") return async function instrumentedSetMultiple(alarmDefs) {
+			const tracer = getTracer$3();
+			const spanName = `Actor ${actorName}: alarms.setMultiple`;
+			return tracer.startActiveSpan(spanName, {
+				kind: SpanKind.CLIENT,
+				attributes: {
+					"actor.name": actorName,
+					"actor.class": actorClassName,
+					"alarm.operation": "setMultiple",
+					"alarm.count": Array.isArray(alarmDefs) ? alarmDefs.length : 0
+				}
+			}, async (span) => {
+				try {
+					const result = await value.call(target, alarmDefs);
+					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();
+				}
+			});
+		};
+		if (prop === "cancel" && typeof value === "function") return async function instrumentedCancel(alarmId) {
+			const tracer = getTracer$3();
+			const spanName = `Actor ${actorName}: alarms.cancel`;
+			return tracer.startActiveSpan(spanName, {
+				kind: SpanKind.CLIENT,
+				attributes: {
+					"actor.name": actorName,
+					"actor.class": actorClassName,
+					"alarm.operation": "cancel",
+					"alarm.id": alarmId
+				}
+			}, async (span) => {
+				try {
+					const result = await value.call(target, alarmId);
+					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();
+				}
+			});
+		};
+		if (prop === "cancelAll" && typeof value === "function") return async function instrumentedCancelAll() {
+			const tracer = getTracer$3();
+			const spanName = `Actor ${actorName}: alarms.cancelAll`;
+			return tracer.startActiveSpan(spanName, {
+				kind: SpanKind.CLIENT,
+				attributes: {
+					"actor.name": actorName,
+					"actor.class": actorClassName,
+					"alarm.operation": "cancelAll"
+				}
+			}, async (span) => {
+				try {
+					const result = await value.call(target);
+					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();
+				}
+			});
+		};
+		if (typeof value === "function") return value.bind(target);
+		return value;
+	} });
 }
-function getTracer3() {
-  return trace.getTracer("autotel-cloudflare-actors");
+
+//#endregion
+//#region src/actors/sockets.ts
+/**
+* Actor sockets instrumentation
+*
+* Traces operations on actor.sockets
+*/
+/**
+* Get the tracer instance
+*/
+function getTracer$2() {
+	return trace.getTracer("autotel-cloudflare-actors");
 }
+/**
+* Instrument Actor sockets for tracing
+*
+* Captures:
+* - acceptWebSocket: Accept an incoming WebSocket connection
+* - broadcast: Send message to all connected sockets
+* - send: Send message to a specific socket
+*/
 function instrumentActorSockets(sockets, actorInstance, actorClass) {
-  if (!sockets || typeof sockets !== "object") {
-    return sockets;
-  }
-  const actorClassName = actorClass.name || "Actor";
-  const actorName = actorInstance.name || actorClassName;
-  const socketsHandler = {
-    get(target, prop) {
-      const value = Reflect.get(target, prop);
-      if (prop === "acceptWebSocket" && typeof value === "function") {
-        return function instrumentedAcceptWebSocket(request) {
-          const tracer = getTracer3();
-          const spanName = `Actor ${actorName}: sockets.acceptWebSocket`;
-          return tracer.startActiveSpan(
-            spanName,
-            {
-              kind: SpanKind.SERVER,
-              attributes: {
-                "actor.name": actorName,
-                "actor.class": actorClassName,
-                "websocket.operation": "accept",
-                "url.full": request.url
-              }
-            },
-            (span) => {
-              try {
-                const result = value.call(target, request);
-                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();
-              }
-            }
-          );
-        };
-      }
-      if (prop === "broadcast" && typeof value === "function") {
-        return function instrumentedBroadcast(message) {
-          const tracer = getTracer3();
-          const spanName = `Actor ${actorName}: sockets.broadcast`;
-          tracer.startActiveSpan(
-            spanName,
-            {
-              kind: SpanKind.PRODUCER,
-              attributes: {
-                "actor.name": actorName,
-                "actor.class": actorClassName,
-                "websocket.operation": "broadcast",
-                "websocket.message.type": typeof message,
-                "websocket.message.size": typeof message === "string" ? message.length : message instanceof ArrayBuffer ? message.byteLength : 0
-              }
-            },
-            (span) => {
-              try {
-                value.call(target, message);
-                span.setStatus({ code: SpanStatusCode.OK });
-              } catch (error) {
-                span.recordException(error);
-                span.setStatus({
-                  code: SpanStatusCode.ERROR,
-                  message: error instanceof Error ? error.message : String(error)
-                });
-                throw error;
-              } finally {
-                span.end();
-              }
-            }
-          );
-        };
-      }
-      if (prop === "send" && typeof value === "function") {
-        return function instrumentedSend(ws, message) {
-          const tracer = getTracer3();
-          const spanName = `Actor ${actorName}: sockets.send`;
-          tracer.startActiveSpan(
-            spanName,
-            {
-              kind: SpanKind.PRODUCER,
-              attributes: {
-                "actor.name": actorName,
-                "actor.class": actorClassName,
-                "websocket.operation": "send",
-                "websocket.message.type": typeof message,
-                "websocket.message.size": typeof message === "string" ? message.length : message instanceof ArrayBuffer ? message.byteLength : 0
-              }
-            },
-            (span) => {
-              try {
-                value.call(target, ws, message);
-                span.setStatus({ code: SpanStatusCode.OK });
-              } catch (error) {
-                span.recordException(error);
-                span.setStatus({
-                  code: SpanStatusCode.ERROR,
-                  message: error instanceof Error ? error.message : String(error)
-                });
-                throw error;
-              } finally {
-                span.end();
-              }
-            }
-          );
-        };
-      }
-      if (prop === "getConnections" && typeof value === "function") {
-        return function instrumentedGetConnections() {
-          const tracer = getTracer3();
-          const spanName = `Actor ${actorName}: sockets.getConnections`;
-          return tracer.startActiveSpan(
-            spanName,
-            {
-              kind: SpanKind.CLIENT,
-              attributes: {
-                "actor.name": actorName,
-                "actor.class": actorClassName,
-                "websocket.operation": "getConnections"
-              }
-            },
-            (span) => {
-              try {
-                const result = value.call(target);
-                if (Array.isArray(result)) {
-                  span.setAttribute("websocket.connections.count", result.length);
-                }
-                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();
-              }
-            }
-          );
-        };
-      }
-      if (typeof value === "function") {
-        return value.bind(target);
-      }
-      return value;
-    }
-  };
-  return wrap(sockets, socketsHandler);
+	if (!sockets || typeof sockets !== "object") return sockets;
+	const actorClassName = actorClass.name || "Actor";
+	const actorName = actorInstance.name || actorClassName;
+	return wrap(sockets, { get(target, prop) {
+		const value = Reflect.get(target, prop);
+		if (prop === "acceptWebSocket" && typeof value === "function") return function instrumentedAcceptWebSocket(request) {
+			const tracer = getTracer$2();
+			const spanName = `Actor ${actorName}: sockets.acceptWebSocket`;
+			return tracer.startActiveSpan(spanName, {
+				kind: SpanKind.SERVER,
+				attributes: {
+					"actor.name": actorName,
+					"actor.class": actorClassName,
+					"websocket.operation": "accept",
+					"url.full": request.url
+				}
+			}, (span) => {
+				try {
+					const result = value.call(target, request);
+					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();
+				}
+			});
+		};
+		if (prop === "broadcast" && typeof value === "function") return function instrumentedBroadcast(message) {
+			const tracer = getTracer$2();
+			const spanName = `Actor ${actorName}: sockets.broadcast`;
+			tracer.startActiveSpan(spanName, {
+				kind: SpanKind.PRODUCER,
+				attributes: {
+					"actor.name": actorName,
+					"actor.class": actorClassName,
+					"websocket.operation": "broadcast",
+					"websocket.message.type": typeof message,
+					"websocket.message.size": typeof message === "string" ? message.length : message instanceof ArrayBuffer ? message.byteLength : 0
+				}
+			}, (span) => {
+				try {
+					value.call(target, message);
+					span.setStatus({ code: SpanStatusCode.OK });
+				} catch (error) {
+					span.recordException(error);
+					span.setStatus({
+						code: SpanStatusCode.ERROR,
+						message: error instanceof Error ? error.message : String(error)
+					});
+					throw error;
+				} finally {
+					span.end();
+				}
+			});
+		};
+		if (prop === "send" && typeof value === "function") return function instrumentedSend(ws, message) {
+			const tracer = getTracer$2();
+			const spanName = `Actor ${actorName}: sockets.send`;
+			tracer.startActiveSpan(spanName, {
+				kind: SpanKind.PRODUCER,
+				attributes: {
+					"actor.name": actorName,
+					"actor.class": actorClassName,
+					"websocket.operation": "send",
+					"websocket.message.type": typeof message,
+					"websocket.message.size": typeof message === "string" ? message.length : message instanceof ArrayBuffer ? message.byteLength : 0
+				}
+			}, (span) => {
+				try {
+					value.call(target, ws, message);
+					span.setStatus({ code: SpanStatusCode.OK });
+				} catch (error) {
+					span.recordException(error);
+					span.setStatus({
+						code: SpanStatusCode.ERROR,
+						message: error instanceof Error ? error.message : String(error)
+					});
+					throw error;
+				} finally {
+					span.end();
+				}
+			});
+		};
+		if (prop === "getConnections" && typeof value === "function") return function instrumentedGetConnections() {
+			const tracer = getTracer$2();
+			const spanName = `Actor ${actorName}: sockets.getConnections`;
+			return tracer.startActiveSpan(spanName, {
+				kind: SpanKind.CLIENT,
+				attributes: {
+					"actor.name": actorName,
+					"actor.class": actorClassName,
+					"websocket.operation": "getConnections"
+				}
+			}, (span) => {
+				try {
+					const result = value.call(target);
+					if (Array.isArray(result)) span.setAttribute("websocket.connections.count", result.length);
+					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();
+				}
+			});
+		};
+		if (typeof value === "function") return value.bind(target);
+		return value;
+	} });
 }
 
-// src/actors/instrument-actor.ts
-var coldStarts = /* @__PURE__ */ new WeakMap();
+//#endregion
+//#region src/actors/instrument-actor.ts
+/**
+* Actor class instrumentation for @cloudflare/actors
+*
+* Wraps Actor lifecycle methods with OpenTelemetry tracing:
+* - onInit: Traced as 'actor.lifecycle': 'init'
+* - onRequest: Traced with full HTTP semantics
+* - onAlarm: Traced as 'actor.lifecycle': 'alarm'
+* - onPersist: Traced as 'actor.lifecycle': 'persist'
+* - WebSocket methods: Traced with socket semantics
+*/
+/**
+* Track cold starts per Actor class
+*/
+const coldStarts = /* @__PURE__ */ new WeakMap();
 function isColdStart(actorClass) {
-  if (!coldStarts.has(actorClass)) {
-    coldStarts.set(actorClass, true);
-    return true;
-  }
-  return false;
+	if (!coldStarts.has(actorClass)) {
+		coldStarts.set(actorClass, true);
+		return true;
+	}
+	return false;
 }
-function getTracer4() {
-  return trace.getTracer("autotel-cloudflare-actors");
+/**
+* Get the tracer instance
+*/
+function getTracer$1() {
+	return trace.getTracer("autotel-cloudflare-actors");
 }
+/**
+* Default span name formatter
+*/
 function defaultSpanNameFormatter(actorName, actorClass, lifecycle) {
-  const displayName = actorName || actorClass;
-  return `Actor ${displayName}: ${lifecycle}`;
+	return `Actor ${actorName || actorClass}: ${lifecycle}`;
 }
+/**
+* Create base Actor span attributes
+*/
 function createActorAttributes(actorInstance, actorClass, lifecycle) {
-  return {
-    "actor.name": actorInstance.name || "unknown",
-    "actor.class": actorClass.name || "Actor",
-    "actor.lifecycle": lifecycle,
-    "actor.coldstart": isColdStart(actorClass),
-    ...actorInstance.identifier && { "actor.identifier": actorInstance.identifier }
-  };
+	return {
+		"actor.name": actorInstance.name || "unknown",
+		"actor.class": actorClass.name || "Actor",
+		"actor.lifecycle": lifecycle,
+		"actor.coldstart": isColdStart(actorClass),
+		...actorInstance.identifier && { "actor.identifier": actorInstance.identifier }
+	};
 }
+/**
+* Instrument the onInit lifecycle method
+*/
 function instrumentOnInit(originalMethod, actorInstance, actorClass, options) {
-  return async function instrumentedOnInit() {
-    const tracer = getTracer4();
-    const actorClassName = actorClass.name || "Actor";
-    const spanName = options.spanNameFormatter ? options.spanNameFormatter(actorInstance.name || "", "init") : defaultSpanNameFormatter(actorInstance.name || "", actorClassName, "init");
-    return tracer.startActiveSpan(
-      spanName,
-      {
-        kind: SpanKind.INTERNAL,
-        attributes: createActorAttributes(actorInstance, actorClass, "init")
-      },
-      async (span) => {
-        try {
-          await originalMethod.call(actorInstance);
-          span.setStatus({ code: SpanStatusCode.OK });
-        } catch (error) {
-          span.recordException(error);
-          span.setStatus({
-            code: SpanStatusCode.ERROR,
-            message: error instanceof Error ? error.message : String(error)
-          });
-          throw error;
-        } finally {
-          span.end();
-        }
-      }
-    );
-  };
+	return async function instrumentedOnInit() {
+		const tracer = getTracer$1();
+		const actorClassName = actorClass.name || "Actor";
+		const spanName = options.spanNameFormatter ? options.spanNameFormatter(actorInstance.name || "", "init") : defaultSpanNameFormatter(actorInstance.name || "", actorClassName, "init");
+		return tracer.startActiveSpan(spanName, {
+			kind: SpanKind.INTERNAL,
+			attributes: createActorAttributes(actorInstance, actorClass, "init")
+		}, async (span) => {
+			try {
+				await originalMethod.call(actorInstance);
+				span.setStatus({ code: SpanStatusCode.OK });
+			} catch (error) {
+				span.recordException(error);
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: error instanceof Error ? error.message : String(error)
+				});
+				throw error;
+			} finally {
+				span.end();
+			}
+		});
+	};
 }
+/**
+* Instrument the onRequest lifecycle method
+*/
 function instrumentOnRequest(originalMethod, actorInstance, actorClass, options) {
-  return async function instrumentedOnRequest(request) {
-    const tracer = getTracer4();
-    const parentContext = propagation.extract(context.active(), request.headers);
-    const url = new URL(request.url);
-    const actorClassName = actorClass.name || "Actor";
-    const spanName = options.spanNameFormatter ? options.spanNameFormatter(actorInstance.name || "", "request") : `Actor ${actorInstance.name || actorClassName}: ${request.method} ${url.pathname}`;
-    return tracer.startActiveSpan(
-      spanName,
-      {
-        kind: SpanKind.SERVER,
-        attributes: {
-          ...createActorAttributes(actorInstance, actorClass, "request"),
-          "http.request.method": request.method,
-          "url.full": request.url,
-          "url.path": url.pathname,
-          "url.query": url.search
-        }
-      },
-      parentContext,
-      async (span) => {
-        try {
-          const response = await originalMethod.call(actorInstance, request);
-          span.setAttributes({
-            "http.response.status_code": response.status
-          });
-          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();
-        }
-      }
-    );
-  };
+	return async function instrumentedOnRequest(request) {
+		const tracer = getTracer$1();
+		const parentContext = propagation.extract(context.active(), request.headers);
+		const url = new URL(request.url);
+		const actorClassName = actorClass.name || "Actor";
+		const spanName = options.spanNameFormatter ? options.spanNameFormatter(actorInstance.name || "", "request") : `Actor ${actorInstance.name || actorClassName}: ${request.method} ${url.pathname}`;
+		return tracer.startActiveSpan(spanName, {
+			kind: SpanKind.SERVER,
+			attributes: {
+				...createActorAttributes(actorInstance, actorClass, "request"),
+				"http.request.method": request.method,
+				"url.full": request.url,
+				"url.path": url.pathname,
+				"url.query": url.search
+			}
+		}, parentContext, async (span) => {
+			try {
+				const response = await originalMethod.call(actorInstance, request);
+				span.setAttributes({ "http.response.status_code": response.status });
+				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();
+			}
+		});
+	};
 }
+/**
+* Instrument the onAlarm lifecycle method
+*/
 function instrumentOnAlarm(originalMethod, actorInstance, actorClass, options) {
-  return async function instrumentedOnAlarm(alarmInfo) {
-    const tracer = getTracer4();
-    const actorClassName = actorClass.name || "Actor";
-    const spanName = options.spanNameFormatter ? options.spanNameFormatter(actorInstance.name || "", "alarm") : defaultSpanNameFormatter(actorInstance.name || "", actorClassName, "alarm");
-    return tracer.startActiveSpan(
-      spanName,
-      {
-        kind: SpanKind.INTERNAL,
-        attributes: {
-          ...createActorAttributes(actorInstance, actorClass, "alarm"),
-          "faas.trigger": "timer"
-        }
-      },
-      async (span) => {
-        try {
-          await originalMethod.call(actorInstance, alarmInfo);
-          span.setStatus({ code: SpanStatusCode.OK });
-        } catch (error) {
-          span.recordException(error);
-          span.setStatus({
-            code: SpanStatusCode.ERROR,
-            message: error instanceof Error ? error.message : String(error)
-          });
-          throw error;
-        } finally {
-          span.end();
-        }
-      }
-    );
-  };
+	return async function instrumentedOnAlarm(alarmInfo) {
+		const tracer = getTracer$1();
+		const actorClassName = actorClass.name || "Actor";
+		const spanName = options.spanNameFormatter ? options.spanNameFormatter(actorInstance.name || "", "alarm") : defaultSpanNameFormatter(actorInstance.name || "", actorClassName, "alarm");
+		return tracer.startActiveSpan(spanName, {
+			kind: SpanKind.INTERNAL,
+			attributes: {
+				...createActorAttributes(actorInstance, actorClass, "alarm"),
+				"faas.trigger": "timer"
+			}
+		}, async (span) => {
+			try {
+				await originalMethod.call(actorInstance, alarmInfo);
+				span.setStatus({ code: SpanStatusCode.OK });
+			} catch (error) {
+				span.recordException(error);
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: error instanceof Error ? error.message : String(error)
+				});
+				throw error;
+			} finally {
+				span.end();
+			}
+		});
+	};
 }
+/**
+* Instrument the onPersist lifecycle method
+*/
 function instrumentOnPersist(originalMethod, actorInstance, actorClass, options) {
-  if (!options.capturePersistEvents) {
-    return originalMethod;
-  }
-  return function instrumentedOnPersist(key, value) {
-    const tracer = getTracer4();
-    const actorClassName = actorClass.name || "Actor";
-    const spanName = options.spanNameFormatter ? options.spanNameFormatter(actorInstance.name || "", "persist") : `Actor ${actorInstance.name || actorClassName}: persist ${key}`;
-    tracer.startActiveSpan(
-      spanName,
-      {
-        kind: SpanKind.INTERNAL,
-        attributes: {
-          ...createActorAttributes(actorInstance, actorClass, "persist"),
-          "actor.persist.key": key,
-          "actor.persist.value_type": typeof value
-        }
-      },
-      (span) => {
-        try {
-          originalMethod.call(actorInstance, key, value);
-          span.setStatus({ code: SpanStatusCode.OK });
-        } catch (error) {
-          span.recordException(error);
-          span.setStatus({
-            code: SpanStatusCode.ERROR,
-            message: error instanceof Error ? error.message : String(error)
-          });
-          throw error;
-        } finally {
-          span.end();
-        }
-      }
-    );
-  };
+	if (!options.capturePersistEvents) return originalMethod;
+	return function instrumentedOnPersist(key, value) {
+		const tracer = getTracer$1();
+		const actorClassName = actorClass.name || "Actor";
+		const spanName = options.spanNameFormatter ? options.spanNameFormatter(actorInstance.name || "", "persist") : `Actor ${actorInstance.name || actorClassName}: persist ${key}`;
+		tracer.startActiveSpan(spanName, {
+			kind: SpanKind.INTERNAL,
+			attributes: {
+				...createActorAttributes(actorInstance, actorClass, "persist"),
+				"actor.persist.key": key,
+				"actor.persist.value_type": typeof value
+			}
+		}, (span) => {
+			try {
+				originalMethod.call(actorInstance, key, value);
+				span.setStatus({ code: SpanStatusCode.OK });
+			} catch (error) {
+				span.recordException(error);
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: error instanceof Error ? error.message : String(error)
+				});
+				throw error;
+			} finally {
+				span.end();
+			}
+		});
+	};
 }
+/**
+* Instrument WebSocket lifecycle methods
+*/
 function instrumentWebSocketConnect(originalMethod, actorInstance, actorClass, options) {
-  return function instrumentedWebSocketConnect(ws, request) {
-    const tracer = getTracer4();
-    const actorClassName = actorClass.name || "Actor";
-    const spanName = options.spanNameFormatter ? options.spanNameFormatter(actorInstance.name || "", "websocket.connect") : defaultSpanNameFormatter(actorInstance.name || "", actorClassName, "websocket.connect");
-    tracer.startActiveSpan(
-      spanName,
-      {
-        kind: SpanKind.SERVER,
-        attributes: {
-          ...createActorAttributes(actorInstance, actorClass, "websocket.connect"),
-          "url.full": request.url
-        }
-      },
-      (span) => {
-        try {
-          originalMethod.call(actorInstance, ws, request);
-          span.setStatus({ code: SpanStatusCode.OK });
-        } catch (error) {
-          span.recordException(error);
-          span.setStatus({
-            code: SpanStatusCode.ERROR,
-            message: error instanceof Error ? error.message : String(error)
-          });
-          throw error;
-        } finally {
-          span.end();
-        }
-      }
-    );
-  };
+	return function instrumentedWebSocketConnect(ws, request) {
+		const tracer = getTracer$1();
+		const actorClassName = actorClass.name || "Actor";
+		const spanName = options.spanNameFormatter ? options.spanNameFormatter(actorInstance.name || "", "websocket.connect") : defaultSpanNameFormatter(actorInstance.name || "", actorClassName, "websocket.connect");
+		tracer.startActiveSpan(spanName, {
+			kind: SpanKind.SERVER,
+			attributes: {
+				...createActorAttributes(actorInstance, actorClass, "websocket.connect"),
+				"url.full": request.url
+			}
+		}, (span) => {
+			try {
+				originalMethod.call(actorInstance, ws, request);
+				span.setStatus({ code: SpanStatusCode.OK });
+			} catch (error) {
+				span.recordException(error);
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: error instanceof Error ? error.message : String(error)
+				});
+				throw error;
+			} finally {
+				span.end();
+			}
+		});
+	};
 }
 function instrumentWebSocketMessage(originalMethod, actorInstance, actorClass, options) {
-  return function instrumentedWebSocketMessage(ws, message) {
-    const tracer = getTracer4();
-    const actorClassName = actorClass.name || "Actor";
-    const spanName = options.spanNameFormatter ? options.spanNameFormatter(actorInstance.name || "", "websocket.message") : defaultSpanNameFormatter(actorInstance.name || "", actorClassName, "websocket.message");
-    tracer.startActiveSpan(
-      spanName,
-      {
-        kind: SpanKind.SERVER,
-        attributes: {
-          ...createActorAttributes(actorInstance, actorClass, "websocket.message"),
-          "websocket.message.type": typeof message,
-          "websocket.message.size": typeof message === "string" ? message.length : message instanceof ArrayBuffer ? message.byteLength : 0
-        }
-      },
-      (span) => {
-        try {
-          originalMethod.call(actorInstance, ws, message);
-          span.setStatus({ code: SpanStatusCode.OK });
-        } catch (error) {
-          span.recordException(error);
-          span.setStatus({
-            code: SpanStatusCode.ERROR,
-            message: error instanceof Error ? error.message : String(error)
-          });
-          throw error;
-        } finally {
-          span.end();
-        }
-      }
-    );
-  };
+	return function instrumentedWebSocketMessage(ws, message) {
+		const tracer = getTracer$1();
+		const actorClassName = actorClass.name || "Actor";
+		const spanName = options.spanNameFormatter ? options.spanNameFormatter(actorInstance.name || "", "websocket.message") : defaultSpanNameFormatter(actorInstance.name || "", actorClassName, "websocket.message");
+		tracer.startActiveSpan(spanName, {
+			kind: SpanKind.SERVER,
+			attributes: {
+				...createActorAttributes(actorInstance, actorClass, "websocket.message"),
+				"websocket.message.type": typeof message,
+				"websocket.message.size": typeof message === "string" ? message.length : message instanceof ArrayBuffer ? message.byteLength : 0
+			}
+		}, (span) => {
+			try {
+				originalMethod.call(actorInstance, ws, message);
+				span.setStatus({ code: SpanStatusCode.OK });
+			} catch (error) {
+				span.recordException(error);
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: error instanceof Error ? error.message : String(error)
+				});
+				throw error;
+			} finally {
+				span.end();
+			}
+		});
+	};
 }
 function instrumentWebSocketDisconnect(originalMethod, actorInstance, actorClass, options) {
-  return function instrumentedWebSocketDisconnect(ws) {
-    const tracer = getTracer4();
-    const actorClassName = actorClass.name || "Actor";
-    const spanName = options.spanNameFormatter ? options.spanNameFormatter(actorInstance.name || "", "websocket.disconnect") : defaultSpanNameFormatter(actorInstance.name || "", actorClassName, "websocket.disconnect");
-    tracer.startActiveSpan(
-      spanName,
-      {
-        kind: SpanKind.SERVER,
-        attributes: createActorAttributes(actorInstance, actorClass, "websocket.disconnect")
-      },
-      (span) => {
-        try {
-          originalMethod.call(actorInstance, ws);
-          span.setStatus({ code: SpanStatusCode.OK });
-        } catch (error) {
-          span.recordException(error);
-          span.setStatus({
-            code: SpanStatusCode.ERROR,
-            message: error instanceof Error ? error.message : String(error)
-          });
-          throw error;
-        } finally {
-          span.end();
-        }
-      }
-    );
-  };
+	return function instrumentedWebSocketDisconnect(ws) {
+		const tracer = getTracer$1();
+		const actorClassName = actorClass.name || "Actor";
+		const spanName = options.spanNameFormatter ? options.spanNameFormatter(actorInstance.name || "", "websocket.disconnect") : defaultSpanNameFormatter(actorInstance.name || "", actorClassName, "websocket.disconnect");
+		tracer.startActiveSpan(spanName, {
+			kind: SpanKind.SERVER,
+			attributes: createActorAttributes(actorInstance, actorClass, "websocket.disconnect")
+		}, (span) => {
+			try {
+				originalMethod.call(actorInstance, ws);
+				span.setStatus({ code: SpanStatusCode.OK });
+			} catch (error) {
+				span.recordException(error);
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: error instanceof Error ? error.message : String(error)
+				});
+				throw error;
+			} finally {
+				span.end();
+			}
+		});
+	};
 }
+/**
+* Instrument an Actor instance by wrapping all lifecycle methods
+*/
 function instrumentActorInstance(actorInstance, _state, _env, actorClass, options) {
-  const instanceHandler = {
-    get(target, prop) {
-      const value = Reflect.get(target, prop);
-      if (prop === "onInit" && typeof value === "function") {
-        return instrumentOnInit(value.bind(target), target, actorClass, options);
-      }
-      if (prop === "onRequest" && typeof value === "function") {
-        return instrumentOnRequest(value.bind(target), target, actorClass, options);
-      }
-      if (prop === "onAlarm" && typeof value === "function") {
-        return instrumentOnAlarm(value.bind(target), target, actorClass, options);
-      }
-      if (prop === "onPersist" && typeof value === "function") {
-        return instrumentOnPersist(value.bind(target), target, actorClass, options);
-      }
-      if (prop === "onWebSocketConnect" && typeof value === "function") {
-        return instrumentWebSocketConnect(value.bind(target), target, actorClass, options);
-      }
-      if (prop === "onWebSocketMessage" && typeof value === "function") {
-        return instrumentWebSocketMessage(value.bind(target), target, actorClass, options);
-      }
-      if (prop === "onWebSocketDisconnect" && typeof value === "function") {
-        return instrumentWebSocketDisconnect(value.bind(target), target, actorClass, options);
-      }
-      if (prop === "storage" && value && options.instrumentStorage !== false) {
-        return instrumentActorStorage(value, target, actorClass);
-      }
-      if (prop === "alarms" && value && options.instrumentAlarms !== false) {
-        return instrumentActorAlarms(value, target, actorClass);
-      }
-      if (prop === "sockets" && value && options.instrumentSockets !== false) {
-        return instrumentActorSockets(value, target, actorClass);
-      }
-      if (typeof value === "function") {
-        return value.bind(target);
-      }
-      return value;
-    }
-  };
-  return wrap(actorInstance, instanceHandler);
+	return wrap(actorInstance, { get(target, prop) {
+		const value = Reflect.get(target, prop);
+		if (prop === "onInit" && typeof value === "function") return instrumentOnInit(value.bind(target), target, actorClass, options);
+		if (prop === "onRequest" && typeof value === "function") return instrumentOnRequest(value.bind(target), target, actorClass, options);
+		if (prop === "onAlarm" && typeof value === "function") return instrumentOnAlarm(value.bind(target), target, actorClass, options);
+		if (prop === "onPersist" && typeof value === "function") return instrumentOnPersist(value.bind(target), target, actorClass, options);
+		if (prop === "onWebSocketConnect" && typeof value === "function") return instrumentWebSocketConnect(value.bind(target), target, actorClass, options);
+		if (prop === "onWebSocketMessage" && typeof value === "function") return instrumentWebSocketMessage(value.bind(target), target, actorClass, options);
+		if (prop === "onWebSocketDisconnect" && typeof value === "function") return instrumentWebSocketDisconnect(value.bind(target), target, actorClass, options);
+		if (prop === "storage" && value && options.instrumentStorage !== false) return instrumentActorStorage(value, target, actorClass);
+		if (prop === "alarms" && value && options.instrumentAlarms !== false) return instrumentActorAlarms(value, target, actorClass);
+		if (prop === "sockets" && value && options.instrumentSockets !== false) return instrumentActorSockets(value, target, actorClass);
+		if (typeof value === "function") return value.bind(target);
+		return value;
+	} });
 }
+/**
+* Instrument an Actor class for comprehensive OpenTelemetry tracing
+*
+* This wraps the Actor class to automatically trace all lifecycle methods:
+* - onInit: Actor initialization
+* - onRequest: HTTP request handling
+* - onAlarm: Alarm triggers
+* - onPersist: Property persistence events
+* - WebSocket methods: Connection, message, disconnect
+*
+* It also optionally instruments:
+* - actor.storage: SQL queries and storage operations
+* - actor.alarms: Alarm scheduling operations
+* - actor.sockets: WebSocket operations
+*
+* @example
+* ```typescript
+* import { Actor } from '@cloudflare/actors'
+* import { instrumentActor } from 'autotel-cloudflare/actors'
+*
+* class Counter extends Actor<Env> {
+*   protected onInit() {
+*     console.log('Counter initialized')
+*   }
+*
+*   protected onRequest(request: Request) {
+*     return new Response('count: 42')
+*   }
+* }
+*
+* // Wrap the class
+* export const InstrumentedCounter = instrumentActor(Counter, (env: Env) => ({
+*   service: { name: 'counter-actor' },
+*   exporter: { url: env.OTLP_ENDPOINT },
+*   actors: {
+*     instrumentStorage: true,
+*     capturePersistEvents: true
+*   }
+* }))
+* ```
+*
+* @param actorClass - The Actor class to instrument
+* @param config - Configuration (static object or function)
+* @returns Instrumented Actor class
+*/
 function instrumentActor(actorClass, config) {
-  const initialiser = createInitialiser(config);
-  const defaultOptions = {
-    instrumentStorage: true,
-    instrumentAlarms: true,
-    instrumentSockets: true,
-    capturePersistEvents: true
-  };
-  const classHandler = {
-    construct(target, [state, env]) {
-      const resolvedConfig = typeof config === "function" ? config(env, { id: state.id.toString(), name: state.id.name }) : config;
-      const actorOptions = resolvedConfig && typeof resolvedConfig === "object" && "actors" in resolvedConfig ? resolvedConfig.actors : void 0;
-      const options = {
-        ...defaultOptions,
-        ...actorOptions
-      };
-      const trigger = {
-        id: state.id.toString(),
-        name: state.id.name
-      };
-      const telemetryConfig = initialiser(env, trigger);
-      const context$1 = setConfig(telemetryConfig);
-      const actorInstance = context.with(context$1, () => {
-        return new target(state, env);
-      });
-      return instrumentActorInstance(actorInstance, state, env, actorClass, options);
-    }
-  };
-  return wrap(actorClass, classHandler);
+	const initialiser = createInitialiser(config);
+	const defaultOptions = {
+		instrumentStorage: true,
+		instrumentAlarms: true,
+		instrumentSockets: true,
+		capturePersistEvents: true
+	};
+	return wrap(actorClass, { construct(target, [state, env]) {
+		const resolvedConfig = typeof config === "function" ? config(env, {
+			id: state.id.toString(),
+			name: state.id.name
+		}) : config;
+		const actorOptions = resolvedConfig && typeof resolvedConfig === "object" && "actors" in resolvedConfig ? resolvedConfig.actors : void 0;
+		const options = {
+			...defaultOptions,
+			...actorOptions
+		};
+		const context$1 = setConfig(initialiser(env, {
+			id: state.id.toString(),
+			name: state.id.name
+		}));
+		return instrumentActorInstance(context.with(context$1, () => {
+			return new target(state, env);
+		}), state, env, actorClass, options);
+	} });
 }
-function getTracer5() {
-  return trace.getTracer("autotel-cloudflare-actors");
+
+//#endregion
+//#region src/actors/traced-handler.ts
+/**
+* Traced handler wrapper for @cloudflare/actors
+*
+* Wraps the Actors handler() to provide:
+* - Root span for the entire request lifecycle
+* - Actor name extraction and correlation
+* - Request routing tracing
+*/
+/**
+* Get the tracer instance
+*/
+function getTracer() {
+	return trace.getTracer("autotel-cloudflare-actors");
 }
+/**
+* Create a traced handler that combines Actor instrumentation with request tracing
+*
+* This is an all-in-one wrapper that:
+* 1. Initializes telemetry for the Worker
+* 2. Creates a root span for each incoming request
+* 3. Extracts the Actor name using `nameFromRequest`
+* 4. Instruments the Actor class with lifecycle tracing
+* 5. Routes the request to the instrumented Actor
+*
+* @example
+* ```typescript
+* import { Actor } from '@cloudflare/actors'
+* import { tracedHandler } from 'autotel-cloudflare/actors'
+*
+* class MyActor extends Actor<Env> {
+*   protected onRequest(request: Request) {
+*     return new Response('Hello!')
+*   }
+* }
+*
+* // Export the Actor class and use tracedHandler
+* export { MyActor }
+* export default tracedHandler(MyActor, (env) => ({
+*   service: { name: 'my-actor-service' },
+*   exporter: { url: env.OTLP_ENDPOINT }
+* }))
+* ```
+*
+* @param actorClass - The Actor class to handle requests
+* @param config - Configuration (static object or function)
+* @returns A Worker handler with full tracing
+*/
 function tracedHandler(actorClass, config) {
-  const initialiser = createInitialiser(config);
-  return {
-    async fetch(request, env, _ctx) {
-      const telemetryConfig = initialiser(env, { type: "http" });
-      const configContext = setConfig(telemetryConfig);
-      const parentContext = propagation.extract(configContext, request.headers);
-      const tracer = getTracer5();
-      const url = new URL(request.url);
-      const actorClassName = actorClass.name || "Actor";
-      let actorName;
-      try {
-        if (actorClass.nameFromRequest) {
-          actorName = await actorClass.nameFromRequest(request);
-        }
-      } catch {
-        actorName = void 0;
-      }
-      const spanName = `${actorClassName} handler: ${request.method} ${url.pathname}`;
-      return tracer.startActiveSpan(
-        spanName,
-        {
-          kind: SpanKind.SERVER,
-          attributes: {
-            "http.request.method": request.method,
-            "url.full": request.url,
-            "url.path": url.pathname,
-            "url.query": url.search,
-            "actor.class": actorClassName,
-            ...actorName && { "actor.name": actorName },
-            "faas.trigger": "http"
-          }
-        },
-        parentContext,
-        async (span) => {
-          try {
-            const envObj = env;
-            const bindingName = Object.keys(envObj).find((key) => {
-              const binding = env.__DURABLE_OBJECT_BINDINGS;
-              return key === actorClassName || binding?.[key]?.class_name === actorClassName;
-            });
-            if (!bindingName) {
-              span.setStatus({
-                code: SpanStatusCode.ERROR,
-                message: `No Durable Object binding found for ${actorClassName}`
-              });
-              return Response.json(
-                {
-                  error: "Configuration Error",
-                  message: `No Durable Object binding found for actor class ${actorClassName}`
-                },
-                { status: 500, headers: { "Content-Type": "application/json" } }
-              );
-            }
-            const namespace = envObj[bindingName];
-            const idString = actorName || "default";
-            const locationHint = actorClass.configuration?.(request)?.locationHint;
-            const stub = namespace.getByName(idString, { locationHint });
-            if ("setName" in stub && typeof stub.setName === "function") {
-              stub.setName(idString);
-            }
-            const headers = new Headers(request.headers);
-            propagation.inject(context.active(), headers);
-            const tracedRequest = new Request(request.url, {
-              method: request.method,
-              headers,
-              body: request.body,
-              redirect: request.redirect
-            });
-            const response = await stub.fetch(tracedRequest);
-            span.setAttributes({
-              "http.response.status_code": response.status,
-              "actor.name": idString
-            });
-            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)
-            });
-            return Response.json(
-              {
-                error: "Internal Server Error",
-                message: error instanceof Error ? error.message : "Unknown error"
-              },
-              { status: 500, headers: { "Content-Type": "application/json" } }
-            );
-          } finally {
-            span.end();
-          }
-        }
-      );
-    }
-  };
+	const initialiser = createInitialiser(config);
+	return { async fetch(request, env, _ctx) {
+		const configContext = setConfig(initialiser(env, { type: "http" }));
+		const parentContext = propagation.extract(configContext, request.headers);
+		const tracer = getTracer();
+		const url = new URL(request.url);
+		const actorClassName = actorClass.name || "Actor";
+		let actorName;
+		try {
+			if (actorClass.nameFromRequest) actorName = await actorClass.nameFromRequest(request);
+		} catch {
+			actorName = void 0;
+		}
+		const spanName = `${actorClassName} handler: ${request.method} ${url.pathname}`;
+		return tracer.startActiveSpan(spanName, {
+			kind: SpanKind.SERVER,
+			attributes: {
+				"http.request.method": request.method,
+				"url.full": request.url,
+				"url.path": url.pathname,
+				"url.query": url.search,
+				"actor.class": actorClassName,
+				...actorName && { "actor.name": actorName },
+				"faas.trigger": "http"
+			}
+		}, parentContext, async (span) => {
+			try {
+				const envObj = env;
+				const bindingName = Object.keys(envObj).find((key) => {
+					const binding = env.__DURABLE_OBJECT_BINDINGS;
+					return key === actorClassName || binding?.[key]?.class_name === actorClassName;
+				});
+				if (!bindingName) {
+					span.setStatus({
+						code: SpanStatusCode.ERROR,
+						message: `No Durable Object binding found for ${actorClassName}`
+					});
+					return Response.json({
+						error: "Configuration Error",
+						message: `No Durable Object binding found for actor class ${actorClassName}`
+					}, {
+						status: 500,
+						headers: { "Content-Type": "application/json" }
+					});
+				}
+				const namespace = envObj[bindingName];
+				const idString = actorName || "default";
+				const locationHint = actorClass.configuration?.(request)?.locationHint;
+				const stub = namespace.getByName(idString, { locationHint });
+				if ("setName" in stub && typeof stub.setName === "function") stub.setName(idString);
+				const headers = new Headers(request.headers);
+				propagation.inject(context.active(), headers);
+				const tracedRequest = new Request(request.url, {
+					method: request.method,
+					headers,
+					body: request.body,
+					redirect: request.redirect
+				});
+				const response = await stub.fetch(tracedRequest);
+				span.setAttributes({
+					"http.response.status_code": response.status,
+					"actor.name": idString
+				});
+				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)
+				});
+				return Response.json({
+					error: "Internal Server Error",
+					message: error instanceof Error ? error.message : "Unknown error"
+				}, {
+					status: 500,
+					headers: { "Content-Type": "application/json" }
+				});
+			} finally {
+				span.end();
+			}
+		});
+	} };
 }
+/**
+* Alternative: Create a handler wrapper that uses the existing @cloudflare/actors handler
+*
+* This is useful if you want to use the original handler() but add tracing around it.
+*
+* @example
+* ```typescript
+* import { Actor, handler } from '@cloudflare/actors'
+* import { wrapHandler } from 'autotel-cloudflare/actors'
+*
+* class MyActor extends Actor<Env> {}
+*
+* export { MyActor }
+* export default wrapHandler(handler(MyActor), (env) => ({
+*   service: { name: 'my-service' }
+* }))
+* ```
+*/
 function wrapHandler(originalHandler, config) {
-  const initialiser = createInitialiser(config);
-  return {
-    async fetch(request, env, ctx) {
-      const telemetryConfig = initialiser(env, { type: "http" });
-      const configContext = setConfig(telemetryConfig);
-      const parentContext = propagation.extract(configContext, request.headers);
-      const tracer = getTracer5();
-      const url = new URL(request.url);
-      return tracer.startActiveSpan(
-        `Worker: ${request.method} ${url.pathname}`,
-        {
-          kind: SpanKind.SERVER,
-          attributes: {
-            "http.request.method": request.method,
-            "url.full": request.url,
-            "url.path": url.pathname,
-            "url.query": url.search,
-            "faas.trigger": "http"
-          }
-        },
-        parentContext,
-        async (span) => {
-          try {
-            const headers = new Headers(request.headers);
-            propagation.inject(context.active(), headers);
-            const tracedRequest = new Request(request.url, {
-              method: request.method,
-              headers,
-              body: request.body,
-              redirect: request.redirect
-            });
-            const response = await originalHandler.fetch(tracedRequest, env, ctx);
-            span.setAttributes({
-              "http.response.status_code": response.status
-            });
-            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();
-          }
-        }
-      );
-    }
-  };
+	const initialiser = createInitialiser(config);
+	return { async fetch(request, env, ctx) {
+		const configContext = setConfig(initialiser(env, { type: "http" }));
+		const parentContext = propagation.extract(configContext, request.headers);
+		const tracer = getTracer();
+		const url = new URL(request.url);
+		return tracer.startActiveSpan(`Worker: ${request.method} ${url.pathname}`, {
+			kind: SpanKind.SERVER,
+			attributes: {
+				"http.request.method": request.method,
+				"url.full": request.url,
+				"url.path": url.pathname,
+				"url.query": url.search,
+				"faas.trigger": "http"
+			}
+		}, parentContext, async (span) => {
+			try {
+				const headers = new Headers(request.headers);
+				propagation.inject(context.active(), headers);
+				const tracedRequest = new Request(request.url, {
+					method: request.method,
+					headers,
+					body: request.body,
+					redirect: request.redirect
+				});
+				const response = await originalHandler.fetch(tracedRequest, env, ctx);
+				span.setAttributes({ "http.response.status_code": response.status });
+				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
 export { instrumentActor, instrumentActorAlarms, instrumentActorSockets, instrumentActorStorage, tracedHandler, wrapHandler };
-//# sourceMappingURL=actors.js.map
 //# sourceMappingURL=actors.js.map