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

package/dist/index.d.ts

@@ -71,6 +71,7 @@ export declare type ConfigurationOption = WorkerOtelConfig | ResolveConfigFn;
 export declare class ConsoleTransport implements LogTransport {
     readonly name = "console";
     private options;
+    private minSeverity;
     constructor(options?: ConsoleTransportConfig);
     export(logs: ReadableLogRecord[], callback: ExportResultCallback): void;
     private printLog;
@@ -84,6 +85,7 @@ export declare interface ConsoleTransportConfig {
     pretty?: boolean;
     colors?: boolean;
     includeTimestamp?: boolean;
+    level?: LogLevel;
     transformLog?: (logRecord: ReadableLogRecord) => ReadableLogRecord;
 }
 
@@ -225,9 +227,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>;
 
@@ -237,10 +246,11 @@ 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;
+    child(name: string, attributes?: LogAttributes): Logger;
+    setProperties(attributes: LogAttributes): this;
 }
 
 export declare interface LoggerOptions {
@@ -253,6 +263,8 @@ export declare interface LoggerProvider {
     shutdown(): Promise<void>;
 }
 
+export declare type LogLevel = 'TRACE' | 'DEBUG' | 'INFO' | 'WARN' | 'ERROR' | 'FATAL';
+
 export declare interface LogRecord {
     readonly timeUnixNano: HrTime;
     readonly observedTimeUnixNano: HrTime;
@@ -275,7 +287,6 @@ export declare interface LogsConfig {
     transports?: LogTransport[];
     batching?: BatchConfig;
     instrumentation?: LogsInstrumentationOptions;
-    level?: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
 }
 
 export declare interface LogsInstrumentationOptions {
@@ -343,6 +354,7 @@ export declare class OTLPTransport implements LogTransport {
     readonly name = "otlp";
     private headers;
     private url;
+    private minSeverity;
     constructor(config: OTLPTransportConfig);
     export(logs: ReadableLogRecord[], callback: ExportResultCallback): void;
     private _export;
@@ -359,6 +371,7 @@ export declare class OTLPTransport implements LogTransport {
 export declare interface OTLPTransportConfig {
     url: string;
     headers?: Record<string, string>;
+    level?: LogLevel;
 }
 
 export declare interface ParentRatioSamplingConfig {
@@ -386,7 +399,6 @@ export declare type ResolveConfigFn<Env = any> = (env: Env, trigger: Trigger) =>
 export declare interface ResolvedLogsConfig {
     processors: LogRecordProcessor[];
     instrumentation: LogsInstrumentationOptions;
-    level: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
 }
 
 export declare interface ResolvedTraceConfig extends TraceConfigBase {
@@ -551,32 +563,33 @@ export declare class WorkerLogger implements Logger {
     private readonly resource;
     private readonly name;
     private readonly version?;
-    private readonly inheritedAttributes;
-    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;
+    private properties;
+    constructor(name: string, processors: LogRecordProcessor[], resource: Resource, version?: string, properties?: LogAttributes);
     emit(logRecord: Partial<LogRecord>): void;
     trace(message: string, attributes?: LogAttributes): void;
     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>;
     /**
-     * Create a child logger that inherits attributes from this logger
-     * Child attributes are merged with parent attributes (child takes precedence)
+     * Create a child logger with a concatenated name (parent:child) that inherits properties from this logger
+     * Child properties are merged with parent properties (child takes precedence)
+     */
+    child(name: string, attributes?: LogAttributes): Logger;
+    /**
+     * Add properties to this logger that will be included in all future log records
+     * New properties are merged with existing properties (new takes precedence)
      */
-    child(attributes: LogAttributes): Logger;
+    setProperties(attributes: LogAttributes): this;
 }
 
 export declare class WorkerLoggerProvider implements LoggerProvider {
     private loggers;
     private processors;
     private resource;
-    private minLevel;
-    constructor(processors: LogRecordProcessor[], resource: Resource, minLevel?: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal');
+    constructor(processors: LogRecordProcessor[], resource: Resource);
     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.2.0";
+const PACKAGE_VERSION = "2.3.0";
 const PACKAGE_NAME = "@inference-net/otel-cf-workers";
 const ATTR_CLOUDFLARE_COLO = "cloudflare.colo";
 const ATTR_CLOUDFLARE_RAY_ID = "cloudflare.ray_id";
@@ -600,8 +600,7 @@ function parseLogsConfig(supplied) {
     processors,
     instrumentation: {
       instrumentConsole: supplied.instrumentation?.instrumentConsole ?? false
-    },
-    level: supplied.level ?? "info"
+    }
   };
 }
 
@@ -1022,6 +1021,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 +1101,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"
@@ -1079,38 +1126,17 @@ class WorkerLogger {
   resource;
   name;
   version;
-  inheritedAttributes;
-  minSeverity;
-  constructor(name, processors, resource, version, inheritedAttributes, minLevel = "info") {
+  properties;
+  constructor(name, processors, resource, version, properties) {
     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;
+    this.properties = properties || {};
   }
   emit(logRecord) {
     const mergedAttributes = {
-      ...this.inheritedAttributes,
+      ...this.properties,
       ...logRecord.attributes || {}
     };
     const record = new LogRecordImpl({
@@ -1128,7 +1154,6 @@ class WorkerLogger {
     });
   }
   trace(message, attributes) {
-    if (!this.shouldEmit(SEVERITY_NUMBERS.TRACE)) return;
     this.emit({
       severityNumber: SEVERITY_NUMBERS.TRACE,
       severityText: "TRACE",
@@ -1137,7 +1162,6 @@ class WorkerLogger {
     });
   }
   debug(message, attributes) {
-    if (!this.shouldEmit(SEVERITY_NUMBERS.DEBUG)) return;
     this.emit({
       severityNumber: SEVERITY_NUMBERS.DEBUG,
       severityText: "DEBUG",
@@ -1146,7 +1170,6 @@ class WorkerLogger {
     });
   }
   info(message, attributes) {
-    if (!this.shouldEmit(SEVERITY_NUMBERS.INFO)) return;
     this.emit({
       severityNumber: SEVERITY_NUMBERS.INFO,
       severityText: "INFO",
@@ -1155,7 +1178,6 @@ class WorkerLogger {
     });
   }
   warn(message, attributes) {
-    if (!this.shouldEmit(SEVERITY_NUMBERS.WARN)) return;
     this.emit({
       severityNumber: SEVERITY_NUMBERS.WARN,
       severityText: "WARN",
@@ -1164,29 +1186,30 @@ 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",
@@ -1199,22 +1222,27 @@ class WorkerLogger {
     await Promise.allSettled(promises);
   }
   /**
-   * Create a child logger that inherits attributes from this logger
-   * Child attributes are merged with parent attributes (child takes precedence)
+   * Create a child logger with a concatenated name (parent:child) that inherits properties from this logger
+   * Child properties are merged with parent properties (child takes precedence)
    */
-  child(attributes) {
-    const mergedAttributes = {
-      ...this.inheritedAttributes,
+  child(name, attributes) {
+    const childName = `${this.name}:${name}`;
+    const mergedProperties = {
+      ...this.properties,
+      ...attributes || {}
+    };
+    return new WorkerLogger(childName, this.processors, this.resource, this.version, mergedProperties);
+  }
+  /**
+   * Add properties to this logger that will be included in all future log records
+   * New properties are merged with existing properties (new takes precedence)
+   */
+  setProperties(attributes) {
+    this.properties = {
+      ...this.properties,
       ...attributes
     };
-    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);
+    return this;
   }
 }
 
@@ -1229,16 +1257,14 @@ class WorkerLoggerProvider {
   loggers = /* @__PURE__ */ new Map();
   processors;
   resource;
-  minLevel;
-  constructor(processors, resource, minLevel = "info") {
+  constructor(processors, resource) {
     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, void 0, this.minLevel));
+      this.loggers.set(key, new WorkerLogger(name, this.processors, this.resource, version));
     }
     return this.loggers.get(key);
   }
@@ -1269,6 +1295,9 @@ class NoopLogger {
   child() {
     return this;
   }
+  setProperties() {
+    return this;
+  }
 }
 class NoopLoggerProvider {
   logger = new NoopLogger();
@@ -3531,7 +3560,7 @@ function init(config, serviceConfig, propagator) {
       traceProvider.register();
     }
     if (config.logs && config.logs.processors.length > 0) {
-      const logsProvider = new WorkerLoggerProvider(config.logs.processors, resource, config.logs.level);
+      const logsProvider = new WorkerLoggerProvider(config.logs.processors, resource);
       logsProvider.register();
       if (config.logs.instrumentation.instrumentConsole) {
         import('./console-Cy5QdByD.js').then(({ instrumentConsole }) => {
@@ -3697,16 +3726,39 @@ class MultiSpanExporterAsync {
   }
 }
 
+function 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;
+  }
+}
 class OTLPTransport {
   name = "otlp";
   headers;
   url;
+  minSeverity;
   constructor(config) {
     this.url = config.url;
     this.headers = Object.assign({}, DEFAULT_OTLP_HEADERS, config.headers);
+    this.minSeverity = levelToSeverity(config.level ?? "TRACE");
   }
   export(logs, callback) {
-    this._export(logs).then(() => {
+    const filteredLogs = logs.filter((log) => (log.severityNumber ?? 0) >= this.minSeverity);
+    if (filteredLogs.length === 0) {
+      callback({ code: ExportResultCode.SUCCESS });
+      return;
+    }
+    this._export(filteredLogs).then(() => {
       callback({ code: ExportResultCode.SUCCESS });
     }).catch((error) => {
       callback({ code: ExportResultCode.FAILED, error });
@@ -3834,6 +3886,7 @@ class OTLPTransport {
 class ConsoleTransport {
   name = "console";
   options;
+  minSeverity;
   constructor(options = {}) {
     this.options = {
       pretty: options.pretty ?? true,
@@ -3841,10 +3894,12 @@ class ConsoleTransport {
       includeTimestamp: options.includeTimestamp ?? true,
       transformLog: options.transformLog ?? ((l) => l)
     };
+    this.minSeverity = levelToSeverity(options.level ?? "TRACE");
   }
   export(logs, callback) {
     try {
       for (const log of logs) {
+        if ((log.severityNumber ?? 0) < this.minSeverity) continue;
         this.printLog(this.options.transformLog ? this.options.transformLog(log) : log);
       }
       callback({ code: ExportResultCode.SUCCESS });