@inference-net/otel-cf-workers 2.1.0 → 2.2.0

package/dist/index.d.ts

@@ -177,6 +177,36 @@ export declare interface InstrumentationOptions {
 
 export declare function instrumentDO(doClass: DOClass, config: ConfigurationOption): DOClass;
 
+/**
+ * Base class for instrumented Durable Objects with TypeScript support for injected methods.
+ * Extend this instead of DurableObject to automatically get typing for `this.instrument()`.
+ *
+ * @example
+ * ```typescript
+ * import { InstrumentedDurableObject } from '@inference-net/otel-cf-workers'
+ *
+ * export class MyDO extends InstrumentedDurableObject<Env> {
+ *   async someMethod() {
+ *     // this.instrument is available with full TypeScript support!
+ *     await this.instrument('custom-operation', async () => {
+ *       // Your code here
+ *     })
+ *   }
+ * }
+ * ```
+ */
+export declare class InstrumentedDurableObject<Env = unknown> extends DurableObject_2<Env> {
+    instrument: InstrumentMethod;
+}
+
+export declare type InstrumentMethod = {
+    <T>(name: string, fn: () => Promise<T>): Promise<T>;
+    <T>(name: string, options: InstrumentOptions, fn: () => Promise<T>): Promise<T>;
+};
+
+export declare interface InstrumentOptions extends Omit<SpanOptions, 'kind'> {
+}
+
 export declare function isAlarm(trigger: Trigger): trigger is 'do-alarm';
 
 export declare const isHeadSampled: TailSampleFn;

package/dist/index.js

@@ -96,7 +96,7 @@ function passthroughGet(target, prop, thisArg) {
   }
 }
 
-const PACKAGE_VERSION = "2.1.0";
+const PACKAGE_VERSION = "2.2.0";
 const PACKAGE_NAME = "@inference-net/otel-cf-workers";
 const ATTR_CLOUDFLARE_COLO = "cloudflare.colo";
 const ATTR_CLOUDFLARE_RAY_ID = "cloudflare.ray_id";
