@inference-net/otel-cf-workers 2.1.1 → 2.2.1

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;
@@ -195,9 +225,16 @@ export declare interface LocalTrace {
     readonly spans: ReadableSpan[];
 }
 
-export declare interface LogAttributes {
-    [key: string]: any;
-}
+/**
+ * Log attributes must be a plain object with string keys.
+ * This type explicitly excludes strings to prevent accidental argument swapping.
+ */
+export declare type LogAttributes = {
+    [key: string]: unknown;
+} & {
+    length?: never;
+    substring?: never;
+};
 
 export declare type LogBody = string | Record<string, any>;
 
@@ -207,7 +244,7 @@ export declare interface Logger {
     debug(message: string, attributes?: LogAttributes): void;
     info(message: string, attributes?: LogAttributes): void;
     warn(message: string, attributes?: LogAttributes): void;
-    error(message: string | Error, attributes?: LogAttributes): void;
+    error(message: string, attributes?: LogAttributes): void;
     fatal(message: string, attributes?: LogAttributes): void;
     forceFlush(): Promise<void>;
     child(attributes: LogAttributes): Logger;
@@ -531,7 +568,7 @@ export declare class WorkerLogger implements Logger {
     debug(message: string, attributes?: LogAttributes): void;
     info(message: string, attributes?: LogAttributes): void;
     warn(message: string, attributes?: LogAttributes): void;
-    error(message: string | Error, attributes?: LogAttributes): void;
+    error(message: string, attributes?: LogAttributes): void;
     fatal(message: string, attributes?: LogAttributes): void;
     forceFlush(): Promise<void>;
     /**

package/dist/index.js

@@ -96,7 +96,7 @@ function passthroughGet(target, prop, thisArg) {
   }
 }
 
-const PACKAGE_VERSION = "2.1.1";
+const PACKAGE_VERSION = "2.2.1";
 const PACKAGE_NAME = "@inference-net/otel-cf-workers";
 const ATTR_CLOUDFLARE_COLO = "cloudflare.colo";
 const ATTR_CLOUDFLARE_RAY_ID = "cloudflare.ray_id";
@@ -1022,6 +1022,53 @@ class WorkerTracerProvider {
 function millisToHr(millis) {
   return [Math.trunc(millis / 1e3), millis % 1e3 * 1e6];
 }
+function flattenError(error, prefix) {
+  const result = {};
+  result[`${prefix}.type`] = error.name;
+  result[`${prefix}.message`] = error.message;
+  if (error.stack) {
+    result[`${prefix}.stacktrace`] = error.stack;
+  }
+  if ("cause" in error && error.cause) {
+    if (error.cause instanceof Error) {
+      Object.assign(result, flattenError(error.cause, `${prefix}.cause`));
+    } else {
+      result[`${prefix}.cause`] = String(error.cause);
+    }
+  }
+  return result;
+}
+function flattenAttributes(attrs, prefix = "") {
+  const result = {};
+  for (const [key, value] of Object.entries(attrs)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (value === null || value === void 0) {
+      continue;
+    } else if (value instanceof Error) {
+      Object.assign(result, flattenError(value, fullKey));
+    } else if (Array.isArray(value)) {
+      const hasObjects = value.some((item) => item !== null && typeof item === "object" && !Array.isArray(item));
+      if (hasObjects) {
+        value.forEach((item, index) => {
+          if (item instanceof Error) {
+            Object.assign(result, flattenError(item, `${fullKey}.${index}`));
+          } else if (item !== null && typeof item === "object" && !Array.isArray(item)) {
+            Object.assign(result, flattenAttributes(item, `${fullKey}.${index}`));
+          } else if (item !== null && item !== void 0) {
+            result[`${fullKey}.${index}`] = item;
+          }
+        });
+      } else {
+        result[fullKey] = value;
+      }
+    } else if (typeof value === "object") {
+      Object.assign(result, flattenAttributes(value, fullKey));
+    } else {
+      result[fullKey] = value;
+    }
+  }
+  return result;
+}
 function getHrTime(input) {
   const now = Date.now();
   if (!input) {
@@ -1055,7 +1102,8 @@ class LogRecordImpl {
     this.severityNumber = init.severityNumber;
     this.severityText = init.severityText;
     this.body = init.body;
-    this.attributes = sanitizeAttributes(init.attributes || {});
+    const flattenedAttributes = flattenAttributes(init.attributes || {});
+    this.attributes = sanitizeAttributes(flattenedAttributes);
     this.resource = init.resource;
     this.instrumentationScope = init.instrumentationScope || {
       name: "@inference-net/otel-cf-workers"
@@ -1165,28 +1213,31 @@ class WorkerLogger {
   }
   error(message, attributes) {
     if (!this.shouldEmit(SEVERITY_NUMBERS.ERROR)) return;
-    let body;
-    let attrs = { ...attributes };
-    if (message instanceof Error) {
-      body = message.message;
-      attrs = {
-        ...attrs,
-        "exception.type": message.name,
-        "exception.message": message.message,
-        "exception.stacktrace": message.stack
-      };
-    } else {
-      body = message;
+    const exception = attributes?.["error"] instanceof Error ? attributes["error"] : void 0;
+    const activeSpan = trace.getActiveSpan();
+    if (activeSpan) {
+      activeSpan.setStatus({ code: SpanStatusCode.ERROR, message });
+      if (exception) {
+        activeSpan.recordException(exception);
+      }
     }
     this.emit({
       severityNumber: SEVERITY_NUMBERS.ERROR,
       severityText: "ERROR",
-      body,
-      attributes: attrs
+      body: message,
+      attributes
     });
   }
   fatal(message, attributes) {
     if (!this.shouldEmit(SEVERITY_NUMBERS.FATAL)) return;
+    const exception = attributes?.["error"] instanceof Error ? attributes["error"] : void 0;
+    const activeSpan = trace.getActiveSpan();
+    if (activeSpan) {
+      activeSpan.setStatus({ code: SpanStatusCode.ERROR, message });
+      if (exception) {
+        activeSpan.recordException(exception);
+      }
+    }
     this.emit({
       severityNumber: SEVERITY_NUMBERS.FATAL,
       severityText: "FATAL",
@@ -3033,6 +3084,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 = {
@@ -3277,14 +3371,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") {
@@ -3313,16 +3403,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);
@@ -3866,5 +3968,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