@arivlabs/logger 1.4.1 → 2.0.0

package/dist/index.d.ts

@@ -1,11 +1,49 @@
 /**
- * Service names for ArivLabs services
- */
-export type ServiceName = 'api-gateway' | 'queue-manager' | 'scanner-result-processor' | 'enrichment-processor' | 'lineage-processor' | 'ai-proxy' | 'control-plane';
-/**
- * Domain names for structured logging
+ * @arivlabs/logger v2.0.0
+ *
+ * Structured logging for Node.js services with CloudWatch support.
+ *
+ * Features:
+ * - Async logging by default (high performance, non-blocking via SonicBoom)
+ * - Crash-safe logging via synchronous flush on fatal errors
+ * - Flexible types (define your own service/domain types)
+ * - Automatic sensitive data redaction
+ * - Child loggers with context
+ * - Graceful shutdown with proper drain handling
+ * - Buffer metrics for operational observability
+ *
+ * Architecture Notes:
+ * - Production mode uses pino.destination() (SonicBoom) for buffered async writes
+ * - SonicBoom provides flushSync() for crash-safe logging before process exit
+ * - Pretty mode uses pino-pretty transport (worker thread) - flush() is a no-op
+ * - Sync mode (enableAsync: false) writes immediately - flush() is a no-op
+ * - pino.final() was deprecated in Node 14+ and removed in pino v10; we use
+ *   direct flushSync() calls instead for crash-safe logging
+ * - Timestamps use ISO 8601 format with field name "time" (same as pino.stdTimeFunctions.isoTime)
+ *
+ * Operational Considerations:
+ * - Async logging can lose buffered logs on abrupt process termination (SIGKILL, OOM)
+ * - flushSync() is best-effort; under extreme backpressure, logs may still be dropped
+ * - Worker thread transports (pretty mode) have different ordering/timing guarantees
+ * - Use getBufferMetrics() to monitor buffer state in production
+ *
+ * @example
+ * ```typescript
+ * import { createLogger } from '@arivlabs/logger';
+ *
+ * const logger = createLogger({ service: 'my-service' });
+ *
+ * logger.info('Server started', { port: 3000 });
+ * logger.domain('auth').info('User logged in', { userId: '123' });
+ *
+ * // IMPORTANT: Call on shutdown to flush buffered logs
+ * process.on('SIGTERM', async () => {
+ *   await logger.shutdown();
+ *   process.exit(0);
+ * });
+ * ```
  */
-export type LogDomain = 'discovery' | 'auth' | 'connectors' | 'connector-types' | 'inventory' | 'lineage' | 'onboarding' | 'proxy' | 'users' | 'dashboard' | 'internal' | 'storage' | 'email' | 'queue' | 'system';
+import { type Logger as PinoLogger } from 'pino';
 /**
  * Redaction configuration for masking sensitive data
  */
@@ -25,36 +63,85 @@ export interface RedactConfig {
     remove?: boolean;
 }
 /**
- * Default sensitive field patterns that are always redacted
- * These are common security-sensitive fields
+ * Default sensitive field patterns that are always redacted.
+ * These cover common security-sensitive fields.
+ *
+ * Note: This is a readonly tuple. When merged with user paths, the result is string[].
  */
