autotel 3.6.0 → 4.0.0

package/dist/logger.cjs

@@ -1,38 +1,238 @@
-'use strict';
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-var chunkFU6R566Y_cjs = require('./chunk-FU6R566Y.cjs');
-require('./chunk-ESLWRGAG.cjs');
-require('./chunk-YREV3LGG.cjs');
+//#region src/logger.ts
+/**
+* Logger types and utilities for autotel
+*
+* **Zero-Config Option:** Don't provide a logger to `init()` and autotel uses
+* a built-in structured JSON logger with automatic trace context injection.
+*
+* **BYOL (Bring Your Own Logger):** Pass Pino or Bunyan to `init()` for
+* automatic instrumentation with trace context and OTLP log export.
+*
+* ## Logger Signature
+*
+* Autotel v2.10+ uses **Pino's signature**: `logger.info({ metadata }, 'message')`.
+*
+* ### Backward Compatibility
+*
+* The built-in logger auto-detects legacy Winston-style calls and swaps arguments:
+* ```typescript
+* // Legacy (auto-detected and handled)
+* logger.info('User created', { userId: '123' });
+* // → Internally treated as: logger.info({ userId: '123' }, 'User created')
+* // → Logs warning in development, works silently in production
+* ```
+*
+* ### Recommended Usage
+*
+* ```typescript
+* // ✅ Pino-style (preferred)
+* logger.info({ userId: '123' }, 'User created');
+*
+* // ✅ Simple message (no metadata)
+* logger.info('Server started');
+* ```
+*
+* **Note:** If you BYOL (bring your own logger), it must use Pino signature.
+* Winston and other `(message, meta)` loggers are NOT compatible.
+* For Winston, use `@opentelemetry/instrumentation-winston` instead.
+*
+* @example Zero-config (uses built-in logger)
+* ```typescript
+* import { init } from 'autotel';
+*
+* init({ service: 'my-app' });
+* // Internal logs: {"level":"info","service":"my-app","msg":"...","traceId":"..."}
+* ```
+*
+* @example Using built-in logger directly
+* ```typescript
+* import { createBuiltinLogger, runWithLogLevel } from 'autotel/logger';
+*
+* const log = createBuiltinLogger('my-service');
+*
+* // Simple message (no metadata)
+* log.info('Server started');
+*
+* // With metadata (Pino-style: object first, message second)
+* log.info({ userId: '123' }, 'User created');
+* // Output: {"level":"info","service":"my-service","msg":"User created","userId":"123","traceId":"..."}
+*
+* // Dynamic log level per-request
+* runWithLogLevel('debug', () => {
+*   log.debug('Debug info for this request only');
+* });
+* ```
+*
+* @example Using Pino (recommended for production, auto-instrumented)
+* ```typescript
+* import pino from 'pino';  // npm install pino
+* import { init } from 'autotel';
+*
+* const logger = pino({ level: 'info' });
+* init({ service: 'my-app', logger });
+*
+* // Logs automatically include traceId/spanId and export via OTLP!
+* logger.info({ userId: '123' }, 'User created');
+* ```
+*
+* @example Using Bunyan (auto-instrumented, same signature as Pino)
+* ```typescript
+* import bunyan from 'bunyan';  // npm install bunyan @opentelemetry/instrumentation-bunyan
+* import { init } from 'autotel';
+* import { BunyanInstrumentation } from '@opentelemetry/instrumentation-bunyan';
+*
+* const logger = bunyan.createLogger({ name: 'my-app' });
+* init({
+*   service: 'my-app',
+*   logger,
+*   instrumentations: [new BunyanInstrumentation()]
+* });
+* ```
+*
+* @example Custom logger (MUST use Pino-compatible signature)
+* ```typescript
+* // ⚠️ Your custom logger MUST accept (object, message?) signature
+* const logger = {
+*   info: (extra, msg) => console.log(msg || '', extra),
+*   warn: (extra, msg) => console.warn(msg || '', extra),
+*   error: (extra, msg) => console.error(msg || '', extra),
+*   debug: (extra, msg) => console.debug(msg || '', extra),
+* };
+* init({ service: 'my-app', logger });
+* ```
+*
+* @example BYOL helper: inject trace context into any logger
+* ```typescript
+* import bunyan from 'bunyan';
+* import { getTraceContext } from 'autotel/logger';
+*
+* const bunyanLogger = bunyan.createLogger({ name: 'myapp' });
+* const ctx = getTraceContext();
+* bunyanLogger.info({ ...ctx, userId: '123' }, 'Creating user');
+* ```
+*/
+/**
+* Log level constants
+*/
+const LOG_LEVEL = {
+	DEBUG: "debug",
+	INFO: "info",
+	WARN: "warn",
+	ERROR: "error"
+};
+/**
+* TS5+ Standard Decorator for logging and tracing operations
+* Uses TC39 Stage 3 decorator syntax
+*
+* This is the traditional per-method decorator approach.
+* For zero-boilerplate solution, see @Instrumented class decorator.
+*
+* @example
+* // Simple usage (Pino-style: object first, message second)
+* class OrderService {
+*   constructor(private readonly deps: { log: Logger }) {}
+*
+*   @LoggedOperation('order.create')
+*   async createOrder(data: CreateOrderData) {
+*     // ✅ Correct Pino-style logging
+*     this.deps.log.info({ orderId: data.id }, 'Creating order');
+*   }
+* }
+*
+* // Advanced usage (future-proof for options)
+* @LoggedOperation({ operationName: 'order.create' })
+* async createOrder(data: CreateOrderData) { }
+*/
+function LoggedOperation(operationNameOrOptions) {
+	const operationName = typeof operationNameOrOptions === "string" ? operationNameOrOptions : operationNameOrOptions.operationName;
+	return function(originalMethod, context) {
+		const methodName = String(context.name);
+		return async function(...args) {
+			const log = this.deps?.log;
+			const startTime = performance.now();
+			return getConfig().tracer.startActiveSpan(operationName, async (span) => {
+				try {
+					log?.info({
+						operation: operationName,
+						method: methodName,
+						args
+					}, "Operation started");
+					const result = await originalMethod.apply(this, args);
+					const duration = performance.now() - startTime;
+					log?.info({
+						operation: operationName,
+						method: methodName,
+						duration
+					}, "Operation completed");
+					span.setStatus({ code: SpanStatusCode.OK });
+					span.setAttributes({
+						"operation.name": operationName,
+						"operation.method": methodName,
+						"operation.duration": duration,
+						"operation.success": true
+					});
+					return result;
+				} catch (error) {
+					const duration = performance.now() - startTime;
+					log?.error({
+						err: error instanceof Error ? error : void 0,
+						operation: operationName,
+						method: methodName,
+						duration
+					}, "Operation failed");
+					span.setStatus({
+						code: SpanStatusCode.ERROR,
+						message: error instanceof Error ? error.message : "Unknown error"
+					});
+					span.setAttributes({
+						"operation.name": operationName,
+						"operation.method": methodName,
+						"operation.duration": duration,
+						"operation.success": false,
+						"error.type": error instanceof Error ? error.constructor.name : "Unknown"
+					});
+					throw error;
+				} finally {
+					span.end();
+				}
+			});
+		};
+	};
+}
 
