@energica-city/shared-amplify-utils
Version:
Shared utilities for AWS Amplify projects
379 lines • 39.1 kB
JavaScript
/**
* Defines the log levels for the logger.
*/
export var LogLevel;
(function (LogLevel) {
LogLevel[LogLevel["NONE"] = 0] = "NONE";
LogLevel[LogLevel["ERROR"] = 1] = "ERROR";
LogLevel[LogLevel["WARN"] = 2] = "WARN";
LogLevel[LogLevel["INFO"] = 3] = "INFO";
LogLevel[LogLevel["DEBUG"] = 4] = "DEBUG";
})(LogLevel || (LogLevel = {}));
/**
* A singleton Logger class that provides structured and text-based logging.
* It supports different log levels, contextual information, and can adapt
* its output format based on the environment (e.g., development, production, AWS Lambda).
*/
class Logger {
static instance;
level = LogLevel.INFO; // Default level
context = {};
useStructuredLogging = false;
environment = 'development';
// Make constructor private to enforce singleton pattern
constructor() {
// Detect environment using multiple methods
this.environment = this.detectEnvironment();
// Enable structured logging based on environment detection
this.useStructuredLogging = this.shouldUseStructuredLogging();
}
/**
* Detects the current runtime environment.
* It checks for Amplify-specific environment variables, AWS Lambda function names,
* and standard `NODE_ENV`. Defaults to 'development'.
* @returns The detected environment name (e.g., 'production', 'development').
*/
detectEnvironment() {
// Method 1: Explicit environment variable (set in backend.ts)
if (process.env.environment === 'prod') {
return 'production';
}
// Method 2: AWS stack name pattern (matches backend.ts logic)
const functionName = process.env.AWS_LAMBDA_FUNCTION_NAME;
if (functionName && functionName.includes('-main-')) {
return 'production';
}
// Method 3: AWS execution environment
if (process.env.AWS_EXECUTION_ENV) {
return 'aws-lambda';
}
// Method 4: Traditional NODE_ENV
if (process.env.NODE_ENV === 'production') {
return 'production';
}
// Default to development
return 'development';
}
/**
* Determines whether to use structured (JSON) logging.
* Structured logging is enabled if the `STRUCTURED_LOGGING` environment variable is 'true',
* or if the environment is detected as 'pro' or 'aws-lambda'.
* @returns `true` if structured logging should be used, otherwise `false`.
*/
shouldUseStructuredLogging() {
// Explicit override
if (process.env.STRUCTURED_LOGGING === 'true') {
return true;
}
if (process.env.STRUCTURED_LOGGING === 'false') {
return false;
}
// Auto-enable for production and AWS Lambda environments
return (this.environment === 'production' || this.environment === 'aws-lambda');
}
/**
* Gets the singleton instance of the Logger.
* @returns The singleton Logger instance.
*/
static getInstance() {
if (!Logger.instance) {
Logger.instance = new Logger();
}
return Logger.instance;
}
/**
* Sets the log level for the logger. Messages with a level lower than
* the set level will not be logged.
* @param level The log level to set.
*/
setLevel(level) {
this.level = level;
}
/**
* Gets the current log level of the logger.
* @returns The current LogLevel.
*/
getLevel() {
return this.level;
}
/**
* Gets the name of the current log level.
* @returns The name of the current log level (e.g., 'INFO', 'DEBUG').
*/
getLevelName() {
return LogLevel[this.level];
}
/**
* Gets the detected runtime environment.
* @returns The name of the environment (e.g., 'production', 'development').
*/
getEnvironment() {
return this.environment;
}
/**
* Enables or disables structured (JSON) logging.
* @param enabled `true` to enable structured logging, `false` to disable it.
*/
setStructuredLogging(enabled) {
this.useStructuredLogging = enabled;
}
/**
* Checks if structured logging is currently enabled.
* @returns `true` if structured logging is enabled, otherwise `false`.
*/
isStructuredLoggingEnabled() {
return this.useStructuredLogging;
}
/**
* Sets context that will be included in all subsequent log messages.
* The new context is merged with any existing context.
* @param newContext A partial LogContext object to merge into the current context.
*/
setContext(newContext) {
this.context = { ...this.context, ...newContext };
}
/**
* Gets a copy of the current log context.
* @returns A copy of the current LogContext.
*/
getContext() {
return { ...this.context };
}
/**
* Clears the current log context.
*/
clearContext() {
this.context = {};
}
/**
* Retrieves AWS Lambda-specific context from environment variables.
* @returns An object containing AWS request ID, function name, trace ID, and environment.
*/
getAWSContext() {
const awsContext = {};
if (process.env.AWS_REQUEST_ID) {
awsContext.awsRequestId = process.env.AWS_REQUEST_ID;
}
if (process.env.AWS_LAMBDA_FUNCTION_NAME) {
awsContext.functionName = process.env.AWS_LAMBDA_FUNCTION_NAME;
}
if (process.env._X_AMZN_TRACE_ID) {
awsContext.xrayTraceId = process.env._X_AMZN_TRACE_ID;
}
// Include detected environment
awsContext.environment = this.environment;
return awsContext;
}
/**
* Creates a structured log entry object.
* @param level The log level name (e.g., 'ERROR').
* @param message The main log message.
* @param data Additional data to include in the log.
* @returns A StructuredLogEntry object.
*/
createStructuredLog(level, message, data) {
const logEntry = {
timestamp: new Date().toISOString(),
level,
message,
...this.getAWSContext(),
};
// Add context if it exists
if (Object.keys(this.context).length > 0) {
logEntry.context = this.context;
}
// Add data if provided
if (data !== undefined) {
logEntry.data = data;
}
return logEntry;
}
/**
* Formats a log message with context for plain text logging.
* @param level The log level name (e.g., 'INFO').
* @param args The array of arguments to log.
* @returns A formatted log string.
*/
formatWithContext(level, args) {
const contextStr = Object.keys(this.context).length > 0
? ` ${JSON.stringify(this.context)}`
: '';
const argsStr = args
.map(arg => {
try {
return typeof arg === 'string' ? arg : JSON.stringify(arg);
}
catch {
return String(arg);
}
})
.join(' ');
return `[${level}]${contextStr} ${argsStr}`;
}
/**
* The main logging method that handles both structured and text logging.
* It checks the log level and formats the message accordingly.
* @param level The log level of the message.
* @param levelName The name of the log level.
* @param args The arguments to log.
*/
logMessage(level, levelName, ...args) {
if (this.level < level)
return;
if (this.useStructuredLogging) {
// Structured JSON logging
const message = args.length > 0 ? String(args[0]) : '';
const data = args.length > 1 ? args.slice(1) : undefined;
const structuredLog = this.createStructuredLog(levelName, message, data);
const output = JSON.stringify(structuredLog);
// Use appropriate console method
if (level === LogLevel.ERROR) {
// eslint-disable-next-line no-console
console.error(output);
}
else if (level === LogLevel.WARN) {
// eslint-disable-next-line no-console
console.warn(output);
}
else if (level === LogLevel.INFO) {
// eslint-disable-next-line no-console
console.info(output);
}
else {
// eslint-disable-next-line no-console
console.debug(output);
}
}
else {
// Text logging (existing behavior)
const message = this.formatWithContext(levelName, args);
if (level === LogLevel.ERROR) {
// eslint-disable-next-line no-console
console.error(message);
}
else if (level === LogLevel.WARN) {
// eslint-disable-next-line no-console
console.warn(message);
}
else if (level === LogLevel.INFO) {
// eslint-disable-next-line no-console
console.info(message);
}
else {
// eslint-disable-next-line no-console
console.debug(message);
}
}
}
/**
* Logs an error message.
* @param args The arguments to log.
*/
error(...args) {
this.logMessage(LogLevel.ERROR, 'ERROR', ...args);
}
/**
* Logs a warning message.
* @param args The arguments to log.
*/
warn(...args) {
this.logMessage(LogLevel.WARN, 'WARN', ...args);
}
/**
* Logs an informational message.
* @param args The arguments to log.
*/
info(...args) {
this.logMessage(LogLevel.INFO, 'INFO', ...args);
}
/**
* Logs a debug message.
* @param args The arguments to log.
*/
debug(...args) {
this.logMessage(LogLevel.DEBUG, 'DEBUG', ...args);
}
/**
* Logs a message directly to the console without level checking or formatting.
* All arguments are stringified.
* @param args The arguments to log.
*/
log(...args) {
const stringifiedArgs = args.map(arg => {
try {
return typeof arg === 'string' ? arg : JSON.stringify(arg);
}
catch {
return String(arg);
}
});
// eslint-disable-next-line no-console
console.log(...stringifiedArgs);
}
}
/**
* # Usage in AWS Lambda with CloudWatch
*
* This logger is optimized for use within AWS Lambda functions, sending structured
* JSON logs to Amazon CloudWatch.
*
* ## Structured Logging
*
* When running in a detected AWS Lambda environment, the logger automatically
* switches to structured JSON format. This provides several advantages in CloudWatch:
*
* - **Searchable Logs**: Structured logs enable easy searching and filtering in CloudWatch Logs
* based on JSON fields (e.g., `level`, `context.requestId`, `data.someValue`).
* - **CloudWatch Logs Insights**: Structured logs can be queried with CloudWatch
* Logs Insights for powerful analysis and visualization.
* - **Automatic Context**: The logger automatically captures Lambda-specific context
* like `awsRequestId` and `functionName`.
*
* ## Example Handler
*
* ```typescript
* import { logger } from './util/log';
*
* export const handler = async (event, context) => {
* // Set context for all logs in this invocation for easy tracking
* logger.setContext({
* awsRequestId: context.awsRequestId,
* userId: event.arguments.userId, // Example
* });
*
* try {
* logger.info('Function started', { input: event.arguments });
*
* // ... business logic implementation ...
*
* const result = { success: true };
* logger.info('Function finished successfully', { result });
* return result;
*
* } catch (error) {
* // Log the error with structured data
* logger.error('An unhandled error occurred', {
* error: error.message,
* stack: error.stack,
* });
* // Rethrow or handle as appropriate
* throw error;
* } finally {
* // Clear context to avoid leaking information between invocations
* logger.clearContext();
* }
* };
* ```
*/
// Export a singleton instance
export const logger = Logger.getInstance();
let logLevel;
try {
// Remove the debug console.log(process) statement
logLevel = parseInt(process?.env?.LOG_LEVEL || '3');
}
catch {
logLevel = 3;
}
logger.setLevel(logLevel);
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../log/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Defines the log levels for the logger.\n */\nexport enum LogLevel {\n  NONE = 0,\n  ERROR = 1,\n  WARN = 2,\n  INFO = 3,\n  DEBUG = 4,\n}\n\n/**\n * Defines the structure for contextual information attached to logs.\n */\nexport interface LogContext {\n  requestId?: string;\n  operation?: string;\n  userId?: string;\n  [key: string]: unknown;\n}\n\n/**\n * Defines the structure for a structured log entry in JSON format.\n */\nexport interface StructuredLogEntry {\n  timestamp: string;\n  level: string;\n  message: string;\n  context?: LogContext;\n  data?: unknown;\n  // AWS Lambda context\n  awsRequestId?: string;\n  functionName?: string;\n  xrayTraceId?: string;\n  // Environment info\n  environment?: string;\n}\n\n/**\n * A singleton Logger class that provides structured and text-based logging.\n * It supports different log levels, contextual information, and can adapt\n * its output format based on the environment (e.g., development, production, AWS Lambda).\n */\nclass Logger {\n  private static instance: Logger;\n  private level: LogLevel = LogLevel.INFO; // Default level\n  private context: LogContext = {};\n  private useStructuredLogging: boolean = false;\n  private environment: string = 'development';\n\n  // Make constructor private to enforce singleton pattern\n  private constructor() {\n    // Detect environment using multiple methods\n    this.environment = this.detectEnvironment();\n\n    // Enable structured logging based on environment detection\n    this.useStructuredLogging = this.shouldUseStructuredLogging();\n  }\n\n  /**\n   * Detects the current runtime environment.\n   * It checks for Amplify-specific environment variables, AWS Lambda function names,\n   * and standard `NODE_ENV`. Defaults to 'development'.\n   * @returns The detected environment name (e.g., 'production', 'development').\n   */\n  private detectEnvironment(): string {\n    // Method 1: Explicit environment variable (set in backend.ts)\n    if (process.env.environment === 'prod') {\n      return 'production';\n    }\n\n    // Method 2: AWS stack name pattern (matches backend.ts logic)\n    const functionName = process.env.AWS_LAMBDA_FUNCTION_NAME;\n    if (functionName && functionName.includes('-main-')) {\n      return 'production';\n    }\n\n    // Method 3: AWS execution environment\n    if (process.env.AWS_EXECUTION_ENV) {\n      return 'aws-lambda';\n    }\n\n    // Method 4: Traditional NODE_ENV\n    if (process.env.NODE_ENV === 'production') {\n      return 'production';\n    }\n\n    // Default to development\n    return 'development';\n  }\n\n  /**\n   * Determines whether to use structured (JSON) logging.\n   * Structured logging is enabled if the `STRUCTURED_LOGGING` environment variable is 'true',\n   * or if the environment is detected as 'pro' or 'aws-lambda'.\n   * @returns `true` if structured logging should be used, otherwise `false`.\n   */\n  private shouldUseStructuredLogging(): boolean {\n    // Explicit override\n    if (process.env.STRUCTURED_LOGGING === 'true') {\n      return true;\n    }\n    if (process.env.STRUCTURED_LOGGING === 'false') {\n      return false;\n    }\n\n    // Auto-enable for production and AWS Lambda environments\n    return (\n      this.environment === 'production' || this.environment === 'aws-lambda'\n    );\n  }\n\n  /**\n   * Gets the singleton instance of the Logger.\n   * @returns The singleton Logger instance.\n   */\n  public static getInstance(): Logger {\n    if (!Logger.instance) {\n      Logger.instance = new Logger();\n    }\n    return Logger.instance;\n  }\n\n  /**\n   * Sets the log level for the logger. Messages with a level lower than\n   * the set level will not be logged.\n   * @param level The log level to set.\n   */\n  public setLevel(level: LogLevel): void {\n    this.level = level;\n  }\n\n  /**\n   * Gets the current log level of the logger.\n   * @returns The current LogLevel.\n   */\n  public getLevel(): LogLevel {\n    return this.level;\n  }\n\n  /**\n   * Gets the name of the current log level.\n   * @returns The name of the current log level (e.g., 'INFO', 'DEBUG').\n   */\n  public getLevelName(): string {\n    return LogLevel[this.level];\n  }\n\n  /**\n   * Gets the detected runtime environment.\n   * @returns The name of the environment (e.g., 'production', 'development').\n   */\n  public getEnvironment(): string {\n    return this.environment;\n  }\n\n  /**\n   * Enables or disables structured (JSON) logging.\n   * @param enabled `true` to enable structured logging, `false` to disable it.\n   */\n  public setStructuredLogging(enabled: boolean): void {\n    this.useStructuredLogging = enabled;\n  }\n\n  /**\n   * Checks if structured logging is currently enabled.\n   * @returns `true` if structured logging is enabled, otherwise `false`.\n   */\n  public isStructuredLoggingEnabled(): boolean {\n    return this.useStructuredLogging;\n  }\n\n  /**\n   * Sets context that will be included in all subsequent log messages.\n   * The new context is merged with any existing context.\n   * @param newContext A partial LogContext object to merge into the current context.\n   */\n  public setContext(newContext: Partial<LogContext>): void {\n    this.context = { ...this.context, ...newContext };\n  }\n\n  /**\n   * Gets a copy of the current log context.\n   * @returns A copy of the current LogContext.\n   */\n  public getContext(): LogContext {\n    return { ...this.context };\n  }\n\n  /**\n   * Clears the current log context.\n   */\n  public clearContext(): void {\n    this.context = {};\n  }\n\n  /**\n   * Retrieves AWS Lambda-specific context from environment variables.\n   * @returns An object containing AWS request ID, function name, trace ID, and environment.\n   */\n  private getAWSContext(): Partial<StructuredLogEntry> {\n    const awsContext: Partial<StructuredLogEntry> = {};\n\n    if (process.env.AWS_REQUEST_ID) {\n      awsContext.awsRequestId = process.env.AWS_REQUEST_ID;\n    }\n\n    if (process.env.AWS_LAMBDA_FUNCTION_NAME) {\n      awsContext.functionName = process.env.AWS_LAMBDA_FUNCTION_NAME;\n    }\n\n    if (process.env._X_AMZN_TRACE_ID) {\n      awsContext.xrayTraceId = process.env._X_AMZN_TRACE_ID;\n    }\n\n    // Include detected environment\n    awsContext.environment = this.environment;\n\n    return awsContext;\n  }\n\n  /**\n   * Creates a structured log entry object.\n   * @param level The log level name (e.g., 'ERROR').\n   * @param message The main log message.\n   * @param data Additional data to include in the log.\n   * @returns A StructuredLogEntry object.\n   */\n  private createStructuredLog(\n    level: string,\n    message: string,\n    data?: unknown,\n  ): StructuredLogEntry {\n    const logEntry: StructuredLogEntry = {\n      timestamp: new Date().toISOString(),\n      level,\n      message,\n      ...this.getAWSContext(),\n    };\n\n    // Add context if it exists\n    if (Object.keys(this.context).length > 0) {\n      logEntry.context = this.context;\n    }\n\n    // Add data if provided\n    if (data !== undefined) {\n      logEntry.data = data;\n    }\n\n    return logEntry;\n  }\n\n  /**\n   * Formats a log message with context for plain text logging.\n   * @param level The log level name (e.g., 'INFO').\n   * @param args The array of arguments to log.\n   * @returns A formatted log string.\n   */\n  private formatWithContext(level: string, args: unknown[]): string {\n    const contextStr =\n      Object.keys(this.context).length > 0\n        ? ` ${JSON.stringify(this.context)}`\n        : '';\n\n    const argsStr = args\n      .map(arg => {\n        try {\n          return typeof arg === 'string' ? arg : JSON.stringify(arg);\n        } catch {\n          return String(arg);\n        }\n      })\n      .join(' ');\n\n    return `[${level}]${contextStr} ${argsStr}`;\n  }\n\n  /**\n   * The main logging method that handles both structured and text logging.\n   * It checks the log level and formats the message accordingly.\n   * @param level The log level of the message.\n   * @param levelName The name of the log level.\n   * @param args The arguments to log.\n   */\n  private logMessage(\n    level: LogLevel,\n    levelName: string,\n    ...args: unknown[]\n  ): void {\n    if (this.level < level) return;\n\n    if (this.useStructuredLogging) {\n      // Structured JSON logging\n      const message = args.length > 0 ? String(args[0]) : '';\n      const data = args.length > 1 ? args.slice(1) : undefined;\n\n      const structuredLog = this.createStructuredLog(levelName, message, data);\n      const output = JSON.stringify(structuredLog);\n\n      // Use appropriate console method\n      if (level === LogLevel.ERROR) {\n        // eslint-disable-next-line no-console\n        console.error(output);\n      } else if (level === LogLevel.WARN) {\n        // eslint-disable-next-line no-console\n        console.warn(output);\n      } else if (level === LogLevel.INFO) {\n        // eslint-disable-next-line no-console\n        console.info(output);\n      } else {\n        // eslint-disable-next-line no-console\n        console.debug(output);\n      }\n    } else {\n      // Text logging (existing behavior)\n      const message = this.formatWithContext(levelName, args);\n\n      if (level === LogLevel.ERROR) {\n        // eslint-disable-next-line no-console\n        console.error(message);\n      } else if (level === LogLevel.WARN) {\n        // eslint-disable-next-line no-console\n        console.warn(message);\n      } else if (level === LogLevel.INFO) {\n        // eslint-disable-next-line no-console\n        console.info(message);\n      } else {\n        // eslint-disable-next-line no-console\n        console.debug(message);\n      }\n    }\n  }\n\n  /**\n   * Logs an error message.\n   * @param args The arguments to log.\n   */\n  public error(...args: unknown[]): void {\n    this.logMessage(LogLevel.ERROR, 'ERROR', ...args);\n  }\n\n  /**\n   * Logs a warning message.\n   * @param args The arguments to log.\n   */\n  public warn(...args: unknown[]): void {\n    this.logMessage(LogLevel.WARN, 'WARN', ...args);\n  }\n\n  /**\n   * Logs an informational message.\n   * @param args The arguments to log.\n   */\n  public info(...args: unknown[]): void {\n    this.logMessage(LogLevel.INFO, 'INFO', ...args);\n  }\n\n  /**\n   * Logs a debug message.\n   * @param args The arguments to log.\n   */\n  public debug(...args: unknown[]): void {\n    this.logMessage(LogLevel.DEBUG, 'DEBUG', ...args);\n  }\n\n  /**\n   * Logs a message directly to the console without level checking or formatting.\n   * All arguments are stringified.\n   * @param args The arguments to log.\n   */\n  public log(...args: unknown[]): void {\n    const stringifiedArgs = args.map(arg => {\n      try {\n        return typeof arg === 'string' ? arg : JSON.stringify(arg);\n      } catch {\n        return String(arg);\n      }\n    });\n    // eslint-disable-next-line no-console\n    console.log(...stringifiedArgs);\n  }\n}\n\n/**\n * # Usage in AWS Lambda with CloudWatch\n *\n * This logger is optimized for use within AWS Lambda functions, sending structured\n * JSON logs to Amazon CloudWatch.\n *\n * ## Structured Logging\n *\n * When running in a detected AWS Lambda environment, the logger automatically\n * switches to structured JSON format. This provides several advantages in CloudWatch:\n *\n * - **Searchable Logs**: Structured logs enable easy searching and filtering in CloudWatch Logs\n *   based on JSON fields (e.g., `level`, `context.requestId`, `data.someValue`).\n * - **CloudWatch Logs Insights**: Structured logs can be queried with CloudWatch\n *   Logs Insights for powerful analysis and visualization.\n * - **Automatic Context**: The logger automatically captures Lambda-specific context\n *   like `awsRequestId` and `functionName`.\n *\n * ## Example Handler\n *\n * ```typescript\n * import { logger } from './util/log';\n *\n * export const handler = async (event, context) => {\n *   // Set context for all logs in this invocation for easy tracking\n *   logger.setContext({\n *     awsRequestId: context.awsRequestId,\n *     userId: event.arguments.userId, // Example\n *   });\n *\n *   try {\n *     logger.info('Function started', { input: event.arguments });\n *\n *     // ... business logic implementation ...\n *\n *     const result = { success: true };\n *     logger.info('Function finished successfully', { result });\n *     return result;\n *\n *   } catch (error) {\n *     // Log the error with structured data\n *     logger.error('An unhandled error occurred', {\n *       error: error.message,\n *       stack: error.stack,\n *     });\n *     // Rethrow or handle as appropriate\n *     throw error;\n *   } finally {\n *     // Clear context to avoid leaking information between invocations\n *     logger.clearContext();\n *   }\n * };\n * ```\n */\n// Export a singleton instance\nexport const logger = Logger.getInstance();\nlet logLevel;\ntry {\n  // Remove the debug console.log(process) statement\n  logLevel = parseInt(process?.env?.LOG_LEVEL || '3');\n} catch {\n  logLevel = 3;\n}\nlogger.setLevel(logLevel as LogLevel);\n"]}