-export declare const DEFAULT_REDACT_PATHS: readonly ["password", "secret", "token", "apiKey", "api_key", "accessToken", "access_token", "refreshToken", "refresh_token", "sessionToken", "session_token", "secretAccessKey", "secret_access_key", "privateKey", "private_key", "*.password", "*.secret", "*.token", "*.apiKey", "*.api_key", "*.accessToken", "*.secretAccessKey", "*.privateKey", "req.headers.authorization", "req.headers.cookie", "req.headers[\"x-api-key\"]", "credentials.accessKeyId", "credentials.secretAccessKey", "credentials.sessionToken"];
+export declare const DEFAULT_REDACT_PATHS: readonly ["password", "secret", "token", "apiKey", "api_key", "accessToken", "access_token", "refreshToken", "refresh_token", "sessionToken", "session_token", "secretAccessKey", "secret_access_key", "privateKey", "private_key", "*.password", "*.secret", "*.token", "*.apiKey", "*.api_key", "*.accessToken", "*.refreshToken", "*.secretAccessKey", "*.privateKey", "req.headers.authorization", "req.headers.cookie", "req.headers[\"x-api-key\"]", "credentials.accessKeyId", "credentials.secretAccessKey", "credentials.sessionToken"];
 /**
  * Logger configuration options
  */
 export interface LoggerConfig {
-    /** Service name (e.g., 'api-gateway') */
-    service: ServiceName | string;
-    /** Environment (defaults to NODE_ENV or 'development') */
+    /** Service name (e.g., 'api-gateway', 'worker-service') */
+    service: string;
+    /** Environment (defaults to ENV or NODE_ENV or 'development') */
     environment?: string;
     /** Log level (defaults to 'debug' in dev, 'info' in prod) */
     level?: string;
-    /** Enable pretty printing (defaults to true in development) */
+    /** Enable pretty printing (defaults to true in development/local) */
     pretty?: boolean;
     /**
-     * Redaction configuration for masking sensitive data
+     * Redaction configuration for masking sensitive data.
      * Sensitive fields are automatically masked. Use this to add custom paths.
      */
     redact?: RedactConfig;
+    /**
+     * Enable async (buffered) logging mode.
+     *
+     * - `true`: Logs are buffered and written asynchronously (high performance).
+     *   You MUST call `logger.shutdown()` before process exit.
+     * - `false`: All logs are written synchronously (guaranteed immediate write).
+     * - Default: `true` in production, `false` in development/local/test.
+     */
+    enableAsync?: boolean;
+    /**
+     * Buffer size before auto-flush in async mode (default: 4096 bytes).
+     * Lower = more frequent writes, higher = better batching.
+     */
+    asyncBufferSize?: number;
+    /**
+     * Custom base fields to include in every log entry.
+     */
+    base?: Record<string, unknown>;
+    /**
+     * Register handlers for uncaughtException and unhandledRejection.
+     * When true, these events will be logged with synchronous flush for crash-safety.
+     *
+     * In production mode (SonicBoom destination), flushSync() ensures buffered logs
+     * are written before process exit. This is best-effort - under extreme conditions
+     * (SIGKILL, OOM, system crash), some logs may still be lost.
+     *
+     * In pretty mode (development), logs are sent to a worker thread transport
+     * and crash-safe delivery cannot be guaranteed.
+     *
+     * Default: false (opt-in for safety).
+     */
+    handleExceptions?: boolean;
+    /**
+     * Whether to call process.exit(1) after logging fatal errors from
+     * uncaughtException/unhandledRejection handlers.
+     *
+     * - `true`: Logger will exit the process after logging (default for backward compat)
+     * - `false`: Logger only logs, allowing app to handle exit and other cleanup
+     *
+     * Setting this to `false` is recommended when:
+     * - You have other cleanup to perform (DB connections, metrics, etc.)
+     * - You have other exception handlers installed
+     * - You want the app to control exit behavior
+     *
+     * Only applies when handleExceptions is true.
+     * Default: true
+     */
+    exitOnFatal?: boolean;
 }
 /**
- * Log data object
- * Pass Error objects as `err` or `error` - both work and will be serialized properly
+ * Log data object.
+ * Pass Error objects as `err` or `error` - both work and will be serialized properly.
  *
  * @example
  * logger.error('Request failed', { err: error });   // Works
  * logger.error('Request failed', { error: error }); // Also works - auto-converted to err
- * logger.error('Request failed', { error: err.message }); // Bad - loses error type/stack
  */
 export type LogData = Record<string, unknown> & {
     /** Pass Error objects here for proper serialization (type, message, stack, custom props) */
@@ -63,17 +150,56 @@ export type LogData = Record<string, unknown> & {
     error?: Error | unknown;
 };
 /**
- * Flexible log method signature supporting multiple calling conventions
+ * Flexible log method signature supporting multiple calling conventions.
  */
 export interface FlexibleLogFn {
+    /** String message with optional data object (intuitive style) */
     (msg: string, data?: LogData): void;
+    /** Object with msg property (pino native style) */
     (obj: LogData & {
         msg?: string;
     }): void;
+    /** Object first, then message (pino native style) */
     (obj: LogData, msg?: string): void;
 }
 /**
- * Extended logger interface with domain support and flexible API
+ * Request context for correlation tracking.
+ */
+export interface RequestContext {
+    /** Correlation ID for request tracing */
+    correlationId: string;
+    /** Optional user ID */
+    userId?: string;
+    /** Optional tenant ID */
+    tenantId?: string;
+    /** Optional domain context */
+    domain?: string;
+}
+/**
+ * Buffer metrics for operational observability.
+ * Use these to monitor logger health and detect backpressure issues.
+ */
+export interface BufferMetrics {
+    /** Whether the logger is operating in async (buffered) mode */
+    isAsync: boolean;
+    /** Whether the logger is in pretty mode (worker thread transport) */
+    isPrettyMode: boolean;
+    /** Whether buffer metrics are available (false in pretty mode) */
+    metricsAvailable: boolean;
+    /**
+     * Whether the underlying stream is currently experiencing backpressure.
+     * When true, writes may be queued or dropped depending on configuration.
+     * Only available when metricsAvailable is true.
+     */
+    isBackpressured?: boolean;
+    /**
+     * Whether the destination stream is destroyed/closed.
+     * Only available when metricsAvailable is true.
+     */
+    isDestroyed?: boolean;
+}
+/**
+ * Extended logger interface with domain support and flexible API.
  */
 export interface ArivLogger {
     /** Log at trace level */
@@ -88,53 +214,97 @@ export interface ArivLogger {
     error: FlexibleLogFn;
     /** Log at fatal level */
     fatal: FlexibleLogFn;
-    /** Create a child logger for a specific domain */
-    domain: (domain: LogDomain) => ArivLogger;
-    /** Create a child logger with request context */
-    withContext: (context: RequestContext) => ArivLogger;
-    /** Create a child logger with additional bindings */
-    child: (bindings: LogData) => ArivLogger;
-    /** Check if level is enabled */
-    isLevelEnabled: (level: string) => boolean;
-    /** Current log level */
+    /**
+     * Create a child logger for a specific domain.
+     * @example
+     * const authLogger = logger.domain('auth');
+     * authLogger.info('User logged in', { userId });
+     */
+    domain(name: string): ArivLogger;
+    /**
+     * Create a child logger with request context.
+     * @example
+     * const reqLogger = logger.withContext({
+     *   correlationId: 'abc-123',
+     *   tenantId: 'tenant-1',
+     *   domain: 'discovery'
+     * });
+     */
+    withContext(context: RequestContext): ArivLogger;
+    /**
+     * Create a child logger with additional bindings.
+     * @example
+     * const jobLogger = logger.child({ jobId: '123' });
+     */
+    child(bindings: LogData): ArivLogger;
+    /** Check if a log level is enabled */
+    isLevelEnabled(level: string): boolean;
+    /** Current log level (readable and writable) */
     level: string;
+    /**
+     * Flush all buffered logs to destination synchronously.
+     *
+     * **Important: This is a no-op in the following cases:**
+     * - Pretty mode (development): pino-pretty runs in a worker thread without flushSync()
+     * - Sync mode (`enableAsync: false`): Writes are immediate, no buffer to flush
+     *
+     * Only performs work when ALL conditions are met:
+     * - Production mode (JSON output with SonicBoom destination)
+     * - Async mode enabled (`enableAsync: true` or production defaults)
+     * - Buffer has pending data (`minLength > 0`)
+     *
+     * For guaranteed delivery during shutdown, use shutdown() instead.
+     */
+    flush(): void;
+    /**
+     * Graceful shutdown - flushes logs and prepares for exit.
+     * Call this on SIGTERM/SIGINT handlers before process.exit().
+     *
+     * This method:
+     * 1. Cleans up exception handlers if registered
+     * 2. Synchronously flushes the buffer (production mode only)
+     * 3. Closes the destination stream with a 5s timeout
+     *
+     * In pretty mode (development), this is largely a no-op since the
+     * pino-pretty transport runs in a worker thread.
+     *
+     * @returns Promise that resolves when shutdown is complete
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Get buffer metrics for operational observability.
+     * Use this to monitor logger health and detect backpressure issues.
+     *
+     * Note: In pretty mode, detailed metrics are not available since the
+     * transport runs in a worker thread.
+     *
+     * @example
+     * ```typescript
+     * // Monitor buffer health
+     * setInterval(() => {
+     *   const metrics = logger.getBufferMetrics();
+     *   if (metrics.isBackpressured) {
+     *     console.warn('Logger buffer backpressure detected');
+     *   }
+     * }, 5000);
+     * ```
+     */
+    getBufferMetrics(): BufferMetrics;
+    /** Access to underlying pino logger (for advanced use cases) */
+    readonly pino: PinoLogger;
 }
 /**
- * Request context for correlation
- */
-export interface RequestContext {
-    correlationId: string;
-    userId?: string;
-    tenantId?: string;
-    domain?: LogDomain;
-}
-/**
- * Create a structured logger for an ArivLabs service
- *
- * Supports flexible calling conventions:
- * - Intuitive style: `logger.info('Message', { key: value })`
- * - Pino native style: `logger.info({ msg: 'Message', key: value })`
+ * Create a structured logger for a service.
  *
  * @example
  * ```typescript
- * import { createLogger } from '@arivlabs/logger';
- *
- * const logger = createLogger({ service: 'api-gateway' });
- *
- * // Basic logging (intuitive style - recommended)
+ * // Basic usage
+ * const logger = createLogger({ service: 'my-service' });
  * logger.info('Server started', { port: 3000 });
  *
- * // Error logging - both { err } and { error } work
- * logger.error('Request failed', { err: error });   // ✅ Works
- * logger.error('Request failed', { error: error }); // ✅ Also works
- * logger.error('Request failed', { error: err.message }); // ❌ Bad - pass Error object
- *
- * // Also works: pino native style
- * logger.info({ msg: 'Server started', port: 3000 });
- *
  * // Domain-specific logging
- * const discoveryLog = logger.domain('discovery');
- * discoveryLog.info('Job created', { jobId: '123' });
+ * const authLog = logger.domain('auth');
+ * authLog.info('User logged in', { userId: '123' });
  *
  * // Request context logging
  * const reqLog = logger.withContext({
@@ -142,25 +312,34 @@ export interface RequestContext {
  *   tenantId: 'tenant-1',
  *   domain: 'discovery'
  * });
- * reqLog.info('Processing request');
+ *
+ * // Error logging - both { err } and { error } work
+ * logger.error('Request failed', { err: error });
+ * logger.error('Request failed', { error }); // Auto-converted
+ *
+ * // IMPORTANT: Graceful shutdown (required for async mode)
+ * process.on('SIGTERM', async () => {
+ *   await logger.shutdown();
+ *   process.exit(0);
+ * });
  * ```
  *
  * CloudWatch Insights queries:
- * - Filter by service: `fields @timestamp, @message | filter service = "api-gateway"`
- * - Filter by domain: `fields @timestamp, @message | filter domain = "discovery"`
- * - Filter errors: `fields @timestamp, @message | filter level = "error"`
- * - Filter by tenant: `fields @timestamp, @message | filter tenant_id = "xxx"`
+ * - Filter by service: `filter service = "my-service"`
+ * - Filter by domain: `filter domain = "auth"`
+ * - Filter errors: `filter level >= 50`
+ * - Filter by tenant: `filter tenant_id = "xxx"`
  */
 export declare function createLogger(config: LoggerConfig): ArivLogger;
 /**
- * Create a domain-specific child logger
- * @deprecated Use logger.domain() instead
+ * Create a domain-specific child logger.
+ * @deprecated Use `logger.domain(name)` instead.
  */
-export declare function createDomainLogger(logger: ArivLogger, domain: LogDomain): ArivLogger;
+export declare function createDomainLogger(logger: ArivLogger, domain: string): ArivLogger;
 /**
- * Create a child logger with request context
- * @deprecated Use logger.withContext() instead
+ * Create a child logger with request context.
+ * @deprecated Use `logger.withContext()` instead.
  */
-export declare function createRequestLogger(logger: ArivLogger, domain: LogDomain, correlationId: string, userId?: string, tenantId?: string): ArivLogger;
+export declare function createRequestLogger(logger: ArivLogger, domain: string, correlationId: string, userId?: string, tenantId?: string): ArivLogger;
 export type { Logger as PinoLogger } from 'pino';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,MAAM,WAAW,GACnB,aAAa,GACb,eAAe,GACf,0BAA0B,GAC1B,sBAAsB,GACtB,mBAAmB,GACnB,UAAU,GACV,eAAe,CAAC;AAEpB;;GAEG;AACH,MAAM,MAAM,SAAS,GACjB,WAAW,GACX,MAAM,GACN,YAAY,GACZ,iBAAiB,GACjB,WAAW,GACX,SAAS,GACT,YAAY,GACZ,OAAO,GACP,OAAO,GACP,WAAW,GACX,UAAU,GACV,SAAS,GACT,OAAO,GACP,OAAO,GACP,QAAQ,CAAC;AAEb;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;GAGG;AACH,eAAO,MAAM,oBAAoB,ggBAqCvB,CAAC;AAEX;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,yCAAyC;IACzC,OAAO,EAAE,WAAW,GAAG,MAAM,CAAC;IAC9B,0DAA0D;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6DAA6D;IAC7D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+DAA+D;IAC/D,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAC9C,4FAA4F;IAC5F,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC;IACtB,iFAAiF;IACjF,KAAK,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC;CACzB,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,aAAa;IAE5B,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAEpC,CAAC,GAAG,EAAE,OAAO,GAAG;QAAE,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAExC,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,yBAAyB;IACzB,KAAK,EAAE,aAAa,CAAC;IACrB,yBAAyB;IACzB,KAAK,EAAE,aAAa,CAAC;IACrB,wBAAwB;IACxB,IAAI,EAAE,aAAa,CAAC;IACpB,wBAAwB;IACxB,IAAI,EAAE,aAAa,CAAC;IACpB,yBAAyB;IACzB,KAAK,EAAE,aAAa,CAAC;IACrB,yBAAyB;IACzB,KAAK,EAAE,aAAa,CAAC;IACrB,kDAAkD;IAClD,MAAM,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,UAAU,CAAC;IAC1C,iDAAiD;IACjD,WAAW,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,UAAU,CAAC;IACrD,qDAAqD;IACrD,KAAK,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,UAAU,CAAC;IACzC,gCAAgC;IAChC,cAAc,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IAC3C,wBAAwB;IACxB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,SAAS,CAAC;CACpB;AA+ED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,UAAU,CAqD7D;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,GAAG,UAAU,CAEpF;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,SAAS,EACjB,aAAa,EAAE,MAAM,EACrB,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,GAChB,UAAU,CAOZ;AAGD,YAAY,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,MAAM,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}