-
-
-Object.defineProperty(exports, "LOG_LEVEL", {
-  enumerable: true,
-  get: function () { return chunkFU6R566Y_cjs.LOG_LEVEL; }
-});
-Object.defineProperty(exports, "LoggedOperation", {
-  enumerable: true,
-  get: function () { return chunkFU6R566Y_cjs.LoggedOperation; }
-});
-Object.defineProperty(exports, "autotelLogger", {
+//#endregion
+exports.LOG_LEVEL = LOG_LEVEL;
+exports.LoggedOperation = LoggedOperation;
+Object.defineProperty(exports, 'autotelLogger', {
   enumerable: true,
-  get: function () { return chunkFU6R566Y_cjs.autotelLogger; }
+  get: function () {
+    return autotelLogger;
+  }
 });
-Object.defineProperty(exports, "createBuiltinLogger", {
+Object.defineProperty(exports, 'createBuiltinLogger', {
   enumerable: true,
-  get: function () { return chunkFU6R566Y_cjs.createBuiltinLogger; }
+  get: function () {
+    return createBuiltinLogger;
+  }
 });
-Object.defineProperty(exports, "getActiveLogLevel", {
+Object.defineProperty(exports, 'getActiveLogLevel', {
   enumerable: true,
-  get: function () { return chunkFU6R566Y_cjs.getActiveLogLevel; }
+  get: function () {
+    return getActiveLogLevel;
+  }
 });
-Object.defineProperty(exports, "getTraceContext", {
+Object.defineProperty(exports, 'getTraceContext', {
   enumerable: true,
-  get: function () { return chunkFU6R566Y_cjs.getTraceContext; }
+  get: function () {
+    return getTraceContext;
+  }
 });
-Object.defineProperty(exports, "runWithLogLevel", {
+Object.defineProperty(exports, 'runWithLogLevel', {
   enumerable: true,
-  get: function () { return chunkFU6R566Y_cjs.runWithLogLevel; }
+  get: function () {
+    return runWithLogLevel;
+  }
 });
-//# sourceMappingURL=logger.cjs.map
 //# sourceMappingURL=logger.cjs.map

package/dist/logger.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"logger.cjs"}
+{"version":3,"file":"logger.cjs","names":[],"sources":["../src/logger.ts"],"sourcesContent":["/**\n * Logger types and utilities for autotel\n *\n * **Zero-Config Option:** Don't provide a logger to `init()` and autotel uses\n * a built-in structured JSON logger with automatic trace context injection.\n *\n * **BYOL (Bring Your Own Logger):** Pass Pino or Bunyan to `init()` for\n * automatic instrumentation with trace context and OTLP log export.\n *\n * ## Logger Signature\n *\n * Autotel v2.10+ uses **Pino's signature**: `logger.info({ metadata }, 'message')`.\n *\n * ### Backward Compatibility\n *\n * The built-in logger auto-detects legacy Winston-style calls and swaps arguments:\n * ```typescript\n * // Legacy (auto-detected and handled)\n * logger.info('User created', { userId: '123' });\n * // → Internally treated as: logger.info({ userId: '123' }, 'User created')\n * // → Logs warning in development, works silently in production\n * ```\n *\n * ### Recommended Usage\n *\n * ```typescript\n * // ✅ Pino-style (preferred)\n * logger.info({ userId: '123' }, 'User created');\n *\n * // ✅ Simple message (no metadata)\n * logger.info('Server started');\n * ```\n *\n * **Note:** If you BYOL (bring your own logger), it must use Pino signature.\n * Winston and other `(message, meta)` loggers are NOT compatible.\n * For Winston, use `@opentelemetry/instrumentation-winston` instead.\n *\n * @example Zero-config (uses built-in logger)\n * ```typescript\n * import { init } from 'autotel';\n *\n * init({ service: 'my-app' });\n * // Internal logs: {\"level\":\"info\",\"service\":\"my-app\",\"msg\":\"...\",\"traceId\":\"...\"}\n * ```\n *\n * @example Using built-in logger directly\n * ```typescript\n * import { createBuiltinLogger, runWithLogLevel } from 'autotel/logger';\n *\n * const log = createBuiltinLogger('my-service');\n *\n * // Simple message (no metadata)\n * log.info('Server started');\n *\n * // With metadata (Pino-style: object first, message second)\n * log.info({ userId: '123' }, 'User created');\n * // Output: {\"level\":\"info\",\"service\":\"my-service\",\"msg\":\"User created\",\"userId\":\"123\",\"traceId\":\"...\"}\n *\n * // Dynamic log level per-request\n * runWithLogLevel('debug', () => {\n *   log.debug('Debug info for this request only');\n * });\n * ```\n *\n * @example Using Pino (recommended for production, auto-instrumented)\n * ```typescript\n * import pino from 'pino';  // npm install pino\n * import { init } from 'autotel';\n *\n * const logger = pino({ level: 'info' });\n * init({ service: 'my-app', logger });\n *\n * // Logs automatically include traceId/spanId and export via OTLP!\n * logger.info({ userId: '123' }, 'User created');\n * ```\n *\n * @example Using Bunyan (auto-instrumented, same signature as Pino)\n * ```typescript\n * import bunyan from 'bunyan';  // npm install bunyan @opentelemetry/instrumentation-bunyan\n * import { init } from 'autotel';\n * import { BunyanInstrumentation } from '@opentelemetry/instrumentation-bunyan';\n *\n * const logger = bunyan.createLogger({ name: 'my-app' });\n * init({\n *   service: 'my-app',\n *   logger,\n *   instrumentations: [new BunyanInstrumentation()]\n * });\n * ```\n *\n * @example Custom logger (MUST use Pino-compatible signature)\n * ```typescript\n * // ⚠️ Your custom logger MUST accept (object, message?) signature\n * const logger = {\n *   info: (extra, msg) => console.log(msg || '', extra),\n *   warn: (extra, msg) => console.warn(msg || '', extra),\n *   error: (extra, msg) => console.error(msg || '', extra),\n *   debug: (extra, msg) => console.debug(msg || '', extra),\n * };\n * init({ service: 'my-app', logger });\n * ```\n *\n * @example BYOL helper: inject trace context into any logger\n * ```typescript\n * import bunyan from 'bunyan';\n * import { getTraceContext } from 'autotel/logger';\n *\n * const bunyanLogger = bunyan.createLogger({ name: 'myapp' });\n * const ctx = getTraceContext();\n * bunyanLogger.info({ ...ctx, userId: '123' }, 'Creating user');\n * ```\n */\n\nimport { SpanStatusCode } from '@opentelemetry/api';\nimport { getConfig } from './config';\n\n// ============================================================================\n// Logger Types\n// ============================================================================\n\n/**\n * Log level constants\n */\nexport const LOG_LEVEL = {\n  DEBUG: 'debug',\n  INFO: 'info',\n  WARN: 'warn',\n  ERROR: 'error',\n} as const;\n\nexport type LogLevel = (typeof LOG_LEVEL)[keyof typeof LOG_LEVEL];\n\n/**\n * Logger configuration (for reference - not needed with BYOL approach)\n */\nexport interface LoggerConfig {\n  service: string;\n  level?: LogLevel;\n  pretty?: boolean;\n  redact?: string[] | false;\n}\n\n/**\n * Pino-compatible log function signature\n *\n * Matches Pino's actual LogFn type which supports:\n * - `(msg: string)` - simple string message\n * - `(obj: object, msg?: string)` - object first with optional message\n *\n * @example\n * ```typescript\n * logger.info('User logged in');\n * logger.info({ userId: '123' }, 'User created');\n * logger.error({ err: error }, 'Operation failed');\n * ```\n */\nexport interface LogFn {\n  (msg: string): void;\n  (obj: Record<string, unknown>, msg?: string): void;\n}\n\n/**\n * Simple logger interface - Pino/Bunyan-compatible\n *\n * Uses Pino's LogFn signature which supports both:\n * - `logger.info('message')` - simple string message\n * - `logger.info({ extra }, 'message')` - object first with optional message\n *\n * This is compatible with Pino, Bunyan, and any logger following this pattern.\n *\n * @example Using Pino (just works!)\n * ```typescript\n * import pino from 'pino';\n * const logger = pino({ level: 'info' });\n * init({ service: 'my-app', logger });\n * ```\n *\n * @example Direct usage\n * ```typescript\n * logger.info('Simple message');\n * logger.info({ userId: '123' }, 'User created');\n * logger.error({ err: error }, 'Operation failed');\n * ```\n */\nexport interface Logger {\n  info: LogFn;\n  warn: LogFn;\n  error: LogFn;\n  debug: LogFn;\n}\n\n/**\n * Alias for Logger interface (backwards compatibility)\n * @deprecated Use Logger instead\n */\nexport type ILogger = Logger;\n\n/**\n * Pino logger type - re-exported for convenience\n *\n * Note: This is a type-only export. To use Pino, install it as a peer dependency:\n * `npm install pino`\n */\nexport type { Logger as PinoLogger } from 'pino';\n\n// ============================================================================\n// LoggedOperation Decorator\n// ============================================================================\n\nexport interface LoggedOperationOptions {\n  /** Operation name for tracing (e.g., 'user.createUser') */\n  operationName: string;\n}\n\n/**\n * TS5+ Standard Decorator for logging and tracing operations\n * Uses TC39 Stage 3 decorator syntax\n *\n * This is the traditional per-method decorator approach.\n * For zero-boilerplate solution, see @Instrumented class decorator.\n *\n * @example\n * // Simple usage (Pino-style: object first, message second)\n * class OrderService {\n *   constructor(private readonly deps: { log: Logger }) {}\n *\n *   @LoggedOperation('order.create')\n *   async createOrder(data: CreateOrderData) {\n *     // ✅ Correct Pino-style logging\n *     this.deps.log.info({ orderId: data.id }, 'Creating order');\n *   }\n * }\n *\n * // Advanced usage (future-proof for options)\n * @LoggedOperation({ operationName: 'order.create' })\n * async createOrder(data: CreateOrderData) { }\n */\nexport function LoggedOperation(\n  operationNameOrOptions: string | LoggedOperationOptions,\n) {\n  const operationName =\n    typeof operationNameOrOptions === 'string'\n      ? operationNameOrOptions\n      : operationNameOrOptions.operationName;\n\n  return function <This, Args extends unknown[], Return>(\n    originalMethod: (this: This, ...args: Args) => Promise<Return>,\n    context: ClassMethodDecoratorContext<\n      This,\n      (this: This, ...args: Args) => Promise<Return>\n    >,\n  ) {\n    const methodName = String(context.name);\n\n    return async function (this: This, ...args: Args): Promise<Return> {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const log = (this as any).deps?.log;\n      const startTime = performance.now();\n\n      const config = getConfig();\n      const tracer = config.tracer;\n\n      return tracer.startActiveSpan(operationName, async (span) => {\n        try {\n          log?.info(\n            {\n              operation: operationName,\n              method: methodName,\n              args,\n            },\n            'Operation started',\n          );\n\n          const result = await originalMethod.apply(this, args);\n\n          const duration = performance.now() - startTime;\n          log?.info(\n            {\n              operation: operationName,\n              method: methodName,\n              duration,\n            },\n            'Operation completed',\n          );\n\n          span.setStatus({ code: SpanStatusCode.OK });\n          span.setAttributes({\n            'operation.name': operationName,\n            'operation.method': methodName,\n            'operation.duration': duration,\n            'operation.success': true,\n          });\n\n          return result;\n        } catch (error) {\n          const duration = performance.now() - startTime;\n          log?.error(\n            {\n              err: error instanceof Error ? error : undefined,\n              operation: operationName,\n              method: methodName,\n              duration,\n            },\n            'Operation failed',\n          );\n\n          span.setStatus({\n            code: SpanStatusCode.ERROR,\n            message: error instanceof Error ? error.message : 'Unknown error',\n          });\n          span.setAttributes({\n            'operation.name': operationName,\n            'operation.method': methodName,\n            'operation.duration': duration,\n            'operation.success': false,\n            'error.type':\n              error instanceof Error ? error.constructor.name : 'Unknown',\n          });\n\n          throw error;\n        } finally {\n          span.end();\n        }\n      });\n    };\n  };\n}\n\n// ============================================================================\n// Built-in Logger (re-exports)\n// ============================================================================\n\nexport {\n  autotelLogger,\n  createBuiltinLogger,\n  runWithLogLevel,\n  getTraceContext,\n  getActiveLogLevel,\n  type BuiltinLogLevel,\n  type BuiltinLoggerOptions,\n} from './autotel-logger';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2HA,MAAa,YAAY;CACvB,OAAO;CACP,MAAM;CACN,MAAM;CACN,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;AA6GA,SAAgB,gBACd,wBACA;CACA,MAAM,gBACJ,OAAO,2BAA2B,WAC9B,yBACA,uBAAuB;CAE7B,OAAO,SACL,gBACA,SAIA;EACA,MAAM,aAAa,OAAO,QAAQ,IAAI;EAEtC,OAAO,eAA4B,GAAG,MAA6B;GAEjE,MAAM,MAAO,KAAa,MAAM;GAChC,MAAM,YAAY,YAAY,IAAI;GAKlC,OAHe,UACK,CAAC,CAAC,OAER,gBAAgB,eAAe,OAAO,SAAS;IAC3D,IAAI;KACF,KAAK,KACH;MACE,WAAW;MACX,QAAQ;MACR;KACF,GACA,mBACF;KAEA,MAAM,SAAS,MAAM,eAAe,MAAM,MAAM,IAAI;KAEpD,MAAM,WAAW,YAAY,IAAI,IAAI;KACrC,KAAK,KACH;MACE,WAAW;MACX,QAAQ;MACR;KACF,GACA,qBACF;KAEA,KAAK,UAAU,EAAE,MAAM,eAAe,GAAG,CAAC;KAC1C,KAAK,cAAc;MACjB,kBAAkB;MAClB,oBAAoB;MACpB,sBAAsB;MACtB,qBAAqB;KACvB,CAAC;KAED,OAAO;IACT,SAAS,OAAO;KACd,MAAM,WAAW,YAAY,IAAI,IAAI;KACrC,KAAK,MACH;MACE,KAAK,iBAAiB,QAAQ,QAAQ;MACtC,WAAW;MACX,QAAQ;MACR;KACF,GACA,kBACF;KAEA,KAAK,UAAU;MACb,MAAM,eAAe;MACrB,SAAS,iBAAiB,QAAQ,MAAM,UAAU;KACpD,CAAC;KACD,KAAK,cAAc;MACjB,kBAAkB;MAClB,oBAAoB;MACpB,sBAAsB;MACtB,qBAAqB;MACrB,cACE,iBAAiB,QAAQ,MAAM,YAAY,OAAO;KACtD,CAAC;KAED,MAAM;IACR,UAAU;KACR,KAAK,IAAI;IACX;GACF,CAAC;EACH;CACF;AACF"}

package/dist/logger.d.cts

@@ -1,348 +1,2 @@
-export { Logger as PinoLogger } from 'pino';
-
-/**
- * Zero-dependency structured logger for autotel
- *
- * This logger provides:
- * - Structured JSON logging (production) or pretty print (development)
- * - Auto trace context injection (traceId, spanId, correlationId)
- * - Dynamic log level control (per-request via OTel context)
- * - Level support (debug, info, warn, error, none)
- * - Zero additional dependencies (uses @opentelemetry/api, already a dep)
- *
- * Uses Pino-compatible signature supporting both patterns:
- * - `log.info('simple message')` - string-only
- * - `log.info({ userId: '123' }, 'message')` - object first with optional message
- *
- * Used as the default fallback when users don't provide Pino/Bunyan.
- * Can also be used directly: import { createBuiltinLogger } from 'autotel/logger'
- *
- * @example
- * ```typescript
- * import { createBuiltinLogger, runWithLogLevel } from 'autotel/logger';
- *
- * const log = createBuiltinLogger('my-service');
- *
- * // Simple message (no metadata)
- * log.info('Server started');
- *
- * // With metadata (Pino-style: object first, message second)
- * log.info({ userId: '123' }, 'User created');
- * // Output: {"level":"info","service":"my-service","msg":"User created","userId":"123","traceId":"..."}
- *
- * // Dynamic log level per-request
- * runWithLogLevel('debug', () => {
- *   log.debug('This will log even if default level is "info"');
- * });
- * ```
- */
-
-type BuiltinLogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
-/**
- * Get the active log level from context (if set)
- * Falls back to undefined if no log level is set in context
- */
-declare function getActiveLogLevel(): BuiltinLogLevel | undefined;
-/**
- * Run a function with a specific log level
- * The log level is stored in OpenTelemetry context and applies to all logger calls within the callback
- *
- * @example
- * ```typescript
- * // Enable debug logging for a specific request
- * runWithLogLevel('debug', () => {
- *   log.debug('This will be logged');
- *   processRequest();
- * });
- *
- * // Disable logging temporarily
- * runWithLogLevel('none', () => {
- *   log.info('This will NOT be logged');
- * });
- * ```
- */
-declare function runWithLogLevel<T>(level: BuiltinLogLevel, callback: () => T): T;
-/**
- * Helper to get trace context (useful for BYOL - Bring Your Own Logger)
- *
- * @example
- * ```typescript
- * import bunyan from 'bunyan';
- * import { getTraceContext } from 'autotel/logger';
- *
- * const bunyanLogger = bunyan.createLogger({ name: 'myapp' });
- * const ctx = getTraceContext();
- * bunyanLogger.info({ ...ctx, email: 'test@example.com' }, 'Creating user');
- * ```
- */
-declare function getTraceContext(): {
-    traceId: string;
-    spanId: string;
-    correlationId: string;
-} | null;
-interface BuiltinLoggerOptions {
-    /** Minimum log level. Default: 'info' */
-    level?: BuiltinLogLevel;
-    /** Pretty print for development. Default: false (JSON output) */
-    pretty?: boolean;
-}
-/**
- * Create a lightweight structured logger
- *
- * @param service - Service name for logging
- * @param options - Optional configuration
- *
- * @example
- * ```typescript
- * const log = createBuiltinLogger('user-service');
- *
- * log.info('Creating user', { email: 'test@example.com' });
- * // Output: {"level":"info","service":"user-service","msg":"Creating user",
- * //          "email":"test@example.com","traceId":"...","spanId":"..."}
- *
- * // Dynamic log level control per-request
- * runWithLogLevel('debug', () => {
- *   log.debug('This will be logged even if logger was created with level: "info"');
- * });
- * ```
- */
-declare function createBuiltinLogger(service: string, options?: BuiltinLoggerOptions): Logger;
-/**
- * Pino-like factory function for creating an autotel logger
- *
- * @example
- * ```typescript
- * import { autotelLogger } from 'autotel/logger';
- *
- * const log = autotelLogger();
- *
- * // Simple message
- * log.info('Server started');
- *
- * // With metadata (Pino-style: object first, message second)
- * log.info({ userId: '123' }, 'User created');
- *
- * // With options
- * const devLog = autotelLogger({ service: 'my-app', level: 'debug', pretty: true });
- * ```
- */
-declare function autotelLogger(options?: {
-    service?: string;
-    level?: BuiltinLogLevel;
-    pretty?: boolean;
-}): Logger;
-
-/**
- * Logger types and utilities for autotel
- *
- * **Zero-Config Option:** Don't provide a logger to `init()` and autotel uses
- * a built-in structured JSON logger with automatic trace context injection.
- *
- * **BYOL (Bring Your Own Logger):** Pass Pino or Bunyan to `init()` for
- * automatic instrumentation with trace context and OTLP log export.
- *
- * ## Logger Signature
- *
- * Autotel v2.10+ uses **Pino's signature**: `logger.info({ metadata }, 'message')`.
- *
- * ### Backward Compatibility
- *
- * The built-in logger auto-detects legacy Winston-style calls and swaps arguments:
- * ```typescript
- * // Legacy (auto-detected and handled)
- * logger.info('User created', { userId: '123' });
- * // → Internally treated as: logger.info({ userId: '123' }, 'User created')
- * // → Logs warning in development, works silently in production
- * ```
- *
- * ### Recommended Usage
- *
- * ```typescript
- * // ✅ Pino-style (preferred)
- * logger.info({ userId: '123' }, 'User created');
- *
- * // ✅ Simple message (no metadata)
- * logger.info('Server started');
- * ```
- *
- * **Note:** If you BYOL (bring your own logger), it must use Pino signature.
- * Winston and other `(message, meta)` loggers are NOT compatible.
- * For Winston, use `@opentelemetry/instrumentation-winston` instead.
- *
- * @example Zero-config (uses built-in logger)
- * ```typescript
- * import { init } from 'autotel';
- *
- * init({ service: 'my-app' });
- * // Internal logs: {"level":"info","service":"my-app","msg":"...","traceId":"..."}
- * ```
- *
- * @example Using built-in logger directly
- * ```typescript
- * import { createBuiltinLogger, runWithLogLevel } from 'autotel/logger';
- *
- * const log = createBuiltinLogger('my-service');
- *
- * // Simple message (no metadata)
- * log.info('Server started');
- *
- * // With metadata (Pino-style: object first, message second)
- * log.info({ userId: '123' }, 'User created');
- * // Output: {"level":"info","service":"my-service","msg":"User created","userId":"123","traceId":"..."}
- *
- * // Dynamic log level per-request
- * runWithLogLevel('debug', () => {
- *   log.debug('Debug info for this request only');
- * });
- * ```
- *
- * @example Using Pino (recommended for production, auto-instrumented)
- * ```typescript
- * import pino from 'pino';  // npm install pino
- * import { init } from 'autotel';
- *
- * const logger = pino({ level: 'info' });
- * init({ service: 'my-app', logger });
- *
- * // Logs automatically include traceId/spanId and export via OTLP!
- * logger.info({ userId: '123' }, 'User created');
- * ```
- *
- * @example Using Bunyan (auto-instrumented, same signature as Pino)
- * ```typescript
- * import bunyan from 'bunyan';  // npm install bunyan @opentelemetry/instrumentation-bunyan
- * import { init } from 'autotel';
- * import { BunyanInstrumentation } from '@opentelemetry/instrumentation-bunyan';
- *
- * const logger = bunyan.createLogger({ name: 'my-app' });
- * init({
- *   service: 'my-app',
- *   logger,
- *   instrumentations: [new BunyanInstrumentation()]
- * });
- * ```
- *
- * @example Custom logger (MUST use Pino-compatible signature)
- * ```typescript
- * // ⚠️ Your custom logger MUST accept (object, message?) signature
- * const logger = {
- *   info: (extra, msg) => console.log(msg || '', extra),
- *   warn: (extra, msg) => console.warn(msg || '', extra),
- *   error: (extra, msg) => console.error(msg || '', extra),
- *   debug: (extra, msg) => console.debug(msg || '', extra),
- * };
- * init({ service: 'my-app', logger });
- * ```
- *
- * @example BYOL helper: inject trace context into any logger
- * ```typescript
- * import bunyan from 'bunyan';
- * import { getTraceContext } from 'autotel/logger';
- *
- * const bunyanLogger = bunyan.createLogger({ name: 'myapp' });
- * const ctx = getTraceContext();
- * bunyanLogger.info({ ...ctx, userId: '123' }, 'Creating user');
- * ```
- */
-/**
- * Log level constants
- */
-declare const LOG_LEVEL: {
-    readonly DEBUG: "debug";
-    readonly INFO: "info";
-    readonly WARN: "warn";
-    readonly ERROR: "error";
-};
-type LogLevel = (typeof LOG_LEVEL)[keyof typeof LOG_LEVEL];
-/**
- * Logger configuration (for reference - not needed with BYOL approach)
- */
-interface LoggerConfig {
-    service: string;
-    level?: LogLevel;
-    pretty?: boolean;
-    redact?: string[] | false;
-}
-/**
- * Pino-compatible log function signature
- *
- * Matches Pino's actual LogFn type which supports:
- * - `(msg: string)` - simple string message
- * - `(obj: object, msg?: string)` - object first with optional message
- *
- * @example
- * ```typescript
- * logger.info('User logged in');
- * logger.info({ userId: '123' }, 'User created');
- * logger.error({ err: error }, 'Operation failed');
- * ```
- */
-interface LogFn {
-    (msg: string): void;
-    (obj: Record<string, unknown>, msg?: string): void;
-}
-/**
- * Simple logger interface - Pino/Bunyan-compatible
- *
- * Uses Pino's LogFn signature which supports both:
- * - `logger.info('message')` - simple string message
- * - `logger.info({ extra }, 'message')` - object first with optional message
- *
- * This is compatible with Pino, Bunyan, and any logger following this pattern.
- *
- * @example Using Pino (just works!)
- * ```typescript
- * import pino from 'pino';
- * const logger = pino({ level: 'info' });
- * init({ service: 'my-app', logger });
- * ```
- *
- * @example Direct usage
- * ```typescript
- * logger.info('Simple message');
- * logger.info({ userId: '123' }, 'User created');
- * logger.error({ err: error }, 'Operation failed');
- * ```
- */
-interface Logger {
-    info: LogFn;
-    warn: LogFn;
-    error: LogFn;
-    debug: LogFn;
-}
-/**
- * Alias for Logger interface (backwards compatibility)
- * @deprecated Use Logger instead
- */
-type ILogger = Logger;
-
-interface LoggedOperationOptions {
-    /** Operation name for tracing (e.g., 'user.createUser') */
-    operationName: string;
-}
-/**
- * TS5+ Standard Decorator for logging and tracing operations
- * Uses TC39 Stage 3 decorator syntax
- *
- * This is the traditional per-method decorator approach.
- * For zero-boilerplate solution, see @Instrumented class decorator.
- *
- * @example
- * // Simple usage (Pino-style: object first, message second)
- * class OrderService {
- *   constructor(private readonly deps: { log: Logger }) {}
- *
- *   @LoggedOperation('order.create')
- *   async createOrder(data: CreateOrderData) {
- *     // ✅ Correct Pino-style logging
- *     this.deps.log.info({ orderId: data.id }, 'Creating order');
- *   }
- * }
- *
- * // Advanced usage (future-proof for options)
- * @LoggedOperation({ operationName: 'order.create' })
- * async createOrder(data: CreateOrderData) { }
- */
-declare function LoggedOperation(operationNameOrOptions: string | LoggedOperationOptions): <This, Args extends unknown[], Return>(originalMethod: (this: This, ...args: Args) => Promise<Return>, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Promise<Return>>) => (this: This, ...args: Args) => Promise<Return>;
-
-export { type BuiltinLogLevel, type BuiltinLoggerOptions, type ILogger, LOG_LEVEL, type LogFn, type LogLevel, LoggedOperation, type LoggedOperationOptions, type Logger, type LoggerConfig, autotelLogger, createBuiltinLogger, getActiveLogLevel, getTraceContext, runWithLogLevel };
+import { a as LoggedOperation, c as LoggerConfig, d as BuiltinLoggerOptions, f as autotelLogger, g as runWithLogLevel, h as getTraceContext, i as LogLevel, l as PinoLogger, m as getActiveLogLevel, n as LOG_LEVEL, o as LoggedOperationOptions, p as createBuiltinLogger, r as LogFn, s as Logger, t as ILogger, u as BuiltinLogLevel } from "./logger-BauSUhUv.cjs";
+export { type BuiltinLogLevel, type BuiltinLoggerOptions, ILogger, LOG_LEVEL, LogFn, LogLevel, LoggedOperation, LoggedOperationOptions, Logger, LoggerConfig, type PinoLogger, autotelLogger, createBuiltinLogger, getActiveLogLevel, getTraceContext, runWithLogLevel };