@@ -1443,9 +1443,10 @@ function getParentContextFromRequest(request) {
 }
 function updateSpanNameOnRoute(span, request, result) {
   const readable = span;
-  if (readable.attributes["http.route"]) {
+  const route = readable.attributes?.["http.route"];
+  if (route) {
     const method = request.method.toUpperCase();
-    span.updateName(`${method} ${readable.attributes["http.route"]}`);
+    span.updateName(`${method} ${route}`);
   }
   if (result) {
     if (result.status >= 400) {
@@ -3032,6 +3033,49 @@ function extractAndRemoveRpcContext(args) {
   return [void 0, args];
 }
 
+class InstrumentedDurableObject extends DurableObject {
+}
+function createInstrumentMethod(state, initialiser, env) {
+  return async function instrument(name, optionsOrFn, maybeFn) {
+    const options = typeof optionsOrFn === "function" ? {} : optionsOrFn;
+    const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+    const tracer = trace.getTracer("DO custom span");
+    const spanOptions = {
+      ...options,
+      attributes: {
+        "do.id": state.id.toString(),
+        ...state.id.name && { "do.name": state.id.name },
+        ...options.attributes
+      }
+    };
+    const executeWithConfig = async () => {
+      const currentContext = context.active();
+      const existingConfig = getActiveConfig();
+      let context$1 = currentContext;
+      if (!existingConfig) {
+        const config = initialiser(env, { id: state.id.toString(), name: state.id.name });
+        context$1 = setConfig(config, currentContext);
+      }
+      return context.with(
+        context$1,
+        () => tracer.startActiveSpan(name, spanOptions, async (span) => {
+          try {
+            const result = await fn();
+            span.setStatus({ code: SpanStatusCode.OK });
+            return result;
+          } catch (error) {
+            span.recordException(error);
+            span.setStatus({ code: SpanStatusCode.ERROR });
+            throw error;
+          } finally {
+            span.end();
+          }
+        })
+      );
+    };
+    return executeWithConfig();
+  };
+}
 function instrumentRpcMethod(method, methodName, nsName, stubId) {
   const tracer = trace.getTracer("do_rpc_client");
   const rpcHandler = {
@@ -3276,14 +3320,10 @@ function instrumentRpcHandlerMethod(fn, methodName, initialiser, env, id) {
   };
   return wrap(fn, fnHandler);
 }
-function instrumentDurableObject(doObj, initialiser, env, state, classStyle) {
+function instrumentDurableObject(doObj, initialiser, env, state) {
   const objHandler = {
     get(target, prop) {
-      if (classStyle && prop === "ctx") {
-        return state;
-      } else if (classStyle && prop === "env") {
-        return env;
-      } else if (prop === "fetch") {
+      if (prop === "fetch") {
         const fetchFn = Reflect.get(target, prop);
         return instrumentFetchFn(fetchFn, initialiser, env, state.id);
       } else if (prop === "alarm") {
@@ -3312,16 +3352,28 @@ function instrumentDOClass(doClass, initialiser) {
       const context$1 = setConfig(constructorConfig);
       const state = instrumentState(orig_state);
       const env = instrumentEnv(orig_env);
-      const classStyle = doClass.prototype instanceof DurableObject;
-      const createDO = () => {
-        if (classStyle) {
-          return new target(orig_state, orig_env);
-        } else {
-          return new target(state, env);
-        }
-      };
+      const createDO = () => new target(orig_state, orig_env);
       const doObj = context.with(context$1, createDO);
-      return instrumentDurableObject(doObj, initialiser, env, state, classStyle);
+      const instrumentMethod = createInstrumentMethod(state, initialiser, env);
+      Object.defineProperty(doObj, "instrument", {
+        value: instrumentMethod,
+        writable: false,
+        enumerable: false,
+        configurable: true
+      });
+      Object.defineProperty(doObj, "env", {
+        value: env,
+        writable: false,
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(doObj, "ctx", {
+        value: state,
+        writable: false,
+        enumerable: true,
+        configurable: true
+      });
+      return instrumentDurableObject(doObj, initialiser, env, state);
     }
   };
   return wrap(doClass, classHandler);
@@ -3540,12 +3592,19 @@ function createHandlerFlowFn(instrumentation) {
     const result = tracer.startActiveSpan(name, options, parentContext, async (span) => {
       try {
         const result2 = await handlerFn(instrumentedTrigger, proxiedEnv, proxiedCtx);
-        if (instrumentation.getAttributesFromResult) {
-          const attributes = instrumentation.getAttributesFromResult(result2);
-          span.setAttributes(attributes);
-        }
-        if (instrumentation.executionSucces) {
-          instrumentation.executionSucces(span, trigger, result2);
+        const isWebSocketUpgrade = isRequest(trigger) && trigger.headers.get("upgrade")?.toLowerCase() === "websocket" && trigger.headers.has("sec-websocket-key");
+        if (isWebSocketUpgrade) {
+          const logger = getLogger("handler");
+          logger.trace("WebSocket upgrade detected, closing span without reading response");
+          span.setStatus({ code: SpanStatusCode.OK });
+        } else {
+          if (instrumentation.getAttributesFromResult) {
+            const attributes = instrumentation.getAttributesFromResult(result2);
+            span.setAttributes(attributes);
+          }
+          if (instrumentation.executionSucces) {
+            instrumentation.executionSucces(span, trigger, result2);
+          }
         }
         return result2;
       } catch (error) {
@@ -3858,5 +3917,5 @@ class ConsoleTransport {
   }
 }
 
-export { BatchSizeLogRecordProcessor, BatchTraceSpanProcessor, ConsoleTransport, ImmediateLogRecordProcessor, MultiSpanExporter, MultiSpanExporterAsync, MultiTransportLogRecordProcessor, OTLPExporter, OTLPTransport, SEVERITY_NUMBERS, SpanImpl, WorkerLogger, WorkerLoggerProvider, __unwrappedFetch, createLogProcessor, createSampler, exportSpans, exportTelemetry, getGlobalLoggerProvider, getLogger, instrument, instrumentDO, isAlarm, isHeadSampled, isMessageBatch, isRequest, isRootErrorSpan, multiTailSampler, setGlobalLoggerProvider, withNextSpan };
+export { BatchSizeLogRecordProcessor, BatchTraceSpanProcessor, ConsoleTransport, ImmediateLogRecordProcessor, InstrumentedDurableObject, MultiSpanExporter, MultiSpanExporterAsync, MultiTransportLogRecordProcessor, OTLPExporter, OTLPTransport, SEVERITY_NUMBERS, SpanImpl, WorkerLogger, WorkerLoggerProvider, __unwrappedFetch, createLogProcessor, createSampler, exportSpans, exportTelemetry, getGlobalLoggerProvider, getLogger, instrument, instrumentDO, isAlarm, isHeadSampled, isMessageBatch, isRequest, isRootErrorSpan, multiTailSampler, setGlobalLoggerProvider, withNextSpan };
 //# sourceMappingURL=index.js.map