{"version":3,"file":"logger-thMPLpOG.cjs","names":["api_context","trace","extra","getConfig","SpanStatusCode"],"sources":["../src/autotel-logger.ts","../src/logger.ts"],"sourcesContent":["/**\n * Zero-dependency structured logger for autotel\n *\n * This logger provides:\n * - Structured JSON logging (production) or pretty print (development)\n * - Auto trace context injection (traceId, spanId, correlationId)\n * - Dynamic log level control (per-request via OTel context)\n * - Level support (debug, info, warn, error, none)\n * - Zero additional dependencies (uses @opentelemetry/api, already a dep)\n *\n * Uses Pino-compatible signature supporting both patterns:\n * - `log.info('simple message')` - string-only\n * - `log.info({ userId: '123' }, 'message')` - object first with optional message\n *\n * Used as the default fallback when users don't provide Pino/Bunyan.\n * Can also be used directly: import { createBuiltinLogger } from 'autotel/logger'\n *\n * @example\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('This will log even if default level is \"info\"');\n * });\n * ```\n */\n\nimport {\n trace,\n context as api_context,\n createContextKey,\n} from '@opentelemetry/api';\nimport type { Logger } from './logger';\n\nexport type BuiltinLogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';\n\n/**\n * Context key for storing active log level (enables per-request log levels)\n */\nconst LOG_LEVEL_KEY = createContextKey('autotel-log-level');\n\n/**\n * Get the active log level from context (if set)\n * Falls back to undefined if no log level is set in context\n */\nexport function getActiveLogLevel(): BuiltinLogLevel | undefined {\n return api_context.active().getValue(LOG_LEVEL_KEY) as\n | BuiltinLogLevel\n | undefined;\n}\n\n/**\n * Run a function with a specific log level\n * The log level is stored in OpenTelemetry context and applies to all logger calls within the callback\n *\n * @example\n * ```typescript\n * // Enable debug logging for a specific request\n * runWithLogLevel('debug', () => {\n * log.debug('This will be logged');\n * processRequest();\n * });\n *\n * // Disable logging temporarily\n * runWithLogLevel('none', () => {\n * log.info('This will NOT be logged');\n * });\n * ```\n */\nexport function runWithLogLevel(\n level: BuiltinLogLevel,\n callback: () => T,\n): T {\n const ctx = api_context.active().setValue(LOG_LEVEL_KEY, level);\n return api_context.with(ctx, callback);\n}\n\n/**\n * Get current trace context from active span\n * Returns null if no active span exists\n */\nfunction getTraceContextInternal(): {\n traceId: string;\n spanId: string;\n correlationId: string;\n} | null {\n const span = trace.getActiveSpan();\n if (!span) return null;\n\n const ctx = span.spanContext();\n return {\n traceId: ctx.traceId,\n spanId: ctx.spanId,\n correlationId: ctx.traceId.slice(0, 16), // First 16 chars for grouping\n };\n}\n\n/**\n * Helper to get trace context (useful for BYOL - Bring Your Own Logger)\n *\n * @example\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, email: 'test@example.com' }, 'Creating user');\n * ```\n */\nexport function getTraceContext() {\n return getTraceContextInternal();\n}\n\nexport interface BuiltinLoggerOptions {\n /** Minimum log level. Default: 'info' */\n level?: BuiltinLogLevel;\n /** Pretty print for development. Default: false (JSON output) */\n pretty?: boolean;\n}\n\n/**\n * Create a lightweight structured logger\n *\n * @param service - Service name for logging\n * @param options - Optional configuration\n *\n * @example\n * ```typescript\n * const log = createBuiltinLogger('user-service');\n *\n * log.info('Creating user', { email: 'test@example.com' });\n * // Output: {\"level\":\"info\",\"service\":\"user-service\",\"msg\":\"Creating user\",\n * // \"email\":\"test@example.com\",\"traceId\":\"...\",\"spanId\":\"...\"}\n *\n * // Dynamic log level control per-request\n * runWithLogLevel('debug', () => {\n * log.debug('This will be logged even if logger was created with level: \"info\"');\n * });\n * ```\n */\nexport function createBuiltinLogger(\n service: string,\n options?: BuiltinLoggerOptions,\n): Logger {\n const defaultLevel = options?.level || 'info';\n const pretty = options?.pretty || false;\n\n const levelPriority: Record = {\n none: -1,\n debug: 0,\n info: 1,\n warn: 2,\n error: 3,\n };\n\n const shouldLog = (level: BuiltinLogLevel): boolean => {\n // Priority: context level > options level > 'info' default\n const activeLevel = getActiveLogLevel() ?? defaultLevel;\n\n // 'none' means suppress all logging\n if (activeLevel === 'none') return false;\n\n return levelPriority[level] >= levelPriority[activeLevel];\n };\n\n const log = (\n level: 'info' | 'error' | 'warn' | 'debug',\n msg: string,\n attrs?: Record,\n ) => {\n if (!shouldLog(level)) return;\n\n const ctx = getTraceContextInternal();\n const logEntry: Record = {\n level,\n service,\n msg,\n ...attrs,\n ...ctx, // Auto-inject traceId, spanId, correlationId\n timestamp: new Date().toISOString(),\n };\n\n if (pretty) {\n // Pretty print for development\n const traceInfo = ctx\n ? ` [${ctx.traceId.slice(0, 8)}.../${ctx.spanId.slice(0, 8)}...]`\n : '';\n console.log(\n `[${level.toUpperCase()}]${traceInfo} ${service}: ${msg}`,\n attrs || '',\n );\n } else {\n // Structured JSON for production\n console.log(JSON.stringify(logEntry));\n }\n };\n\n // Pino-compatible signature: supports both:\n // - logger.info('message') - string-only\n // - logger.info({ extra }, 'message') - Pino style with metadata\n // Also auto-detects and handles legacy Winston-style: logger.info('message', { extra })\n const createLogMethod = (level: 'info' | 'warn' | 'debug') => {\n return (\n extraOrMessage: Record | string,\n message?: string | Record,\n ) => {\n if (typeof extraOrMessage === 'string') {\n // First arg is string - could be:\n // 1. String-only: logger.info('message')\n // 2. Legacy Winston-style: logger.info('message', { extra })\n if (message !== undefined && typeof message === 'object') {\n // Legacy Winston-style detected - auto-swap for backward compatibility\n if (process.env.NODE_ENV !== 'production') {\n console.warn(\n `[autotel] Legacy logger pattern detected: logger.${level}('message', metadata). ` +\n `Autotel recommends Pino signature: logger.${level}({ ...metadata }, 'message'). ` +\n `Auto-swapping arguments for compatibility.`,\n );\n }\n // Swap: treat first arg as message, second as metadata\n log(level, extraOrMessage, message as Record);\n } else {\n // Pure string-only call: logger.info('message')\n log(level, extraOrMessage);\n }\n } else {\n // Pino style: logger.info({ extra }, 'message')\n log(level, (message as string) || '', extraOrMessage);\n }\n };\n };\n\n return {\n info: createLogMethod('info'),\n warn: createLogMethod('warn'),\n debug: createLogMethod('debug'),\n\n error: (\n extraOrMessage: Record | string,\n message?: string | Record | Error,\n ) => {\n if (typeof extraOrMessage === 'string') {\n // First arg is string - could be:\n // 1. String-only: logger.error('message')\n // 2. Legacy: logger.error('message', error) - Error as second arg\n // 3. Legacy: logger.error('message', { extra }) - object as second arg\n\n // Handle legacy logger.error('message', error) pattern\n if (message instanceof Error) {\n if (process.env.NODE_ENV !== 'production') {\n console.warn(\n `[autotel] Legacy logger pattern detected: logger.error('message', error). ` +\n `Autotel recommends Pino signature: logger.error({ err: error }, 'message'). ` +\n `Auto-swapping arguments for compatibility.`,\n );\n }\n log('error', extraOrMessage, {\n error: message.message,\n stack: message.stack,\n name: message.name,\n });\n return;\n }\n\n // Handle legacy logger.error('message', { extra }) pattern\n if (message !== undefined && typeof message === 'object') {\n if (process.env.NODE_ENV !== 'production') {\n console.warn(\n `[autotel] Legacy logger pattern detected: logger.error('message', metadata). ` +\n `Autotel recommends Pino signature: logger.error({ ...metadata }, 'message'). ` +\n `Auto-swapping arguments for compatibility.`,\n );\n }\n // Swap: treat first arg as message, second as metadata (handle err extraction)\n const extra = message as Record;\n const { err, ...rest } = extra as Record & {\n err?: unknown;\n };\n let errorAttrs: Record = rest;\n if (err instanceof Error) {\n errorAttrs = {\n error: err.message,\n stack: err.stack,\n name: err.name,\n ...rest,\n };\n } else if (err !== undefined) {\n errorAttrs = { err, ...rest };\n }\n log('error', extraOrMessage, errorAttrs);\n return;\n }\n\n // Pure string-only call: logger.error('message')\n log('error', extraOrMessage);\n return;\n }\n\n // Pino style: logger.error({ err, ...extra }, 'message')\n // Extract err from extra if present (Pino convention)\n const { err, ...rest } = extraOrMessage as Record & {\n err?: unknown;\n };\n let errorAttrs: Record = rest;\n if (err instanceof Error) {\n // err is an Error - extract message, stack, name for structured logging\n errorAttrs = {\n error: err.message,\n stack: err.stack,\n name: err.name,\n ...rest,\n };\n } else if (err !== undefined) {\n // err is not an Error but exists - preserve it as-is\n errorAttrs = {\n err,\n ...rest,\n };\n }\n log('error', (message as string) || '', errorAttrs);\n },\n };\n}\n\n/**\n * Pino-like factory function for creating an autotel logger\n *\n * @example\n * ```typescript\n * import { autotelLogger } from 'autotel/logger';\n *\n * const log = autotelLogger();\n *\n * // Simple message\n * log.info('Server started');\n *\n * // With metadata (Pino-style: object first, message second)\n * log.info({ userId: '123' }, 'User created');\n *\n * // With options\n * const devLog = autotelLogger({ service: 'my-app', level: 'debug', pretty: true });\n * ```\n */\nexport function autotelLogger(options?: {\n service?: string;\n level?: BuiltinLogLevel;\n pretty?: boolean;\n}): Logger {\n return createBuiltinLogger(options?.service || 'app', {\n level: options?.level,\n pretty: options?.pretty,\n });\n}\n","/**\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, 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 (\n originalMethod: (this: This, ...args: Args) => Promise,\n context: ClassMethodDecoratorContext<\n This,\n (this: This, ...args: Args) => Promise\n >,\n ) {\n const methodName = String(context.name);\n\n return async function (this: This, ...args: Args): Promise {\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":"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"}