@vitkuz/aws-logger 1.3.0 → 1.5.0

package/.prettierignore

@@ -1,4 +1,5 @@
-dist
 node_modules
-package-lock.json
-*.json
+dist
+coverage
+.turbo
+.build

package/.prettierrc.json

@@ -0,0 +1,8 @@
+{
+    "semi": true,
+    "trailingComma": "all",
+    "singleQuote": true,
+    "printWidth": 100,
+    "tabWidth": 2,
+    "arrowParens": "always"
+}

package/dist/index.d.mts

@@ -2,7 +2,7 @@ interface Logger {
     debug(message: string, context?: Record<string, any>): void;
     info(message: string, context?: Record<string, any>): void;
     warn(message: string, context?: Record<string, any>): void;
-    error(message: string, error?: Error | string, context?: Record<string, any>): void;
+    error(message: string, errorOrContext?: Error | string | Record<string, any>, context?: Record<string, any>): void;
     /**
      * Creates a child logger with bound context.
      * Any logs emitted by the child will include the parent's context plus the new context.
@@ -39,16 +39,15 @@ declare const createRedactor: (config: RedactionConfig) => (info: any) => any;
  * Runs a callback within a logger context.
  * The logger provided becomes the "current" logger for the duration of the callback.
  */
-declare const runWithLogger: <T>(logger: Logger, callback: () => T) => T;
+declare const runWithLogger: <T>(logger: Logger, callback: () => T, requestId?: string) => T;
 /**
  * Gets the current logger from the async context.
- * Throws an error if called outside of a runWithLogger context,
- * unless a fallback is provided (though usually we want to enforce context).
- *
- * To make it easier to use, we can return undefined or a default logger if needed,
- * but for this specific feature request "access by all down the stream", strictness is good.
  */
 declare const getLogger: () => Logger | undefined;
+/**
+ * Gets the current request ID from the async context.
+ */
+declare const getRequestId: () => string | undefined;
 /**
  * Updates the current context's logger.
  * This effectively "extends" the logger for the remainder of the current async execution
@@ -86,4 +85,4 @@ declare const withLogger: <TEvent = any, TResult = any>(handler: Handler<TEvent,
 declare const DEFAULT_LOG_LEVEL = "info";
 declare const REQUEST_ID_KEY = "x-request-id";
 
-export { COMMON_REDACTION_KEYS, type CreateLoggerOptions, DEFAULT_LOG_LEVEL, type Logger, REQUEST_ID_KEY, type RedactionConfig, type RedactionStrategy, createLogger, createRedactor, getLogger, recursiveRedact, runWithLogger, updateLoggerContext, withLogger };
+export { COMMON_REDACTION_KEYS, type CreateLoggerOptions, DEFAULT_LOG_LEVEL, type Logger, REQUEST_ID_KEY, type RedactionConfig, type RedactionStrategy, createLogger, createRedactor, getLogger, getRequestId, recursiveRedact, runWithLogger, updateLoggerContext, withLogger };

package/dist/index.d.ts

@@ -2,7 +2,7 @@ interface Logger {
     debug(message: string, context?: Record<string, any>): void;
     info(message: string, context?: Record<string, any>): void;
     warn(message: string, context?: Record<string, any>): void;
-    error(message: string, error?: Error | string, context?: Record<string, any>): void;
+    error(message: string, errorOrContext?: Error | string | Record<string, any>, context?: Record<string, any>): void;
     /**
      * Creates a child logger with bound context.
      * Any logs emitted by the child will include the parent's context plus the new context.
@@ -39,16 +39,15 @@ declare const createRedactor: (config: RedactionConfig) => (info: any) => any;
  * Runs a callback within a logger context.
  * The logger provided becomes the "current" logger for the duration of the callback.
  */
-declare const runWithLogger: <T>(logger: Logger, callback: () => T) => T;
+declare const runWithLogger: <T>(logger: Logger, callback: () => T, requestId?: string) => T;
 /**
  * Gets the current logger from the async context.
- * Throws an error if called outside of a runWithLogger context,
- * unless a fallback is provided (though usually we want to enforce context).
- *
- * To make it easier to use, we can return undefined or a default logger if needed,
- * but for this specific feature request "access by all down the stream", strictness is good.
  */
 declare const getLogger: () => Logger | undefined;
+/**
+ * Gets the current request ID from the async context.
+ */
+declare const getRequestId: () => string | undefined;
 /**
  * Updates the current context's logger.
  * This effectively "extends" the logger for the remainder of the current async execution
@@ -86,4 +85,4 @@ declare const withLogger: <TEvent = any, TResult = any>(handler: Handler<TEvent,
 declare const DEFAULT_LOG_LEVEL = "info";
 declare const REQUEST_ID_KEY = "x-request-id";
 
-export { COMMON_REDACTION_KEYS, type CreateLoggerOptions, DEFAULT_LOG_LEVEL, type Logger, REQUEST_ID_KEY, type RedactionConfig, type RedactionStrategy, createLogger, createRedactor, getLogger, recursiveRedact, runWithLogger, updateLoggerContext, withLogger };
+export { COMMON_REDACTION_KEYS, type CreateLoggerOptions, DEFAULT_LOG_LEVEL, type Logger, REQUEST_ID_KEY, type RedactionConfig, type RedactionStrategy, createLogger, createRedactor, getLogger, getRequestId, recursiveRedact, runWithLogger, updateLoggerContext, withLogger };

package/dist/index.js

@@ -36,6 +36,7 @@ __export(index_exports, {
   createLogger: () => createLogger,
   createRedactor: () => createRedactor,
   getLogger: () => getLogger,
+  getRequestId: () => getRequestId,
   recursiveRedact: () => recursiveRedact,
   runWithLogger: () => runWithLogger,
   updateLoggerContext: () => updateLoggerContext,
@@ -139,13 +140,17 @@ var createRedactor = (config) => {
 // src/context.ts
 var import_async_hooks = require("async_hooks");
 var asyncLocalStorage = new import_async_hooks.AsyncLocalStorage();
-var runWithLogger = (logger, callback) => {
-  return asyncLocalStorage.run({ logger }, callback);
+var runWithLogger = (logger, callback, requestId) => {
+  return asyncLocalStorage.run({ logger, requestId }, callback);
 };
 var getLogger = () => {
   const store = asyncLocalStorage.getStore();
   return store?.logger;
 };
+var getRequestId = () => {
+  const store = asyncLocalStorage.getStore();
+  return store?.requestId;
+};
 var updateLoggerContext = (newLogger) => {
   const store = asyncLocalStorage.getStore();
   if (store) {
@@ -179,18 +184,32 @@ var createLoggerWrapper = (winstonLogger) => {
     warn: (message, context) => {
       winstonLogger.warn(message, formatContext(context));
     },
-    error: (message, error, context) => {
-      const meta = formatContext(context);
-      if (error instanceof Error) {
-        const { message: message2, name, stack, ...rest } = error;
-        meta.error = {
-          ...rest,
-          message: message2,
-          name,
-          stack
-        };
-      } else if (error) {
-        meta.error = error;
+    error: (message, errorOrContext, context) => {
+      let meta = formatContext(context);
+      if (errorOrContext instanceof Error || typeof errorOrContext === "string") {
+        const error = errorOrContext;
+        if (error instanceof Error) {
+          const { message: message2, name, stack, ...rest } = error;
+          meta.error = {
+            ...rest,
+            message: message2,
+            name,
+            stack
+          };
+        } else {
+          meta.error = error;
+        }
+      } else if (typeof errorOrContext === "object" && errorOrContext !== null) {
+        meta = { ...meta, ...errorOrContext };
+        if (meta.error instanceof Error) {
+          const { message: message2, name, stack, ...rest } = meta.error;
+          meta.error = {
+            ...rest,
+            message: message2,
+            name,
+            stack
+          };
+        }
       }
       winstonLogger.error(message, meta);
     },
@@ -235,15 +254,19 @@ var withLogger = (handler, options = {}) => {
     const scopedLogger = rootLogger.child(requestContext);
     scopedLogger.debug("Lambda Event", { event });
     scopedLogger.debug("Lambda Context", { context });
-    return runWithLogger(scopedLogger, async () => {
-      try {
-        const result = await handler(event, context, callback);
-        return result;
-      } catch (error) {
-        scopedLogger.error("Unhandled Lambda Exception", error);
-        throw error;
-      }
-    });
+    return runWithLogger(
+      scopedLogger,
+      async () => {
+        try {
+          const result = await handler(event, context, callback);
+          return result;
+        } catch (error) {
+          scopedLogger.error("Unhandled Lambda Exception", error);
+          throw error;
+        }
+      },
+      requestContext.requestId
+    );
   };
 };
 // Annotate the CommonJS export names for ESM import in node:
@@ -254,6 +277,7 @@ var withLogger = (handler, options = {}) => {
   createLogger,
   createRedactor,
   getLogger,
+  getRequestId,
   recursiveRedact,
   runWithLogger,
   updateLoggerContext,

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/redactor.ts","../src/context.ts","../src/logger.ts","../src/constants.ts","../src/wrapper.ts"],"sourcesContent":["export * from './types';\nexport * from './redactor';\nexport * from './context';\nexport * from './logger';\nexport * from './wrapper';\nexport * from './constants';\n","import crypto from 'crypto';\n\nexport type RedactionStrategy = 'mask' | 'remove' | 'hash' | string | ((value: any) => any);\n\nexport interface RedactionConfig {\n    /**\n     * Array of keys to redact.\n     * Case-insensitive matching is recommended/implemented.\n     */\n    keys: string[];\n    /**\n     * Map of specific key to strategy.\n     * If a key is in 'keys' but not here, it uses the default strategy ('mask').\n     */\n    strategies?: Record<string, RedactionStrategy>;\n    /**\n     * Default strategy for keys found in the list but not in the strategy map.\n     * Default: 'mask'\n     */\n    defaultStrategy?: RedactionStrategy;\n}\n\nexport const COMMON_REDACTION_KEYS = [\n    'password',\n    'passwd',\n    'secret',\n    'token',\n    'access_token',\n    'access-token',\n    'auth',\n    'auth-token',\n    'authorization',\n    'apikey',\n    'api_key',\n    'api-key',\n    'card',\n    'cvv',\n    'ssn',\n    'pin',\n];\n\n/**\n * Applies the redaction strategy to a single value.\n */\nconst applyStrategy = (value: any, strategy: RedactionStrategy): any => {\n    if (typeof strategy === 'function') {\n        return strategy(value);\n    }\n\n    if (typeof strategy === 'string' && strategy.startsWith('mask-last-')) {\n        const parts = strategy.split('-');\n        const lastN = parseInt(parts[2], 10);\n\n        if (typeof value === 'string' && !isNaN(lastN)) {\n            if (value.length <= lastN) {\n                return value; // Or mask entirely? Usually if shorter, we show it or mask all. Let's return as is or mask all?\n                // Security wise: showing short secrets fully is bad. Masking all is safer.\n                // BUT, if user asked for last 4 and length is 3, showing 3 is effectively \"last 4\".\n                // Let's mask all if length <= lastN to be safe? Or just return.\n                // Actually, standard is usually: if len <= N, show all (it IS the last N).\n                // But for API keys, usually we want to see SOMETHING masked.\n                // Let's preserve standard behavior: visible suffix.\n                return value;\n            }\n            const maskLen = value.length - lastN;\n            return '*'.repeat(maskLen) + value.slice(-lastN);\n        }\n        return '*****'; // Fallback for non-strings\n    }\n\n    switch (strategy) {\n        case 'remove':\n            return undefined;\n        case 'hash':\n            if (typeof value === 'string' || typeof value === 'number') {\n                return crypto.createHash('sha256').update(String(value)).digest('hex');\n            }\n            return '[HASH_FAILED_TYPE]';\n        case 'mask':\n        default:\n            return '*****';\n    }\n};\n\n/**\n * Recursively walks the object and redacts fields matching the config.\n */\nexport const recursiveRedact = (\n    target: any,\n    config: RedactionConfig,\n    cache = new Set<any>(),\n): any => {\n    if (target === null || typeof target !== 'object') {\n        return target;\n    }\n\n    // Handle circular references\n    if (cache.has(target)) {\n        return '[Circular]';\n    }\n    cache.add(target);\n\n    // Handle Arrays\n    if (Array.isArray(target)) {\n        return target.map((item) => recursiveRedact(item, config, cache));\n    }\n\n    // Handle Objects\n    const redactedObj: Record<string, any> = {};\n    const keysToRedact = new Set(config.keys.map((k) => k.toLowerCase()));\n\n    for (const [key, value] of Object.entries(target)) {\n        const lowerKey = key.toLowerCase();\n\n        if (keysToRedact.has(lowerKey)) {\n            // Determine strategy\n            let strategy = config.defaultStrategy || 'mask';\n            if (config.strategies && config.strategies[key]) {\n                // Try exact match first\n                strategy = config.strategies[key];\n            } else if (config.strategies) {\n                // Try case-insensitive lookup in strategies if needed,\n                // but for simplicity let's rely on specific keys matching or default.\n                // Actually, user might put 'Password': 'hash' and we matched 'password'.\n                // Let's iterate strategies keys to find case-insensitive match if strictly needed.\n                // For performance/simplicity, strict case matching in strategies map is safer,\n                // but generic 'keys' list is case-insensitive.\n\n                // Let's look for a key in strategies that matches lowerKey\n                const strategyKey = Object.keys(config.strategies).find(\n                    (k) => k.toLowerCase() === lowerKey,\n                );\n                if (strategyKey) {\n                    strategy = config.strategies[strategyKey];\n                }\n            }\n\n            const result = applyStrategy(value, strategy);\n            if (result !== undefined) {\n                redactedObj[key] = result;\n            }\n            // If undefined (remove strategy), we just don't add the key.\n        } else {\n            // Recurse\n            redactedObj[key] = recursiveRedact(value, config, cache);\n        }\n    }\n\n    return redactedObj;\n};\n\nexport const createRedactor = (config: RedactionConfig) => {\n    return (info: any) => {\n        return recursiveRedact(info, config);\n    };\n};\n","import { AsyncLocalStorage } from 'async_hooks';\nimport { Logger } from './types';\n\n// We store a reference to the logger so we can update it in-place for the current context\ninterface LoggerStore {\n    logger: Logger;\n}\n\nconst asyncLocalStorage = new AsyncLocalStorage<LoggerStore>();\n\n/**\n * Runs a callback within a logger context.\n * The logger provided becomes the \"current\" logger for the duration of the callback.\n */\nexport const runWithLogger = <T>(logger: Logger, callback: () => T): T => {\n    return asyncLocalStorage.run({ logger }, callback);\n};\n\n/**\n * Gets the current logger from the async context.\n * Throws an error if called outside of a runWithLogger context,\n * unless a fallback is provided (though usually we want to enforce context).\n *\n * To make it easier to use, we can return undefined or a default logger if needed,\n * but for this specific feature request \"access by all down the stream\", strictness is good.\n */\nexport const getLogger = (): Logger | undefined => {\n    const store = asyncLocalStorage.getStore();\n    return store?.logger;\n};\n\n/**\n * Updates the current context's logger.\n * This effectively \"extends\" the logger for the remainder of the current async execution\n * and any further downstream calls sharing this context.\n */\nexport const updateLoggerContext = (newLogger: Logger): void => {\n    const store = asyncLocalStorage.getStore();\n    if (store) {\n        store.logger = newLogger;\n    } else {\n        // If we are not in a context, we can't update it.\n        // We could throw, or warn. For now, let's warn.\n        console.warn(\n            'AntigravityLogger: updateLoggerContext called outside of an active context. Logic ignored.',\n        );\n    }\n};\n","import winston from 'winston';\nimport { Logger } from './types';\nimport { DEFAULT_LOG_LEVEL } from './constants';\nimport { RedactionConfig, createRedactor } from './redactor';\n\nexport interface CreateLoggerOptions {\n    /**\n     * Default context to include in all logs\n     */\n    defaultContext?: Record<string, any>;\n    /**\n     * Log level (default: process.env.LOG_LEVEL || 'info')\n     */\n    level?: string;\n    /**\n     * Configuration for data redaction\n     */\n    redaction?: RedactionConfig;\n}\n\nconst formatContext = (context?: Record<string, any>): Record<string, any> => {\n    return context || {};\n};\n\nconst createLoggerWrapper = (winstonLogger: winston.Logger): Logger => {\n    return {\n        debug: (message: string, context?: Record<string, any>): void => {\n            winstonLogger.debug(message, formatContext(context));\n        },\n\n        info: (message: string, context?: Record<string, any>): void => {\n            winstonLogger.info(message, formatContext(context));\n        },\n\n        warn: (message: string, context?: Record<string, any>): void => {\n            winstonLogger.warn(message, formatContext(context));\n        },\n\n        error: (message: string, error?: Error | string, context?: Record<string, any>): void => {\n            const meta = formatContext(context);\n            if (error instanceof Error) {\n                // Winston handles error objects well if passed as meta or splat\n                // But for explicit structure, let's attach it\n                // Spread error first to capture custom props, then overwrite standard ones to ensure presence\n                const { message, name, stack, ...rest } = error;\n                meta.error = {\n                    ...rest,\n                    message,\n                    name,\n                    stack,\n                };\n            } else if (error) {\n                meta.error = error;\n            }\n            winstonLogger.error(message, meta);\n        },\n\n        child: (context: Record<string, any>): Logger => {\n            // Winston's child() returns a new logger instance with the metadata bound\n            return createLoggerWrapper(winstonLogger.child(context));\n        },\n    };\n};\n\nexport const createLogger = (options: CreateLoggerOptions = {}): Logger => {\n    const level = options.level || process.env.LOG_LEVEL || DEFAULT_LOG_LEVEL;\n\n    // Create redactor if config is present\n    const redactor = options.redaction ? createRedactor(options.redaction) : null;\n\n    // Custom format that applies redaction\n    const redactionFormat = winston.format((info) => {\n        if (redactor) {\n            return redactor(info);\n        }\n        return info;\n    });\n\n    const format = winston.format.combine(\n        winston.format.timestamp(),\n        redactionFormat(), // Apply redaction before JSON\n        winston.format.json(),\n    );\n\n    const winstonLogger = winston.createLogger({\n        level,\n        format,\n        defaultMeta: options.defaultContext,\n        transports: [new winston.transports.Console()],\n    });\n\n    return createLoggerWrapper(winstonLogger);\n};\n","export const DEFAULT_LOG_LEVEL = 'info';\nexport const REQUEST_ID_KEY = 'x-request-id';\n","import { CreateLoggerOptions, createLogger } from './logger';\nimport { runWithLogger } from './context';\n\n// Generic Handler type compatible with AWS Lambda\n// We use 'any' to avoid strict dependency on @types/aws-lambda for this generic wrapper\n// but in practice it wraps (event, context, callback?) => Promise<any> | any\ntype Handler<TEvent = any, TResult = any> = (\n    event: TEvent,\n    context: any,\n    callback?: any,\n) => Promise<TResult> | void;\n\n/**\n * Higher-order function to wrap a Lambda handler with logger context.\n * Automatically extracts 'awsRequestId' and 'functionName' from the Lambda context\n * and initializes a logger for the request scope.\n *\n * @param handler The original Lambda handler\n * @param options Logger options (level, redaction, etc.)\n */\nexport const withLogger = <TEvent = any, TResult = any>(\n    handler: Handler<TEvent, TResult>,\n    options: CreateLoggerOptions = {},\n): Handler<TEvent, TResult> => {\n    return async (event: TEvent, context: any, callback?: any) => {\n        // 1. Initialize Logger\n        // Create a root logger if custom options are provided, or use default behavior.\n        // We create a FRESH logger instance for each request to ensure context isolation if needed?\n        // Actually, creating a logger instance is cheap?\n        // Winston createLogger is relatively heavy.\n        // Optimization: We could reuse a global logger and just child() it.\n        // But options might change? Usually options are static.\n        // Let's assume options are static per lambda wrapper usage.\n\n        // HOWEVER, to support dynamic options per request might be overkill.\n        // Let's create one global logger instance for this wrapper instantiation if possible?\n        // But wait, the standard `createLogger` we implemented creates a NEW winston instance every time.\n        // We should probably cache it?\n        // For now, let's keep it simple: createLogger per request.\n        // If performance becomes an issue, we can refactor `createLogger` to reuse the winston instance if options match.\n\n        const rootLogger = createLogger(options);\n\n        // 2. Extract Context\n        const requestContext: Record<string, any> = {};\n        if (context) {\n            if (context.awsRequestId) requestContext.requestId = context.awsRequestId;\n            if (context.functionName) requestContext.functionName = context.functionName;\n        }\n\n        // 3. Create Child Logger with Request Context\n        const scopedLogger = rootLogger.child(requestContext);\n\n        // 3a. Log Event and Context\n        scopedLogger.debug('Lambda Event', { event });\n        scopedLogger.debug('Lambda Context', { context });\n\n        // 4. Run Handler in Context\n        return runWithLogger(scopedLogger, async () => {\n            // We use 'await' to ensure the context stays active during the handler execution\n            // If the handler accepts a callback, we might need special handling?\n            // Most modern lambdas use async/await.\n            // If legacy callback style is used, AsyncLocalStorage context *should* still propagate\n            // if the callback is invoked asynchronously.\n            // But we wrap the result in Promise usually.\n\n            // Supporting both async and callback style:\n            try {\n                // If it returns a promise, await it\n                const result = await handler(event, context, callback);\n                return result as TResult;\n            } catch (error) {\n                // We could log unhandled errors here too?\n                // Standard lambda practice is to let the error propagate so Lambda runtime sees it (and retries etc)\n                // BUT we should log it first because once it leaves here, we might lose the logger context behavior.\n                scopedLogger.error('Unhandled Lambda Exception', error as Error);\n                throw error;\n            }\n        });\n    };\n};\n"],"mappings":"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","names":["crypto","message","winston"]}
+{"version":3,"sources":["../src/index.ts","../src/redactor.ts","../src/context.ts","../src/logger.ts","../src/constants.ts","../src/wrapper.ts"],"sourcesContent":["export * from './types';\nexport * from './redactor';\nexport * from './context';\nexport * from './logger';\nexport * from './wrapper';\nexport * from './constants';\n","import crypto from 'crypto';\n\nexport type RedactionStrategy = 'mask' | 'remove' | 'hash' | string | ((value: any) => any);\n\nexport interface RedactionConfig {\n    /**\n     * Array of keys to redact.\n     * Case-insensitive matching is recommended/implemented.\n     */\n    keys: string[];\n    /**\n     * Map of specific key to strategy.\n     * If a key is in 'keys' but not here, it uses the default strategy ('mask').\n     */\n    strategies?: Record<string, RedactionStrategy>;\n    /**\n     * Default strategy for keys found in the list but not in the strategy map.\n     * Default: 'mask'\n     */\n    defaultStrategy?: RedactionStrategy;\n}\n\nexport const COMMON_REDACTION_KEYS = [\n    'password',\n    'passwd',\n    'secret',\n    'token',\n    'access_token',\n    'access-token',\n    'auth',\n    'auth-token',\n    'authorization',\n    'apikey',\n    'api_key',\n    'api-key',\n    'card',\n    'cvv',\n    'ssn',\n    'pin',\n];\n\n/**\n * Applies the redaction strategy to a single value.\n */\nconst applyStrategy = (value: any, strategy: RedactionStrategy): any => {\n    if (typeof strategy === 'function') {\n        return strategy(value);\n    }\n\n    if (typeof strategy === 'string' && strategy.startsWith('mask-last-')) {\n        const parts = strategy.split('-');\n        const lastN = parseInt(parts[2], 10);\n\n        if (typeof value === 'string' && !isNaN(lastN)) {\n            if (value.length <= lastN) {\n                return value; // Or mask entirely? Usually if shorter, we show it or mask all. Let's return as is or mask all?\n                // Security wise: showing short secrets fully is bad. Masking all is safer.\n                // BUT, if user asked for last 4 and length is 3, showing 3 is effectively \"last 4\".\n                // Let's mask all if length <= lastN to be safe? Or just return.\n                // Actually, standard is usually: if len <= N, show all (it IS the last N).\n                // But for API keys, usually we want to see SOMETHING masked.\n                // Let's preserve standard behavior: visible suffix.\n                return value;\n            }\n            const maskLen = value.length - lastN;\n            return '*'.repeat(maskLen) + value.slice(-lastN);\n        }\n        return '*****'; // Fallback for non-strings\n    }\n\n    switch (strategy) {\n        case 'remove':\n            return undefined;\n        case 'hash':\n            if (typeof value === 'string' || typeof value === 'number') {\n                return crypto.createHash('sha256').update(String(value)).digest('hex');\n            }\n            return '[HASH_FAILED_TYPE]';\n        case 'mask':\n        default:\n            return '*****';\n    }\n};\n\n/**\n * Recursively walks the object and redacts fields matching the config.\n */\nexport const recursiveRedact = (\n    target: any,\n    config: RedactionConfig,\n    cache = new Set<any>(),\n): any => {\n    if (target === null || typeof target !== 'object') {\n        return target;\n    }\n\n    // Handle circular references\n    if (cache.has(target)) {\n        return '[Circular]';\n    }\n    cache.add(target);\n\n    // Handle Arrays\n    if (Array.isArray(target)) {\n        return target.map((item) => recursiveRedact(item, config, cache));\n    }\n\n    // Handle Objects\n    const redactedObj: Record<string, any> = {};\n    const keysToRedact = new Set(config.keys.map((k) => k.toLowerCase()));\n\n    for (const [key, value] of Object.entries(target)) {\n        const lowerKey = key.toLowerCase();\n\n        if (keysToRedact.has(lowerKey)) {\n            // Determine strategy\n            let strategy = config.defaultStrategy || 'mask';\n            if (config.strategies && config.strategies[key]) {\n                // Try exact match first\n                strategy = config.strategies[key];\n            } else if (config.strategies) {\n                // Try case-insensitive lookup in strategies if needed,\n                // but for simplicity let's rely on specific keys matching or default.\n                // Actually, user might put 'Password': 'hash' and we matched 'password'.\n                // Let's iterate strategies keys to find case-insensitive match if strictly needed.\n                // For performance/simplicity, strict case matching in strategies map is safer,\n                // but generic 'keys' list is case-insensitive.\n\n                // Let's look for a key in strategies that matches lowerKey\n                const strategyKey = Object.keys(config.strategies).find(\n                    (k) => k.toLowerCase() === lowerKey,\n                );\n                if (strategyKey) {\n                    strategy = config.strategies[strategyKey];\n                }\n            }\n\n            const result = applyStrategy(value, strategy);\n            if (result !== undefined) {\n                redactedObj[key] = result;\n            }\n            // If undefined (remove strategy), we just don't add the key.\n        } else {\n            // Recurse\n            redactedObj[key] = recursiveRedact(value, config, cache);\n        }\n    }\n\n    return redactedObj;\n};\n\nexport const createRedactor = (config: RedactionConfig) => {\n    return (info: any) => {\n        return recursiveRedact(info, config);\n    };\n};\n","import { AsyncLocalStorage } from 'async_hooks';\nimport { Logger } from './types';\n\n// We store a reference to the logger so we can update it in-place for the current context\ninterface LoggerStore {\n    logger: Logger;\n    requestId?: string;\n}\n\nconst asyncLocalStorage = new AsyncLocalStorage<LoggerStore>();\n\n/**\n * Runs a callback within a logger context.\n * The logger provided becomes the \"current\" logger for the duration of the callback.\n */\nexport const runWithLogger = <T>(logger: Logger, callback: () => T, requestId?: string): T => {\n    return asyncLocalStorage.run({ logger, requestId }, callback);\n};\n\n/**\n * Gets the current logger from the async context.\n */\nexport const getLogger = (): Logger | undefined => {\n    const store = asyncLocalStorage.getStore();\n    return store?.logger;\n};\n\n/**\n * Gets the current request ID from the async context.\n */\nexport const getRequestId = (): string | undefined => {\n    const store = asyncLocalStorage.getStore();\n    return store?.requestId;\n};\n\n/**\n * Updates the current context's logger.\n * This effectively \"extends\" the logger for the remainder of the current async execution\n * and any further downstream calls sharing this context.\n */\nexport const updateLoggerContext = (newLogger: Logger): void => {\n    const store = asyncLocalStorage.getStore();\n    if (store) {\n        store.logger = newLogger;\n    } else {\n        // If we are not in a context, we can't update it.\n        // We could throw, or warn. For now, let's warn.\n        console.warn(\n            'AntigravityLogger: updateLoggerContext called outside of an active context. Logic ignored.',\n        );\n    }\n};\n","import winston from 'winston';\nimport { Logger } from './types';\nimport { DEFAULT_LOG_LEVEL } from './constants';\nimport { RedactionConfig, createRedactor } from './redactor';\n\nexport interface CreateLoggerOptions {\n    /**\n     * Default context to include in all logs\n     */\n    defaultContext?: Record<string, any>;\n    /**\n     * Log level (default: process.env.LOG_LEVEL || 'info')\n     */\n    level?: string;\n    /**\n     * Configuration for data redaction\n     */\n    redaction?: RedactionConfig;\n}\n\nconst formatContext = (context?: Record<string, any>): Record<string, any> => {\n    return context || {};\n};\n\nconst createLoggerWrapper = (winstonLogger: winston.Logger): Logger => {\n    return {\n        debug: (message: string, context?: Record<string, any>): void => {\n            winstonLogger.debug(message, formatContext(context));\n        },\n\n        info: (message: string, context?: Record<string, any>): void => {\n            winstonLogger.info(message, formatContext(context));\n        },\n\n        warn: (message: string, context?: Record<string, any>): void => {\n            winstonLogger.warn(message, formatContext(context));\n        },\n\n        error: (\n            message: string,\n            errorOrContext?: Error | string | Record<string, any>,\n            context?: Record<string, any>,\n        ): void => {\n            let meta = formatContext(context);\n\n            if (errorOrContext instanceof Error || typeof errorOrContext === 'string') {\n                // Old behavior: second arg is the error\n                const error = errorOrContext;\n                if (error instanceof Error) {\n                    const { message, name, stack, ...rest } = error;\n                    meta.error = {\n                        ...rest,\n                        message,\n                        name,\n                        stack,\n                    };\n                } else {\n                    meta.error = error;\n                }\n            } else if (typeof errorOrContext === 'object' && errorOrContext !== null) {\n                // New behavior: second arg is context (which might contain error)\n                meta = { ...meta, ...errorOrContext };\n\n                // If error is in the context, format it nicely\n                if (meta.error instanceof Error) {\n                    const { message, name, stack, ...rest } = meta.error;\n                    meta.error = {\n                        ...rest,\n                        message,\n                        name,\n                        stack,\n                    };\n                }\n            }\n\n            winstonLogger.error(message, meta);\n        },\n\n        child: (context: Record<string, any>): Logger => {\n            // Winston's child() returns a new logger instance with the metadata bound\n            return createLoggerWrapper(winstonLogger.child(context));\n        },\n    };\n};\n\nexport const createLogger = (options: CreateLoggerOptions = {}): Logger => {\n    const level = options.level || process.env.LOG_LEVEL || DEFAULT_LOG_LEVEL;\n\n    // Create redactor if config is present\n    const redactor = options.redaction ? createRedactor(options.redaction) : null;\n\n    // Custom format that applies redaction\n    const redactionFormat = winston.format((info) => {\n        if (redactor) {\n            return redactor(info);\n        }\n        return info;\n    });\n\n    const format = winston.format.combine(\n        winston.format.timestamp(),\n        redactionFormat(), // Apply redaction before JSON\n        winston.format.json(),\n    );\n\n    const winstonLogger = winston.createLogger({\n        level,\n        format,\n        defaultMeta: options.defaultContext,\n        transports: [new winston.transports.Console()],\n    });\n\n    return createLoggerWrapper(winstonLogger);\n};\n","export const DEFAULT_LOG_LEVEL = 'info';\nexport const REQUEST_ID_KEY = 'x-request-id';\n","import { CreateLoggerOptions, createLogger } from './logger';\nimport { runWithLogger } from './context';\n\n// Generic Handler type compatible with AWS Lambda\n// We use 'any' to avoid strict dependency on @types/aws-lambda for this generic wrapper\n// but in practice it wraps (event, context, callback?) => Promise<any> | any\ntype Handler<TEvent = any, TResult = any> = (\n    event: TEvent,\n    context: any,\n    callback?: any,\n) => Promise<TResult> | void;\n\n/**\n * Higher-order function to wrap a Lambda handler with logger context.\n * Automatically extracts 'awsRequestId' and 'functionName' from the Lambda context\n * and initializes a logger for the request scope.\n *\n * @param handler The original Lambda handler\n * @param options Logger options (level, redaction, etc.)\n */\nexport const withLogger = <TEvent = any, TResult = any>(\n    handler: Handler<TEvent, TResult>,\n    options: CreateLoggerOptions = {},\n): Handler<TEvent, TResult> => {\n    return async (event: TEvent, context: any, callback?: any) => {\n        // 1. Initialize Logger\n        // Create a root logger if custom options are provided, or use default behavior.\n        // We create a FRESH logger instance for each request to ensure context isolation if needed?\n        // Actually, creating a logger instance is cheap?\n        // Winston createLogger is relatively heavy.\n        // Optimization: We could reuse a global logger and just child() it.\n        // But options might change? Usually options are static.\n        // Let's assume options are static per lambda wrapper usage.\n\n        // HOWEVER, to support dynamic options per request might be overkill.\n        // Let's create one global logger instance for this wrapper instantiation if possible?\n        // But wait, the standard `createLogger` we implemented creates a NEW winston instance every time.\n        // We should probably cache it?\n        // For now, let's keep it simple: createLogger per request.\n        // If performance becomes an issue, we can refactor `createLogger` to reuse the winston instance if options match.\n\n        const rootLogger = createLogger(options);\n\n        // 2. Extract Context\n        const requestContext: Record<string, any> = {};\n        if (context) {\n            if (context.awsRequestId) requestContext.requestId = context.awsRequestId;\n            if (context.functionName) requestContext.functionName = context.functionName;\n        }\n\n        // 3. Create Child Logger with Request Context\n        const scopedLogger = rootLogger.child(requestContext);\n\n        // 3a. Log Event and Context\n        scopedLogger.debug('Lambda Event', { event });\n        scopedLogger.debug('Lambda Context', { context });\n\n        // 4. Run Handler in Context\n        return runWithLogger(\n            scopedLogger,\n            async () => {\n                // We use 'await' to ensure the context stays active during the handler execution\n                // If the handler accepts a callback, we might need special handling?\n                // Most modern lambdas use async/await.\n                // If legacy callback style is used, AsyncLocalStorage context *should* still propagate\n                // if the callback is invoked asynchronously.\n                // But we wrap the result in Promise usually.\n\n                // Supporting both async and callback style:\n                try {\n                    // If it returns a promise, await it\n                    const result = await handler(event, context, callback);\n                    return result as TResult;\n                } catch (error) {\n                    // We could log unhandled errors here too?\n                    // Standard lambda practice is to let the error propagate so Lambda runtime sees it (and retries etc)\n                    // BUT we should log it first because once it leaves here, we might lose the logger context behavior.\n                    scopedLogger.error('Unhandled Lambda Exception', error as Error);\n                    throw error;\n                }\n            },\n            requestContext.requestId,\n        );\n    };\n};\n"],"mappings":"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","names":["crypto","message","winston"]}

package/dist/index.mjs

@@ -94,13 +94,17 @@ var createRedactor = (config) => {
 // src/context.ts
 import { AsyncLocalStorage } from "async_hooks";
 var asyncLocalStorage = new AsyncLocalStorage();
-var runWithLogger = (logger, callback) => {
-  return asyncLocalStorage.run({ logger }, callback);
+var runWithLogger = (logger, callback, requestId) => {
+  return asyncLocalStorage.run({ logger, requestId }, callback);
 };
 var getLogger = () => {
   const store = asyncLocalStorage.getStore();
   return store?.logger;
 };
+var getRequestId = () => {
+  const store = asyncLocalStorage.getStore();
+  return store?.requestId;
+};
 var updateLoggerContext = (newLogger) => {
   const store = asyncLocalStorage.getStore();
   if (store) {
@@ -134,18 +138,32 @@ var createLoggerWrapper = (winstonLogger) => {
     warn: (message, context) => {
       winstonLogger.warn(message, formatContext(context));
     },
-    error: (message, error, context) => {
-      const meta = formatContext(context);
-      if (error instanceof Error) {
-        const { message: message2, name, stack, ...rest } = error;
-        meta.error = {
-          ...rest,
-          message: message2,
-          name,
-          stack
-        };
-      } else if (error) {
-        meta.error = error;
+    error: (message, errorOrContext, context) => {
+      let meta = formatContext(context);
+      if (errorOrContext instanceof Error || typeof errorOrContext === "string") {
+        const error = errorOrContext;
+        if (error instanceof Error) {
+          const { message: message2, name, stack, ...rest } = error;
+          meta.error = {
+            ...rest,
+            message: message2,
+            name,
+            stack
+          };
+        } else {
+          meta.error = error;
+        }
+      } else if (typeof errorOrContext === "object" && errorOrContext !== null) {
+        meta = { ...meta, ...errorOrContext };
+        if (meta.error instanceof Error) {
+          const { message: message2, name, stack, ...rest } = meta.error;
+          meta.error = {
+            ...rest,
+            message: message2,
+            name,
+            stack
+          };
+        }
       }
       winstonLogger.error(message, meta);
     },
@@ -190,15 +208,19 @@ var withLogger = (handler, options = {}) => {
     const scopedLogger = rootLogger.child(requestContext);
     scopedLogger.debug("Lambda Event", { event });
     scopedLogger.debug("Lambda Context", { context });
-    return runWithLogger(scopedLogger, async () => {
-      try {
-        const result = await handler(event, context, callback);
-        return result;
-      } catch (error) {
-        scopedLogger.error("Unhandled Lambda Exception", error);
-        throw error;
-      }
-    });
+    return runWithLogger(
+      scopedLogger,
+      async () => {
+        try {
+          const result = await handler(event, context, callback);
+          return result;
+        } catch (error) {
+          scopedLogger.error("Unhandled Lambda Exception", error);
+          throw error;
+        }
+      },
+      requestContext.requestId
+    );
   };
 };
 export {
@@ -208,6 +230,7 @@ export {
   createLogger,
   createRedactor,
   getLogger,
+  getRequestId,
   recursiveRedact,
   runWithLogger,
   updateLoggerContext,

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/redactor.ts","../src/context.ts","../src/logger.ts","../src/constants.ts","../src/wrapper.ts"],"sourcesContent":["import crypto from 'crypto';\n\nexport type RedactionStrategy = 'mask' | 'remove' | 'hash' | string | ((value: any) => any);\n\nexport interface RedactionConfig {\n    /**\n     * Array of keys to redact.\n     * Case-insensitive matching is recommended/implemented.\n     */\n    keys: string[];\n    /**\n     * Map of specific key to strategy.\n     * If a key is in 'keys' but not here, it uses the default strategy ('mask').\n     */\n    strategies?: Record<string, RedactionStrategy>;\n    /**\n     * Default strategy for keys found in the list but not in the strategy map.\n     * Default: 'mask'\n     */\n    defaultStrategy?: RedactionStrategy;\n}\n\nexport const COMMON_REDACTION_KEYS = [\n    'password',\n    'passwd',\n    'secret',\n    'token',\n    'access_token',\n    'access-token',\n    'auth',\n    'auth-token',\n    'authorization',\n    'apikey',\n    'api_key',\n    'api-key',\n    'card',\n    'cvv',\n    'ssn',\n    'pin',\n];\n\n/**\n * Applies the redaction strategy to a single value.\n */\nconst applyStrategy = (value: any, strategy: RedactionStrategy): any => {\n    if (typeof strategy === 'function') {\n        return strategy(value);\n    }\n\n    if (typeof strategy === 'string' && strategy.startsWith('mask-last-')) {\n        const parts = strategy.split('-');\n        const lastN = parseInt(parts[2], 10);\n\n        if (typeof value === 'string' && !isNaN(lastN)) {\n            if (value.length <= lastN) {\n                return value; // Or mask entirely? Usually if shorter, we show it or mask all. Let's return as is or mask all?\n                // Security wise: showing short secrets fully is bad. Masking all is safer.\n                // BUT, if user asked for last 4 and length is 3, showing 3 is effectively \"last 4\".\n                // Let's mask all if length <= lastN to be safe? Or just return.\n                // Actually, standard is usually: if len <= N, show all (it IS the last N).\n                // But for API keys, usually we want to see SOMETHING masked.\n                // Let's preserve standard behavior: visible suffix.\n                return value;\n            }\n            const maskLen = value.length - lastN;\n            return '*'.repeat(maskLen) + value.slice(-lastN);\n        }\n        return '*****'; // Fallback for non-strings\n    }\n\n    switch (strategy) {\n        case 'remove':\n            return undefined;\n        case 'hash':\n            if (typeof value === 'string' || typeof value === 'number') {\n                return crypto.createHash('sha256').update(String(value)).digest('hex');\n            }\n            return '[HASH_FAILED_TYPE]';\n        case 'mask':\n        default:\n            return '*****';\n    }\n};\n\n/**\n * Recursively walks the object and redacts fields matching the config.\n */\nexport const recursiveRedact = (\n    target: any,\n    config: RedactionConfig,\n    cache = new Set<any>(),\n): any => {\n    if (target === null || typeof target !== 'object') {\n        return target;\n    }\n\n    // Handle circular references\n    if (cache.has(target)) {\n        return '[Circular]';\n    }\n    cache.add(target);\n\n    // Handle Arrays\n    if (Array.isArray(target)) {\n        return target.map((item) => recursiveRedact(item, config, cache));\n    }\n\n    // Handle Objects\n    const redactedObj: Record<string, any> = {};\n    const keysToRedact = new Set(config.keys.map((k) => k.toLowerCase()));\n\n    for (const [key, value] of Object.entries(target)) {\n        const lowerKey = key.toLowerCase();\n\n        if (keysToRedact.has(lowerKey)) {\n            // Determine strategy\n            let strategy = config.defaultStrategy || 'mask';\n            if (config.strategies && config.strategies[key]) {\n                // Try exact match first\n                strategy = config.strategies[key];\n            } else if (config.strategies) {\n                // Try case-insensitive lookup in strategies if needed,\n                // but for simplicity let's rely on specific keys matching or default.\n                // Actually, user might put 'Password': 'hash' and we matched 'password'.\n                // Let's iterate strategies keys to find case-insensitive match if strictly needed.\n                // For performance/simplicity, strict case matching in strategies map is safer,\n                // but generic 'keys' list is case-insensitive.\n\n                // Let's look for a key in strategies that matches lowerKey\n                const strategyKey = Object.keys(config.strategies).find(\n                    (k) => k.toLowerCase() === lowerKey,\n                );\n                if (strategyKey) {\n                    strategy = config.strategies[strategyKey];\n                }\n            }\n\n            const result = applyStrategy(value, strategy);\n            if (result !== undefined) {\n                redactedObj[key] = result;\n            }\n            // If undefined (remove strategy), we just don't add the key.\n        } else {\n            // Recurse\n            redactedObj[key] = recursiveRedact(value, config, cache);\n        }\n    }\n\n    return redactedObj;\n};\n\nexport const createRedactor = (config: RedactionConfig) => {\n    return (info: any) => {\n        return recursiveRedact(info, config);\n    };\n};\n","import { AsyncLocalStorage } from 'async_hooks';\nimport { Logger } from './types';\n\n// We store a reference to the logger so we can update it in-place for the current context\ninterface LoggerStore {\n    logger: Logger;\n}\n\nconst asyncLocalStorage = new AsyncLocalStorage<LoggerStore>();\n\n/**\n * Runs a callback within a logger context.\n * The logger provided becomes the \"current\" logger for the duration of the callback.\n */\nexport const runWithLogger = <T>(logger: Logger, callback: () => T): T => {\n    return asyncLocalStorage.run({ logger }, callback);\n};\n\n/**\n * Gets the current logger from the async context.\n * Throws an error if called outside of a runWithLogger context,\n * unless a fallback is provided (though usually we want to enforce context).\n *\n * To make it easier to use, we can return undefined or a default logger if needed,\n * but for this specific feature request \"access by all down the stream\", strictness is good.\n */\nexport const getLogger = (): Logger | undefined => {\n    const store = asyncLocalStorage.getStore();\n    return store?.logger;\n};\n\n/**\n * Updates the current context's logger.\n * This effectively \"extends\" the logger for the remainder of the current async execution\n * and any further downstream calls sharing this context.\n */\nexport const updateLoggerContext = (newLogger: Logger): void => {\n    const store = asyncLocalStorage.getStore();\n    if (store) {\n        store.logger = newLogger;\n    } else {\n        // If we are not in a context, we can't update it.\n        // We could throw, or warn. For now, let's warn.\n        console.warn(\n            'AntigravityLogger: updateLoggerContext called outside of an active context. Logic ignored.',\n        );\n    }\n};\n","import winston from 'winston';\nimport { Logger } from './types';\nimport { DEFAULT_LOG_LEVEL } from './constants';\nimport { RedactionConfig, createRedactor } from './redactor';\n\nexport interface CreateLoggerOptions {\n    /**\n     * Default context to include in all logs\n     */\n    defaultContext?: Record<string, any>;\n    /**\n     * Log level (default: process.env.LOG_LEVEL || 'info')\n     */\n    level?: string;\n    /**\n     * Configuration for data redaction\n     */\n    redaction?: RedactionConfig;\n}\n\nconst formatContext = (context?: Record<string, any>): Record<string, any> => {\n    return context || {};\n};\n\nconst createLoggerWrapper = (winstonLogger: winston.Logger): Logger => {\n    return {\n        debug: (message: string, context?: Record<string, any>): void => {\n            winstonLogger.debug(message, formatContext(context));\n        },\n\n        info: (message: string, context?: Record<string, any>): void => {\n            winstonLogger.info(message, formatContext(context));\n        },\n\n        warn: (message: string, context?: Record<string, any>): void => {\n            winstonLogger.warn(message, formatContext(context));\n        },\n\n        error: (message: string, error?: Error | string, context?: Record<string, any>): void => {\n            const meta = formatContext(context);\n            if (error instanceof Error) {\n                // Winston handles error objects well if passed as meta or splat\n                // But for explicit structure, let's attach it\n                // Spread error first to capture custom props, then overwrite standard ones to ensure presence\n                const { message, name, stack, ...rest } = error;\n                meta.error = {\n                    ...rest,\n                    message,\n                    name,\n                    stack,\n                };\n            } else if (error) {\n                meta.error = error;\n            }\n            winstonLogger.error(message, meta);\n        },\n\n        child: (context: Record<string, any>): Logger => {\n            // Winston's child() returns a new logger instance with the metadata bound\n            return createLoggerWrapper(winstonLogger.child(context));\n        },\n    };\n};\n\nexport const createLogger = (options: CreateLoggerOptions = {}): Logger => {\n    const level = options.level || process.env.LOG_LEVEL || DEFAULT_LOG_LEVEL;\n\n    // Create redactor if config is present\n    const redactor = options.redaction ? createRedactor(options.redaction) : null;\n\n    // Custom format that applies redaction\n    const redactionFormat = winston.format((info) => {\n        if (redactor) {\n            return redactor(info);\n        }\n        return info;\n    });\n\n    const format = winston.format.combine(\n        winston.format.timestamp(),\n        redactionFormat(), // Apply redaction before JSON\n        winston.format.json(),\n    );\n\n    const winstonLogger = winston.createLogger({\n        level,\n        format,\n        defaultMeta: options.defaultContext,\n        transports: [new winston.transports.Console()],\n    });\n\n    return createLoggerWrapper(winstonLogger);\n};\n","export const DEFAULT_LOG_LEVEL = 'info';\nexport const REQUEST_ID_KEY = 'x-request-id';\n","import { CreateLoggerOptions, createLogger } from './logger';\nimport { runWithLogger } from './context';\n\n// Generic Handler type compatible with AWS Lambda\n// We use 'any' to avoid strict dependency on @types/aws-lambda for this generic wrapper\n// but in practice it wraps (event, context, callback?) => Promise<any> | any\ntype Handler<TEvent = any, TResult = any> = (\n    event: TEvent,\n    context: any,\n    callback?: any,\n) => Promise<TResult> | void;\n\n/**\n * Higher-order function to wrap a Lambda handler with logger context.\n * Automatically extracts 'awsRequestId' and 'functionName' from the Lambda context\n * and initializes a logger for the request scope.\n *\n * @param handler The original Lambda handler\n * @param options Logger options (level, redaction, etc.)\n */\nexport const withLogger = <TEvent = any, TResult = any>(\n    handler: Handler<TEvent, TResult>,\n    options: CreateLoggerOptions = {},\n): Handler<TEvent, TResult> => {\n    return async (event: TEvent, context: any, callback?: any) => {\n        // 1. Initialize Logger\n        // Create a root logger if custom options are provided, or use default behavior.\n        // We create a FRESH logger instance for each request to ensure context isolation if needed?\n        // Actually, creating a logger instance is cheap?\n        // Winston createLogger is relatively heavy.\n        // Optimization: We could reuse a global logger and just child() it.\n        // But options might change? Usually options are static.\n        // Let's assume options are static per lambda wrapper usage.\n\n        // HOWEVER, to support dynamic options per request might be overkill.\n        // Let's create one global logger instance for this wrapper instantiation if possible?\n        // But wait, the standard `createLogger` we implemented creates a NEW winston instance every time.\n        // We should probably cache it?\n        // For now, let's keep it simple: createLogger per request.\n        // If performance becomes an issue, we can refactor `createLogger` to reuse the winston instance if options match.\n\n        const rootLogger = createLogger(options);\n\n        // 2. Extract Context\n        const requestContext: Record<string, any> = {};\n        if (context) {\n            if (context.awsRequestId) requestContext.requestId = context.awsRequestId;\n            if (context.functionName) requestContext.functionName = context.functionName;\n        }\n\n        // 3. Create Child Logger with Request Context\n        const scopedLogger = rootLogger.child(requestContext);\n\n        // 3a. Log Event and Context\n        scopedLogger.debug('Lambda Event', { event });\n        scopedLogger.debug('Lambda Context', { context });\n\n        // 4. Run Handler in Context\n        return runWithLogger(scopedLogger, async () => {\n            // We use 'await' to ensure the context stays active during the handler execution\n            // If the handler accepts a callback, we might need special handling?\n            // Most modern lambdas use async/await.\n            // If legacy callback style is used, AsyncLocalStorage context *should* still propagate\n            // if the callback is invoked asynchronously.\n            // But we wrap the result in Promise usually.\n\n            // Supporting both async and callback style:\n            try {\n                // If it returns a promise, await it\n                const result = await handler(event, context, callback);\n                return result as TResult;\n            } catch (error) {\n                // We could log unhandled errors here too?\n                // Standard lambda practice is to let the error propagate so Lambda runtime sees it (and retries etc)\n                // BUT we should log it first because once it leaves here, we might lose the logger context behavior.\n                scopedLogger.error('Unhandled Lambda Exception', error as Error);\n                throw error;\n            }\n        });\n    };\n};\n"],"mappings":"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","names":["message"]}
+{"version":3,"sources":["../src/redactor.ts","../src/context.ts","../src/logger.ts","../src/constants.ts","../src/wrapper.ts"],"sourcesContent":["import crypto from 'crypto';\n\nexport type RedactionStrategy = 'mask' | 'remove' | 'hash' | string | ((value: any) => any);\n\nexport interface RedactionConfig {\n    /**\n     * Array of keys to redact.\n     * Case-insensitive matching is recommended/implemented.\n     */\n    keys: string[];\n    /**\n     * Map of specific key to strategy.\n     * If a key is in 'keys' but not here, it uses the default strategy ('mask').\n     */\n    strategies?: Record<string, RedactionStrategy>;\n    /**\n     * Default strategy for keys found in the list but not in the strategy map.\n     * Default: 'mask'\n     */\n    defaultStrategy?: RedactionStrategy;\n}\n\nexport const COMMON_REDACTION_KEYS = [\n    'password',\n    'passwd',\n    'secret',\n    'token',\n    'access_token',\n    'access-token',\n    'auth',\n    'auth-token',\n    'authorization',\n    'apikey',\n    'api_key',\n    'api-key',\n    'card',\n    'cvv',\n    'ssn',\n    'pin',\n];\n\n/**\n * Applies the redaction strategy to a single value.\n */\nconst applyStrategy = (value: any, strategy: RedactionStrategy): any => {\n    if (typeof strategy === 'function') {\n        return strategy(value);\n    }\n\n    if (typeof strategy === 'string' && strategy.startsWith('mask-last-')) {\n        const parts = strategy.split('-');\n        const lastN = parseInt(parts[2], 10);\n\n        if (typeof value === 'string' && !isNaN(lastN)) {\n            if (value.length <= lastN) {\n                return value; // Or mask entirely? Usually if shorter, we show it or mask all. Let's return as is or mask all?\n                // Security wise: showing short secrets fully is bad. Masking all is safer.\n                // BUT, if user asked for last 4 and length is 3, showing 3 is effectively \"last 4\".\n                // Let's mask all if length <= lastN to be safe? Or just return.\n                // Actually, standard is usually: if len <= N, show all (it IS the last N).\n                // But for API keys, usually we want to see SOMETHING masked.\n                // Let's preserve standard behavior: visible suffix.\n                return value;\n            }\n            const maskLen = value.length - lastN;\n            return '*'.repeat(maskLen) + value.slice(-lastN);\n        }\n        return '*****'; // Fallback for non-strings\n    }\n\n    switch (strategy) {\n        case 'remove':\n            return undefined;\n        case 'hash':\n            if (typeof value === 'string' || typeof value === 'number') {\n                return crypto.createHash('sha256').update(String(value)).digest('hex');\n            }\n            return '[HASH_FAILED_TYPE]';\n        case 'mask':\n        default:\n            return '*****';\n    }\n};\n\n/**\n * Recursively walks the object and redacts fields matching the config.\n */\nexport const recursiveRedact = (\n    target: any,\n    config: RedactionConfig,\n    cache = new Set<any>(),\n): any => {\n    if (target === null || typeof target !== 'object') {\n        return target;\n    }\n\n    // Handle circular references\n    if (cache.has(target)) {\n        return '[Circular]';\n    }\n    cache.add(target);\n\n    // Handle Arrays\n    if (Array.isArray(target)) {\n        return target.map((item) => recursiveRedact(item, config, cache));\n    }\n\n    // Handle Objects\n    const redactedObj: Record<string, any> = {};\n    const keysToRedact = new Set(config.keys.map((k) => k.toLowerCase()));\n\n    for (const [key, value] of Object.entries(target)) {\n        const lowerKey = key.toLowerCase();\n\n        if (keysToRedact.has(lowerKey)) {\n            // Determine strategy\n            let strategy = config.defaultStrategy || 'mask';\n            if (config.strategies && config.strategies[key]) {\n                // Try exact match first\n                strategy = config.strategies[key];\n            } else if (config.strategies) {\n                // Try case-insensitive lookup in strategies if needed,\n                // but for simplicity let's rely on specific keys matching or default.\n                // Actually, user might put 'Password': 'hash' and we matched 'password'.\n                // Let's iterate strategies keys to find case-insensitive match if strictly needed.\n                // For performance/simplicity, strict case matching in strategies map is safer,\n                // but generic 'keys' list is case-insensitive.\n\n                // Let's look for a key in strategies that matches lowerKey\n                const strategyKey = Object.keys(config.strategies).find(\n                    (k) => k.toLowerCase() === lowerKey,\n                );\n                if (strategyKey) {\n                    strategy = config.strategies[strategyKey];\n                }\n            }\n\n            const result = applyStrategy(value, strategy);\n            if (result !== undefined) {\n                redactedObj[key] = result;\n            }\n            // If undefined (remove strategy), we just don't add the key.\n        } else {\n            // Recurse\n            redactedObj[key] = recursiveRedact(value, config, cache);\n        }\n    }\n\n    return redactedObj;\n};\n\nexport const createRedactor = (config: RedactionConfig) => {\n    return (info: any) => {\n        return recursiveRedact(info, config);\n    };\n};\n","import { AsyncLocalStorage } from 'async_hooks';\nimport { Logger } from './types';\n\n// We store a reference to the logger so we can update it in-place for the current context\ninterface LoggerStore {\n    logger: Logger;\n    requestId?: string;\n}\n\nconst asyncLocalStorage = new AsyncLocalStorage<LoggerStore>();\n\n/**\n * Runs a callback within a logger context.\n * The logger provided becomes the \"current\" logger for the duration of the callback.\n */\nexport const runWithLogger = <T>(logger: Logger, callback: () => T, requestId?: string): T => {\n    return asyncLocalStorage.run({ logger, requestId }, callback);\n};\n\n/**\n * Gets the current logger from the async context.\n */\nexport const getLogger = (): Logger | undefined => {\n    const store = asyncLocalStorage.getStore();\n    return store?.logger;\n};\n\n/**\n * Gets the current request ID from the async context.\n */\nexport const getRequestId = (): string | undefined => {\n    const store = asyncLocalStorage.getStore();\n    return store?.requestId;\n};\n\n/**\n * Updates the current context's logger.\n * This effectively \"extends\" the logger for the remainder of the current async execution\n * and any further downstream calls sharing this context.\n */\nexport const updateLoggerContext = (newLogger: Logger): void => {\n    const store = asyncLocalStorage.getStore();\n    if (store) {\n        store.logger = newLogger;\n    } else {\n        // If we are not in a context, we can't update it.\n        // We could throw, or warn. For now, let's warn.\n        console.warn(\n            'AntigravityLogger: updateLoggerContext called outside of an active context. Logic ignored.',\n        );\n    }\n};\n","import winston from 'winston';\nimport { Logger } from './types';\nimport { DEFAULT_LOG_LEVEL } from './constants';\nimport { RedactionConfig, createRedactor } from './redactor';\n\nexport interface CreateLoggerOptions {\n    /**\n     * Default context to include in all logs\n     */\n    defaultContext?: Record<string, any>;\n    /**\n     * Log level (default: process.env.LOG_LEVEL || 'info')\n     */\n    level?: string;\n    /**\n     * Configuration for data redaction\n     */\n    redaction?: RedactionConfig;\n}\n\nconst formatContext = (context?: Record<string, any>): Record<string, any> => {\n    return context || {};\n};\n\nconst createLoggerWrapper = (winstonLogger: winston.Logger): Logger => {\n    return {\n        debug: (message: string, context?: Record<string, any>): void => {\n            winstonLogger.debug(message, formatContext(context));\n        },\n\n        info: (message: string, context?: Record<string, any>): void => {\n            winstonLogger.info(message, formatContext(context));\n        },\n\n        warn: (message: string, context?: Record<string, any>): void => {\n            winstonLogger.warn(message, formatContext(context));\n        },\n\n        error: (\n            message: string,\n            errorOrContext?: Error | string | Record<string, any>,\n            context?: Record<string, any>,\n        ): void => {\n            let meta = formatContext(context);\n\n            if (errorOrContext instanceof Error || typeof errorOrContext === 'string') {\n                // Old behavior: second arg is the error\n                const error = errorOrContext;\n                if (error instanceof Error) {\n                    const { message, name, stack, ...rest } = error;\n                    meta.error = {\n                        ...rest,\n                        message,\n                        name,\n                        stack,\n                    };\n                } else {\n                    meta.error = error;\n                }\n            } else if (typeof errorOrContext === 'object' && errorOrContext !== null) {\n                // New behavior: second arg is context (which might contain error)\n                meta = { ...meta, ...errorOrContext };\n\n                // If error is in the context, format it nicely\n                if (meta.error instanceof Error) {\n                    const { message, name, stack, ...rest } = meta.error;\n                    meta.error = {\n                        ...rest,\n                        message,\n                        name,\n                        stack,\n                    };\n                }\n            }\n\n            winstonLogger.error(message, meta);\n        },\n\n        child: (context: Record<string, any>): Logger => {\n            // Winston's child() returns a new logger instance with the metadata bound\n            return createLoggerWrapper(winstonLogger.child(context));\n        },\n    };\n};\n\nexport const createLogger = (options: CreateLoggerOptions = {}): Logger => {\n    const level = options.level || process.env.LOG_LEVEL || DEFAULT_LOG_LEVEL;\n\n    // Create redactor if config is present\n    const redactor = options.redaction ? createRedactor(options.redaction) : null;\n\n    // Custom format that applies redaction\n    const redactionFormat = winston.format((info) => {\n        if (redactor) {\n            return redactor(info);\n        }\n        return info;\n    });\n\n    const format = winston.format.combine(\n        winston.format.timestamp(),\n        redactionFormat(), // Apply redaction before JSON\n        winston.format.json(),\n    );\n\n    const winstonLogger = winston.createLogger({\n        level,\n        format,\n        defaultMeta: options.defaultContext,\n        transports: [new winston.transports.Console()],\n    });\n\n    return createLoggerWrapper(winstonLogger);\n};\n","export const DEFAULT_LOG_LEVEL = 'info';\nexport const REQUEST_ID_KEY = 'x-request-id';\n","import { CreateLoggerOptions, createLogger } from './logger';\nimport { runWithLogger } from './context';\n\n// Generic Handler type compatible with AWS Lambda\n// We use 'any' to avoid strict dependency on @types/aws-lambda for this generic wrapper\n// but in practice it wraps (event, context, callback?) => Promise<any> | any\ntype Handler<TEvent = any, TResult = any> = (\n    event: TEvent,\n    context: any,\n    callback?: any,\n) => Promise<TResult> | void;\n\n/**\n * Higher-order function to wrap a Lambda handler with logger context.\n * Automatically extracts 'awsRequestId' and 'functionName' from the Lambda context\n * and initializes a logger for the request scope.\n *\n * @param handler The original Lambda handler\n * @param options Logger options (level, redaction, etc.)\n */\nexport const withLogger = <TEvent = any, TResult = any>(\n    handler: Handler<TEvent, TResult>,\n    options: CreateLoggerOptions = {},\n): Handler<TEvent, TResult> => {\n    return async (event: TEvent, context: any, callback?: any) => {\n        // 1. Initialize Logger\n        // Create a root logger if custom options are provided, or use default behavior.\n        // We create a FRESH logger instance for each request to ensure context isolation if needed?\n        // Actually, creating a logger instance is cheap?\n        // Winston createLogger is relatively heavy.\n        // Optimization: We could reuse a global logger and just child() it.\n        // But options might change? Usually options are static.\n        // Let's assume options are static per lambda wrapper usage.\n\n        // HOWEVER, to support dynamic options per request might be overkill.\n        // Let's create one global logger instance for this wrapper instantiation if possible?\n        // But wait, the standard `createLogger` we implemented creates a NEW winston instance every time.\n        // We should probably cache it?\n        // For now, let's keep it simple: createLogger per request.\n        // If performance becomes an issue, we can refactor `createLogger` to reuse the winston instance if options match.\n\n        const rootLogger = createLogger(options);\n\n        // 2. Extract Context\n        const requestContext: Record<string, any> = {};\n        if (context) {\n            if (context.awsRequestId) requestContext.requestId = context.awsRequestId;\n            if (context.functionName) requestContext.functionName = context.functionName;\n        }\n\n        // 3. Create Child Logger with Request Context\n        const scopedLogger = rootLogger.child(requestContext);\n\n        // 3a. Log Event and Context\n        scopedLogger.debug('Lambda Event', { event });\n        scopedLogger.debug('Lambda Context', { context });\n\n        // 4. Run Handler in Context\n        return runWithLogger(\n            scopedLogger,\n            async () => {\n                // We use 'await' to ensure the context stays active during the handler execution\n                // If the handler accepts a callback, we might need special handling?\n                // Most modern lambdas use async/await.\n                // If legacy callback style is used, AsyncLocalStorage context *should* still propagate\n                // if the callback is invoked asynchronously.\n                // But we wrap the result in Promise usually.\n\n                // Supporting both async and callback style:\n                try {\n                    // If it returns a promise, await it\n                    const result = await handler(event, context, callback);\n                    return result as TResult;\n                } catch (error) {\n                    // We could log unhandled errors here too?\n                    // Standard lambda practice is to let the error propagate so Lambda runtime sees it (and retries etc)\n                    // BUT we should log it first because once it leaves here, we might lose the logger context behavior.\n                    scopedLogger.error('Unhandled Lambda Exception', error as Error);\n                    throw error;\n                }\n            },\n            requestContext.requestId,\n        );\n    };\n};\n"],"mappings":"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","names":["message"]}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vitkuz/aws-logger",
-    "version": "1.3.0",
+    "version": "1.5.0",
     "description": "Standardized AWS Logger using Winston",
     "main": "dist/index.js",
     "module": "dist/index.mjs",
@@ -14,8 +14,9 @@
         "test:redaction": "tsx test/redaction-test.ts",
         "test:async-context": "tsx test/async-context.test.ts",
         "test:wrapper": "tsx test/wrapper.test.ts",
-        "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
-        "prepublishOnly": "npm run format && npm run build"
+        "format": "prettier --write .",
+        "prepublishOnly": "npm run format && npm run build",
+        "check-format": "prettier --check ."
     },
     "dependencies": {
         "winston": "^3.11.0"
@@ -26,5 +27,14 @@
         "tsup": "^8.0.1",
         "tsx": "^4.7.0",
         "typescript": "^5.3.3"
-    }
+    },
+    "author": "Vitali Kuzmenka",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/vitkuz/vitkuz-aws-logger.git"
+    },
+    "bugs": {
+        "url": "https://github.com/vitkuz/vitkuz-aws-logger/issues"
+    },
+    "homepage": "https://github.com/vitkuz/vitkuz-aws-logger#readme"
 }

package/src/context.ts

@@ -4,6 +4,7 @@ import { Logger } from './types';
 // We store a reference to the logger so we can update it in-place for the current context
 interface LoggerStore {
     logger: Logger;
+    requestId?: string;
 }
 
 const asyncLocalStorage = new AsyncLocalStorage<LoggerStore>();
@@ -12,23 +13,26 @@ const asyncLocalStorage = new AsyncLocalStorage<LoggerStore>();
  * Runs a callback within a logger context.
  * The logger provided becomes the "current" logger for the duration of the callback.
  */
-export const runWithLogger = <T>(logger: Logger, callback: () => T): T => {
-    return asyncLocalStorage.run({ logger }, callback);
+export const runWithLogger = <T>(logger: Logger, callback: () => T, requestId?: string): T => {
+    return asyncLocalStorage.run({ logger, requestId }, callback);
 };
 
 /**
  * Gets the current logger from the async context.
- * Throws an error if called outside of a runWithLogger context,
- * unless a fallback is provided (though usually we want to enforce context).
- *
- * To make it easier to use, we can return undefined or a default logger if needed,
- * but for this specific feature request "access by all down the stream", strictness is good.
  */
 export const getLogger = (): Logger | undefined => {
     const store = asyncLocalStorage.getStore();
     return store?.logger;
 };
 
+/**
+ * Gets the current request ID from the async context.
+ */
+export const getRequestId = (): string | undefined => {
+    const store = asyncLocalStorage.getStore();
+    return store?.requestId;
+};
+
 /**
  * Updates the current context's logger.
  * This effectively "extends" the logger for the remainder of the current async execution

package/src/logger.ts

@@ -36,22 +36,43 @@ const createLoggerWrapper = (winstonLogger: winston.Logger): Logger => {
             winstonLogger.warn(message, formatContext(context));
         },
 
-        error: (message: string, error?: Error | string, context?: Record<string, any>): void => {
-            const meta = formatContext(context);
-            if (error instanceof Error) {
-                // Winston handles error objects well if passed as meta or splat
-                // But for explicit structure, let's attach it
-                // Spread error first to capture custom props, then overwrite standard ones to ensure presence
-                const { message, name, stack, ...rest } = error;
-                meta.error = {
-                    ...rest,
-                    message,
-                    name,
-                    stack,
-                };
-            } else if (error) {
-                meta.error = error;
+        error: (
+            message: string,
+            errorOrContext?: Error | string | Record<string, any>,
+            context?: Record<string, any>,
+        ): void => {
+            let meta = formatContext(context);
+
+            if (errorOrContext instanceof Error || typeof errorOrContext === 'string') {
+                // Old behavior: second arg is the error
+                const error = errorOrContext;
+                if (error instanceof Error) {
+                    const { message, name, stack, ...rest } = error;
+                    meta.error = {
+                        ...rest,
+                        message,
+                        name,
+                        stack,
+                    };
+                } else {
+                    meta.error = error;
+                }
+            } else if (typeof errorOrContext === 'object' && errorOrContext !== null) {
+                // New behavior: second arg is context (which might contain error)
+                meta = { ...meta, ...errorOrContext };
+
+                // If error is in the context, format it nicely
+                if (meta.error instanceof Error) {
+                    const { message, name, stack, ...rest } = meta.error;
+                    meta.error = {
+                        ...rest,
+                        message,
+                        name,
+                        stack,
+                    };
+                }
             }
+
             winstonLogger.error(message, meta);
         },
 

package/src/types.ts

@@ -2,7 +2,11 @@ export interface Logger {
     debug(message: string, context?: Record<string, any>): void;
     info(message: string, context?: Record<string, any>): void;
     warn(message: string, context?: Record<string, any>): void;
-    error(message: string, error?: Error | string, context?: Record<string, any>): void;
+    error(
+        message: string,
+        errorOrContext?: Error | string | Record<string, any>,
+        context?: Record<string, any>,
+    ): void;
 
     /**
      * Creates a child logger with bound context.

package/src/wrapper.ts

@@ -56,26 +56,30 @@ export const withLogger = <TEvent = any, TResult = any>(
         scopedLogger.debug('Lambda Context', { context });
 
         // 4. Run Handler in Context
-        return runWithLogger(scopedLogger, async () => {
-            // We use 'await' to ensure the context stays active during the handler execution
-            // If the handler accepts a callback, we might need special handling?
-            // Most modern lambdas use async/await.
-            // If legacy callback style is used, AsyncLocalStorage context *should* still propagate
-            // if the callback is invoked asynchronously.
-            // But we wrap the result in Promise usually.
+        return runWithLogger(
+            scopedLogger,
+            async () => {
+                // We use 'await' to ensure the context stays active during the handler execution
+                // If the handler accepts a callback, we might need special handling?
+                // Most modern lambdas use async/await.
+                // If legacy callback style is used, AsyncLocalStorage context *should* still propagate
+                // if the callback is invoked asynchronously.
+                // But we wrap the result in Promise usually.
 
-            // Supporting both async and callback style:
-            try {
-                // If it returns a promise, await it
-                const result = await handler(event, context, callback);
-                return result as TResult;
-            } catch (error) {
-                // We could log unhandled errors here too?
-                // Standard lambda practice is to let the error propagate so Lambda runtime sees it (and retries etc)
-                // BUT we should log it first because once it leaves here, we might lose the logger context behavior.
-                scopedLogger.error('Unhandled Lambda Exception', error as Error);
-                throw error;
-            }
-        });
+                // Supporting both async and callback style:
+                try {
+                    // If it returns a promise, await it
+                    const result = await handler(event, context, callback);
+                    return result as TResult;
+                } catch (error) {
+                    // We could log unhandled errors here too?
+                    // Standard lambda practice is to let the error propagate so Lambda runtime sees it (and retries etc)
+                    // BUT we should log it first because once it leaves here, we might lose the logger context behavior.
+                    scopedLogger.error('Unhandled Lambda Exception', error as Error);
+                    throw error;
+                }
+            },
+            requestContext.requestId,
+        );
     };
 };

package/tsconfig.json

@@ -10,8 +10,5 @@
         "outDir": "dist",
         "declaration": true
     },
-    "include": [
-        "src",
-        "test"
-    ]
-}
+    "include": ["src", "test"]
+}