@inference-net/otel-cf-workers 2.0.1 → 2.0.3

package/dist/index.d.ts

@@ -84,6 +84,7 @@ export declare interface ConsoleTransportConfig {
     pretty?: boolean;
     colors?: boolean;
     includeTimestamp?: boolean;
+    transformLog?: (logRecord: ReadableLogRecord) => ReadableLogRecord;
 }
 
 /**
@@ -511,7 +512,7 @@ declare class TraceState {
     private exportSpans;
 }
 
-export declare type Trigger = Request | MessageBatch | ScheduledController | DOConstructorTrigger | 'do-alarm' | ForwardableEmailMessage;
+export declare type Trigger = Request | MessageBatch | ScheduledController | DOConstructorTrigger | 'do-alarm' | 'do-rpc' | ForwardableEmailMessage;
 
 export declare function withNextSpan(attrs: Attributes): void;
 

package/dist/index.js

@@ -96,7 +96,7 @@ function passthroughGet(target, prop, thisArg) {
   }
 }
 
-const PACKAGE_VERSION = "2.0.1";
+const PACKAGE_VERSION = "2.0.3";
 const PACKAGE_NAME = "@inference-net/otel-cf-workers";
 const ATTR_CLOUDFLARE_COLO = "cloudflare.colo";
 const ATTR_CLOUDFLARE_RAY_ID = "cloudflare.ray_id";
@@ -224,6 +224,10 @@ const ATTR_CLOUDFLARE_IMAGES_REQUIRE_SIGNED_URLS = "cloudflare.images.require_si
 const ATTR_CLOUDFLARE_RATE_LIMIT_KEY = "cloudflare.rate_limit.key";
 const ATTR_CLOUDFLARE_RATE_LIMIT_ALLOWED = "cloudflare.rate_limit.allowed";
 const ATTR_CLOUDFLARE_RATE_LIMIT_SUCCESS = "cloudflare.rate_limit.success";
+const ATTR_CLOUDFLARE_JSRPC_METHOD = "cloudflare.jsrpc.method";
+const ATTR_RPC_SYSTEM = "rpc.system";
+const ATTR_RPC_SERVICE = "rpc.service";
+const ATTR_RPC_METHOD = "rpc.method";
 const DEFAULT_OTLP_HEADERS = {
   accept: "application/json",
   "content-type": "application/json",
@@ -2920,6 +2924,79 @@ function instrumentSQLStorage(sql) {
   return wrap(sql, sqlHandler);
 }
 
+const RPC_CONTEXT_MARKER = "__otel_rpc_ctx__";
+function isRpcContextCarrier(obj) {
+  return typeof obj === "object" && obj !== null && RPC_CONTEXT_MARKER in obj && obj[RPC_CONTEXT_MARKER] === true;
+}
+function injectRpcContext(ctx = context.active()) {
+  const carrier = {
+    [RPC_CONTEXT_MARKER]: true,
+    headers: {}
+  };
+  propagation.inject(ctx, carrier.headers, {
+    set: (headers, key, value) => {
+      headers[key] = typeof value === "string" ? value : String(value);
+    }
+  });
+  return carrier;
+}
+function extractRpcContext(carrier) {
+  return propagation.extract(context.active(), carrier.headers, {
+    get(headers, key) {
+      return headers[key] || void 0;
+    },
+    keys(headers) {
+      return Object.keys(headers);
+    }
+  });
+}
+function extractAndRemoveRpcContext(args) {
+  if (args.length > 0 && isRpcContextCarrier(args[0])) {
+    const carrier = args[0];
+    const extractedContext = extractRpcContext(carrier);
+    const cleanedArgs = args.slice(1);
+    return [extractedContext, cleanedArgs];
+  }
+  return [void 0, args];
+}
+
+function instrumentRpcMethod(method, methodName, nsName, stubId) {
+  const tracer = trace.getTracer("do_rpc_client");
+  const rpcHandler = {
+    apply: async (target, thisArg, argArray) => {
+      const attributes = {
+        [ATTR_RPC_SYSTEM]: "cloudflare_rpc",
+        [ATTR_RPC_SERVICE]: nsName,
+        [ATTR_RPC_METHOD]: methodName,
+        [ATTR_CLOUDFLARE_JSRPC_METHOD]: methodName,
+        "do.namespace": nsName,
+        "do.id": stubId.toString(),
+        "do.id.name": stubId.name
+      };
+      const options = {
+        kind: SpanKind.CLIENT,
+        attributes
+      };
+      const spanName = `RPC ${nsName}.${methodName}`;
+      return tracer.startActiveSpan(spanName, options, async (span) => {
+        try {
+          const contextCarrier = injectRpcContext(context.active());
+          const argsWithContext = [contextCarrier, ...argArray];
+          const result = await Reflect.apply(target, thisArg, argsWithContext);
+          span.setStatus({ code: SpanStatusCode.OK });
+          return result;
+        } catch (error) {
+          span.recordException(error);
+          span.setStatus({ code: SpanStatusCode.ERROR });
+          throw error;
+        } finally {
+          span.end();
+        }
+      });
+    }
+  };
+  return wrap(method, rpcHandler);
+}
 function instrumentBindingStub(stub, nsName) {
   const stubHandler = {
     get(target, prop, receiver) {
@@ -2933,7 +3010,11 @@ function instrumentBindingStub(stub, nsName) {
         };
         return instrumentClientFetch(fetcher, () => ({ includeTraceContext: true }), attrs);
       } else {
-        return passthroughGet(target, prop, receiver);
+        const value = passthroughGet(target, prop, receiver);
+        if (typeof value === "function" && typeof prop === "string") {
+          return instrumentRpcMethod(value, prop, nsName, target.id);
+        }
+        return value;
       }
     }
   };
@@ -3062,19 +3143,47 @@ function instrumentAlarmFn(alarmFn, initialiser, env, id) {
   };
   return wrap(alarmFn, alarmHandler);
 }
-function instrumentAnyFn(fn, initialiser, env, _id) {
-  if (!fn) return void 0;
+function instrumentRpcHandlerMethod(fn, methodName, initialiser, env, id) {
+  if (!fn) return fn;
   const fnHandler = {
     async apply(target, thisArg, argArray) {
       thisArg = unwrap(thisArg);
-      const config = initialiser(env, "do-alarm");
-      const context$1 = setConfig(config);
-      try {
-        const bound = target.bind(unwrap(thisArg));
-        return await context.with(context$1, () => bound.apply(thisArg, argArray), void 0);
-      } catch (error) {
-        throw error;
-      }
+      const config = initialiser(env, "do-rpc");
+      const [extractedContext, cleanedArgs] = extractAndRemoveRpcContext(argArray);
+      let context$1 = extractedContext || context.active();
+      context$1 = setConfig(config, context$1);
+      const tracer = trace.getTracer("do_rpc_handler");
+      const doName = id.name || id.toString();
+      const executeRpc = async () => {
+        const attributes = {
+          [ATTR_RPC_SYSTEM]: "cloudflare_rpc",
+          [ATTR_RPC_METHOD]: methodName,
+          [ATTR_CLOUDFLARE_JSRPC_METHOD]: methodName,
+          [SemanticAttributes.FAAS_TRIGGER]: "rpc",
+          "do.id": id.toString(),
+          "do.name": id.name
+        };
+        const options = {
+          kind: SpanKind.SERVER,
+          attributes
+        };
+        const spanName = `Durable Object RPC ${doName}.${methodName}`;
+        return tracer.startActiveSpan(spanName, options, async (span) => {
+          try {
+            const bound = target.bind(thisArg);
+            const result = await bound.apply(thisArg, cleanedArgs);
+            span.setStatus({ code: SpanStatusCode.OK });
+            return result;
+          } catch (error) {
+            span.recordException(error);
+            span.setStatus({ code: SpanStatusCode.ERROR });
+            throw error;
+          } finally {
+            span.end();
+          }
+        });
+      };
+      return await context.with(context$1, executeRpc);
     }
   };
   return wrap(fn, fnHandler);
@@ -3094,9 +3203,9 @@ function instrumentDurableObject(doObj, initialiser, env, state, classStyle) {
         return instrumentAlarmFn(alarmFn, initialiser, env, state.id);
       } else {
         const result = Reflect.get(target, prop);
-        if (typeof result === "function") {
+        if (typeof result === "function" && typeof prop === "string") {
           result.bind(doObj);
-          return instrumentAnyFn(result, initialiser, env, state.id);
+          return instrumentRpcHandlerMethod(result, prop, initialiser, env, state.id);
         }
         return result;
       }
@@ -3583,7 +3692,8 @@ class ConsoleTransport {
     this.options = {
       pretty: options.pretty ?? true,
       colors: options.colors ?? false,
-      includeTimestamp: options.includeTimestamp ?? true
+      includeTimestamp: options.includeTimestamp ?? true,
+      transformLog: options.transformLog ?? ((l) => l)
     };
   }
   export(logs, callback) {