@inference-net/otel-cf-workers 2.0.2 → 2.0.4

package/dist/index.d.ts

@@ -522,7 +522,10 @@ export declare class WorkerLogger implements Logger {
     private readonly name;
     private readonly version?;
     private readonly inheritedAttributes;
-    constructor(name: string, processors: LogRecordProcessor[], resource: Resource, version?: string, inheritedAttributes?: LogAttributes);
+    private readonly minSeverity;
+    constructor(name: string, processors: LogRecordProcessor[], resource: Resource, version?: string, inheritedAttributes?: LogAttributes, minLevel?: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal');
+    private levelToSeverity;
+    private shouldEmit;
     emit(logRecord: Partial<LogRecord>): void;
     trace(message: string, attributes?: LogAttributes): void;
     debug(message: string, attributes?: LogAttributes): void;
@@ -542,7 +545,8 @@ export declare class WorkerLoggerProvider implements LoggerProvider {
     private loggers;
     private processors;
     private resource;
-    constructor(processors: LogRecordProcessor[], resource: Resource);
+    private minLevel;
+    constructor(processors: LogRecordProcessor[], resource: Resource, minLevel?: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal');
     getLogger(name: string, version?: string, options?: LoggerOptions): Logger;
     register(): void;
     shutdown(): Promise<void>;

package/dist/index.js

@@ -96,7 +96,7 @@ function passthroughGet(target, prop, thisArg) {
   }
 }
 
-const PACKAGE_VERSION = "2.0.2";
+const PACKAGE_VERSION = "2.0.4";
 const PACKAGE_NAME = "@inference-net/otel-cf-workers";
 const ATTR_CLOUDFLARE_COLO = "cloudflare.colo";
 const ATTR_CLOUDFLARE_RAY_ID = "cloudflare.ray_id";
@@ -1080,12 +1080,33 @@ class WorkerLogger {
   name;
   version;
   inheritedAttributes;
-  constructor(name, processors, resource, version, inheritedAttributes) {
+  minSeverity;
+  constructor(name, processors, resource, version, inheritedAttributes, minLevel = "info") {
     this.name = name;
     this.processors = processors;
     this.resource = resource;
     this.version = version;
     this.inheritedAttributes = inheritedAttributes || {};
+    this.minSeverity = this.levelToSeverity(minLevel);
+  }
+  levelToSeverity(level) {
+    switch (level) {
+      case "trace":
+        return SEVERITY_NUMBERS.TRACE;
+      case "debug":
+        return SEVERITY_NUMBERS.DEBUG;
+      case "info":
+        return SEVERITY_NUMBERS.INFO;
+      case "warn":
+        return SEVERITY_NUMBERS.WARN;
+      case "error":
+        return SEVERITY_NUMBERS.ERROR;
+      case "fatal":
+        return SEVERITY_NUMBERS.FATAL;
+    }
+  }
+  shouldEmit(severityNumber) {
+    return severityNumber >= this.minSeverity;
   }
   emit(logRecord) {
     const mergedAttributes = {
@@ -1107,6 +1128,7 @@ class WorkerLogger {
     });
   }
   trace(message, attributes) {
+    if (!this.shouldEmit(SEVERITY_NUMBERS.TRACE)) return;
     this.emit({
       severityNumber: SEVERITY_NUMBERS.TRACE,
       severityText: "TRACE",
@@ -1115,6 +1137,7 @@ class WorkerLogger {
     });
   }
   debug(message, attributes) {
+    if (!this.shouldEmit(SEVERITY_NUMBERS.DEBUG)) return;
     this.emit({
       severityNumber: SEVERITY_NUMBERS.DEBUG,
       severityText: "DEBUG",
@@ -1123,6 +1146,7 @@ class WorkerLogger {
     });
   }
   info(message, attributes) {
+    if (!this.shouldEmit(SEVERITY_NUMBERS.INFO)) return;
     this.emit({
       severityNumber: SEVERITY_NUMBERS.INFO,
       severityText: "INFO",
@@ -1131,6 +1155,7 @@ class WorkerLogger {
     });
   }
   warn(message, attributes) {
+    if (!this.shouldEmit(SEVERITY_NUMBERS.WARN)) return;
     this.emit({
       severityNumber: SEVERITY_NUMBERS.WARN,
       severityText: "WARN",
@@ -1139,6 +1164,7 @@ class WorkerLogger {
     });
   }
   error(message, attributes) {
+    if (!this.shouldEmit(SEVERITY_NUMBERS.ERROR)) return;
     let body;
     let attrs = { ...attributes };
     if (message instanceof Error) {
@@ -1160,6 +1186,7 @@ class WorkerLogger {
     });
   }
   fatal(message, attributes) {
+    if (!this.shouldEmit(SEVERITY_NUMBERS.FATAL)) return;
     this.emit({
       severityNumber: SEVERITY_NUMBERS.FATAL,
       severityText: "FATAL",
@@ -1180,7 +1207,14 @@ class WorkerLogger {
       ...this.inheritedAttributes,
       ...attributes
     };
-    return new WorkerLogger(this.name, this.processors, this.resource, this.version, mergedAttributes);
+    let minLevel = "info";
+    if (this.minSeverity <= SEVERITY_NUMBERS.TRACE) minLevel = "trace";
+    else if (this.minSeverity <= SEVERITY_NUMBERS.DEBUG) minLevel = "debug";
+    else if (this.minSeverity <= SEVERITY_NUMBERS.INFO) minLevel = "info";
+    else if (this.minSeverity <= SEVERITY_NUMBERS.WARN) minLevel = "warn";
+    else if (this.minSeverity <= SEVERITY_NUMBERS.ERROR) minLevel = "error";
+    else minLevel = "fatal";
+    return new WorkerLogger(this.name, this.processors, this.resource, this.version, mergedAttributes, minLevel);
   }
 }
 
@@ -1195,14 +1229,16 @@ class WorkerLoggerProvider {
   loggers = /* @__PURE__ */ new Map();
   processors;
   resource;
-  constructor(processors, resource) {
+  minLevel;
+  constructor(processors, resource, minLevel = "info") {
     this.processors = processors;
     this.resource = resource;
+    this.minLevel = minLevel;
   }
   getLogger(name, version, options) {
     const key = `${name}@${version || ""}:${options?.schemaUrl || ""}`;
     if (!this.loggers.has(key)) {
-      this.loggers.set(key, new WorkerLogger(name, this.processors, this.resource, version));
+      this.loggers.set(key, new WorkerLogger(name, this.processors, this.resource, version, void 0, this.minLevel));
     }
     return this.loggers.get(key);
   }
@@ -2924,6 +2960,45 @@ 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(), doName) {
+  const carrier = {
+    [RPC_CONTEXT_MARKER]: true,
+    headers: {}
+  };
+  if (doName) {
+    carrier.doName = doName;
+  }
+  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 = {
@@ -2944,7 +3019,9 @@ function instrumentRpcMethod(method, methodName, nsName, stubId) {
       const spanName = `RPC ${nsName}.${methodName}`;
       return tracer.startActiveSpan(spanName, options, async (span) => {
         try {
-          const result = await Reflect.apply(target, thisArg, argArray);
+          const contextCarrier = injectRpcContext(context.active(), stubId.name);
+          const argsWithContext = [contextCarrier, ...argArray];
+          const result = await Reflect.apply(target, thisArg, argsWithContext);
           span.setStatus({ code: SpanStatusCode.OK });
           return result;
         } catch (error) {
@@ -2991,12 +3068,24 @@ function instrumentBindingGet(getFn, nsName) {
   };
   return wrap(getFn, getHandler);
 }
+function instrumentBindingGetByName(getByNameFn, nsName) {
+  const getByNameHandler = {
+    apply(target, thisArg, argArray) {
+      const stub = Reflect.apply(target, thisArg, argArray);
+      return instrumentBindingStub(stub, nsName);
+    }
+  };
+  return wrap(getByNameFn, getByNameHandler);
+}
 function instrumentDOBinding(ns, nsName) {
   const nsHandler = {
     get(target, prop, receiver) {
       if (prop === "get") {
         const fn = Reflect.get(ns, prop, receiver);
         return instrumentBindingGet(fn, nsName);
+      } else if (prop === "getByName") {
+        const fn = Reflect.get(ns, prop, receiver);
+        return instrumentBindingGetByName(fn, nsName);
       } else {
         return passthroughGet(target, prop, receiver);
       }
@@ -3111,27 +3200,41 @@ function instrumentRpcHandlerMethod(fn, methodName, initialiser, env, id) {
     async apply(target, thisArg, argArray) {
       thisArg = unwrap(thisArg);
       const config = initialiser(env, "do-rpc");
-      const context$1 = setConfig(config);
+      const [extractedContext, cleanedArgs] = extractAndRemoveRpcContext(argArray);
+      const carrierDoName = argArray.length > 0 && extractedContext ? argArray[0].doName : void 0;
+      const doName = carrierDoName || id.name || void 0;
+      console.log("[DO RPC Server]", {
+        methodName,
+        hasExtractedContext: !!extractedContext,
+        carrierDoName,
+        idName: id.name,
+        finalDoName: doName,
+        argArrayLength: argArray.length,
+        cleanedArgsLength: cleanedArgs.length
+      });
+      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
+          "do.id": id.toString()
         };
+        if (doName) {
+          attributes["do.name"] = doName;
+        }
         const options = {
           kind: SpanKind.SERVER,
           attributes
         };
-        const spanName = `Durable Object RPC ${doName}.${methodName}`;
+        const spanName = doName ? `${doName}.${methodName}` : `${attributes["do.id"]}.${methodName}`;
         return tracer.startActiveSpan(spanName, options, async (span) => {
           try {
             const bound = target.bind(thisArg);
-            const result = await bound.apply(thisArg, argArray);
+            const result = await bound.apply(thisArg, cleanedArgs);
             span.setStatus({ code: SpanStatusCode.OK });
             return result;
           } catch (error) {
@@ -3351,7 +3454,7 @@ function init(config, serviceConfig, propagator) {
       traceProvider.register();
     }
     if (config.logs && config.logs.processors.length > 0) {
-      const logsProvider = new WorkerLoggerProvider(config.logs.processors, resource);
+      const logsProvider = new WorkerLoggerProvider(config.logs.processors, resource, config.logs.level);
       logsProvider.register();
       if (config.logs.instrumentation.instrumentConsole) {
         import('./console-Cy5QdByD.js').then(({ instrumentConsole }) => {
@@ -3659,7 +3762,7 @@ class ConsoleTransport {
   export(logs, callback) {
     try {
       for (const log of logs) {
-        this.printLog(log);
+        this.printLog(this.options.transformLog ? this.options.transformLog(log) : log);
       }
       callback({ code: ExportResultCode.SUCCESS });
     } catch (error) {