refactor(logger): add context enabled variable

Author: saragerion

packages/logger/examples/child-logger.ts

@@ -1,9 +1,9 @@
-process.env._X_AMZN_TRACE_ID = 'abcdef123456abcdef123456abcdef123456';
-process.env.AWS_LAMBDA_FUNCTION_NAME = 'my-lambda-function';
-process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '128';
-process.env.AWS_REGION = 'eu-central-1';
+import { populateEnvironmentVariables } from '../tests/helpers';
+
+// Populate runtime
+populateEnvironmentVariables();
+// Additional runtime variables
 process.env.LOG_LEVEL = 'INFO';
-process.env.POWERTOOLS_SERVICE_NAME = 'hello-world';
 
 import * as dummyEvent from '../../../tests/resources/events/custom/hello-world.json';
 import { context as dummyContext } from '../../../tests/resources/contexts/hello-world';

packages/logger/examples/custom-logger-options.ts

@@ -1,8 +1,10 @@
-process.env._X_AMZN_TRACE_ID = 'abcdef123456abcdef123456abcdef123456';
-process.env.AWS_LAMBDA_FUNCTION_NAME = 'my-lambda-function';
-process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '128';
-process.env.AWS_REGION = 'eu-central-1';
+import { populateEnvironmentVariables } from '../tests/helpers';
+
+// Populate runtime
+populateEnvironmentVariables();
+// Additional runtime variables
 process.env.CUSTOM_ENV = 'prod';
+process.env.POWERTOOLS_CONTEXT_ENABLED = 'TRUE';
 
 import * as dummyEvent from '../../../tests/resources/events/custom/hello-world.json';
 import * as powertool from '../../../package.json';
@@ -41,36 +43,4 @@ const lambdaHandler: Handler = async (event, context) => {
 
 };
 
-lambdaHandler(dummyEvent, dummyContext, () => {});
-
-/**
- * Sample output:
- *
- * {
- *   message: 'This is an ERROR log',
- *   service: 'foo-bar',
- *   environment: 'prod',
- *   awsRegion: 'eu-central-1',
- *   correlationIds: {
- *     awsRequestId: 'c6af9ac6-7b61-11e6-9a41-93e8deadbeef',
- *     xRayTraceId: 'abcdef123456abcdef123456abcdef123456',
- *     myCustomCorrelationId: 'foo-bar-baz'
- *   },
- *   lambdaFunction: {
- *     name: 'foo-bar-function',
- *     arn: 'arn:aws:lambda:eu-central-1:123456789012:function:Example',
- *     memoryLimitInMB: 128,
- *     version: '$LATEST',
- *     coldStart: undefined
- *   },
- *   logLevel: 'ERROR',
- *   timestamp: '2021-03-10T18:47:04.724Z',
- *   logger: {
- *     name: '@aws-lambda-powertools/logger',
- *     version: '0.0.0',
- *     level: 'ERROR',
- *     sampleRateValue: 0.00001
- *   }
- * }
- *
- **/
+lambdaHandler(dummyEvent, dummyContext, () => console.log('Lambda invoked!'));

packages/logger/examples/formatters/CustomLogFormatter.ts

@@ -12,15 +12,15 @@ class CustomLogFormatter extends LogFormatter {
       environment: attributes.environment,
       awsRegion: attributes.awsRegion,
       correlationIds: {
-        awsRequestId: attributes.awsRequestId,
+        awsRequestId: attributes.lambdaContext?.awsRequestId,
         xRayTraceId: attributes.xRayTraceId
       },
       lambdaFunction: {
-        name: attributes.functionName,
-        arn: attributes.invokedFunctionArn,
-        memoryLimitInMB: Number(attributes.memoryLimitInMB),
-        version: attributes.functionVersion,
-        coldStart: attributes.coldStart,
+        name: attributes.lambdaContext?.name,
+        arn: attributes.lambdaContext?.arn,
+        memoryLimitInMB: attributes.lambdaContext?.memoryLimitInMB,
+        version: attributes.lambdaContext?.version,
+        coldStart: attributes.lambdaContext?.coldStart,
       },
       logLevel: attributes.logLevel,
       timestamp: this.formatTimestamp(attributes.timestamp),

packages/logger/examples/hello-world-with-context.ts

@@ -0,0 +1,31 @@
+import { populateEnvironmentVariables } from '../tests/helpers';
+
+// Populate runtime
+populateEnvironmentVariables();
+// Additional runtime variables
+process.env.LOG_LEVEL = 'WARN';
+process.env.POWERTOOLS_SERVICE_NAME = 'hello-world';
+process.env.POWERTOOLS_CONTEXT_ENABLED = 'TRUE';
+
+import * as dummyEvent from '../../../tests/resources/events/custom/hello-world.json';
+import { context as dummyContext } from '../../../tests/resources/contexts/hello-world';
+import { Handler } from 'aws-lambda';
+import { Logger } from '../src';
+
+const logger = new Logger();
+
+const lambdaHandler: Handler = async (event, context) => {
+  logger.addContext(context);
+
+  logger.debug('This is a DEBUG log', { bar: 'baz' });
+  logger.info('This is an INFO log', { bar: 'baz' });
+  logger.warn('This is a WARN log', { bar: 'baz' });
+  logger.error('This is an ERROR log', { bar: 'baz' });
+
+  return {
+    foo: 'bar'
+  };
+
+};
+
+lambdaHandler(dummyEvent, dummyContext, () => console.log('Lambda invoked!'));

packages/logger/examples/hello-world.ts

@@ -1,3 +1,8 @@
+import { populateEnvironmentVariables } from '../tests/helpers';
+
+// Populate runtime
+populateEnvironmentVariables();
+// Additional runtime variables
 process.env.LOG_LEVEL = 'WARN';
 process.env.POWERTOOLS_SERVICE_NAME = 'hello-world';
 
@@ -8,8 +13,7 @@ import { Logger } from '../src';
 
 const logger = new Logger();
 
-const lambdaHandler: Handler = async (event, context) => {
-  logger.addContext(context);
+const lambdaHandler: Handler = async () => {
 
   logger.debug('This is a DEBUG log', { bar: 'baz' });
   logger.info('This is an INFO log', { bar: 'baz' });
@@ -22,66 +26,4 @@ const lambdaHandler: Handler = async (event, context) => {
 
 };
 
-lambdaHandler(dummyEvent, dummyContext, () => {});
-
-/**
- * Logs output:
- *
- * {
- *   sampling_rate: 1,
- *   service: 'hello-world',
- *   xray_trace_id: 'abcdef123456abcdef123456abcdef123456',
- *   cold_start: true,
- *   lambda_function_arn: 'arn:aws:lambda:eu-central-1:123456789012:function:Example',
- *   lambda_function_memory_size: 128,
- *   lambda_function_name: 'foo-bar-function',
- *   aws_request_id: 'c6af9ac6-7b61-11e6-9a41-93e8deadbeef',
- *   message: 'This is a DEBUG log',
- *   timestamp: '2021-03-10T01:42:42.664Z',
- *   level: 'DEBUG',
- *   bar: 'baz'
- * }
- * {
- *   sampling_rate: 1,
- *   service: 'hello-world',
- *   xray_trace_id: 'abcdef123456abcdef123456abcdef123456',
- *   cold_start: true,
- *   lambda_function_arn: 'arn:aws:lambda:eu-central-1:123456789012:function:Example',
- *   lambda_function_memory_size: 128,
- *   lambda_function_name: 'foo-bar-function',
- *   aws_request_id: 'c6af9ac6-7b61-11e6-9a41-93e8deadbeef',
- *   message: 'This is an INFO log',
- *   timestamp: '2021-03-10T01:42:42.667Z',
- *   level: 'INFO',
- *   bar: 'baz'
- * }
- * {
- *   sampling_rate: 1,
- *   service: 'hello-world',
- *   xray_trace_id: 'abcdef123456abcdef123456abcdef123456',
- *   cold_start: true,
- *   lambda_function_arn: 'arn:aws:lambda:eu-central-1:123456789012:function:Example',
- *   lambda_function_memory_size: 128,
- *   lambda_function_name: 'foo-bar-function',
- *   aws_request_id: 'c6af9ac6-7b61-11e6-9a41-93e8deadbeef',
- *   message: 'This is a WARN log',
- *   timestamp: '2021-03-10T01:42:42.667Z',
- *   level: 'WARN',
- *   bar: 'baz'
- * }
- * {
- *   sampling_rate: 1,
- *   service: 'hello-world',
- *   xray_trace_id: 'abcdef123456abcdef123456abcdef123456',
- *   cold_start: true,
- *   lambda_function_arn: 'arn:aws:lambda:eu-central-1:123456789012:function:Example',
- *   lambda_function_memory_size: 128,
- *   lambda_function_name: 'foo-bar-function',
- *   aws_request_id: 'c6af9ac6-7b61-11e6-9a41-93e8deadbeef',
- *   message: 'This is an ERROR log',
- *   timestamp: '2021-03-10T01:42:42.667Z',
- *   level: 'ERROR',
- *   bar: 'baz'
- * }
- *
- **/
+lambdaHandler(dummyEvent, dummyContext, () => console.log('Lambda invoked!'));

packages/logger/package.json

@@ -19,6 +19,7 @@
     "version": "npm run format && git add -A src",
     "postversion": "git push && git push --tags",
     "example:hello-world": "ts-node examples/hello-world.ts",
+    "example:hello-world-with-context": "ts-node examples/hello-world-with-context.ts",
     "example:custom-logger-options": "ts-node examples/custom-logger-options.ts",
     "example:child-logger": "ts-node examples/child-logger.ts"
   },

packages/logger/src/Logger.ts

@@ -5,12 +5,13 @@ import { LogItem } from './log';
 import { cloneDeep, merge } from 'lodash/fp';
 import { ConfigServiceInterface, EnvironmentVariablesService } from './config';
 import {
-  DefaultLoggerAttributes,
   Environment,
+  LoggerData,
   LogAttributes,
   LoggerOptions,
   LogLevel,
-  LogLevelThresholds, UnformattedAttributes,
+  LogLevelThresholds,
+  UnformattedAttributes, LambdaFunctionContext,
 } from '../types';
 import { LogFormatterInterface, PowertoolLogFormatter } from './formatter';
 
@@ -20,10 +21,10 @@ class Logger implements LoggerInterface {
 
   private customConfigService?: ConfigServiceInterface;
 
-  private defaultLoggerAttributes: DefaultLoggerAttributes = {};
-
   private static readonly defaultLogLevel: LogLevel = 'INFO';
 
+  private static readonly defaultSampleRate: number = 1;
+
   private envVarsService?: EnvironmentVariablesService;
 
   private logFormatter?: LogFormatterInterface;
@@ -37,14 +38,30 @@ class Logger implements LoggerInterface {
     'ERROR': 20
   };
 
-  private sampleRateValue?: number;
+  private loggerData: LoggerData = <LoggerData>{};
 
   public constructor(options: LoggerOptions = {}) {
     this.applyOptions(options);
   }
 
   public addContext(context: Context): void {
-    this.addToDefaultLoggerAttributes(context, { isColdStart: Logger.isColdStart() });
+    if (!this.isContextEnabled()) {
+      return;
+    }
+
+    const lambdaContext: LambdaFunctionContext = {
+      arn: context.invokedFunctionArn,
+      awsRequestId: context.awsRequestId,
+      coldStart: Logger.isColdStart(),
+      memoryLimitInMB: Number(context.memoryLimitInMB),
+      name: context.functionName,
+      version: context.functionVersion,
+    };
+
+    this.addToLoggerData({
+      lambdaContext
+    });
+
   }
 
   public createChild(options: LoggerOptions = {}): Logger {
@@ -77,9 +94,9 @@ class Logger implements LoggerInterface {
     this.printLog('WARN', this.createLogItem('WARN', message, attributes).getAttributes());
   }
 
-  private addToDefaultLoggerAttributes(...attributesArray: Array<DefaultLoggerAttributes>): void {
-    attributesArray.forEach((attributes: DefaultLoggerAttributes) => {
-      this.defaultLoggerAttributes = merge(this.getDefaultLoggerAttributes(), attributes);
+  private addToLoggerData(...attributesArray: Array<Partial<LoggerData>>): void {
+    attributesArray.forEach((attributes: Partial<LoggerData>) => {
+      this.loggerData = merge(this.getLoggerData(), attributes);
     });
   }
 
@@ -99,26 +116,23 @@ class Logger implements LoggerInterface {
     this.setLogLevel(logLevel);
     this.setSampleRateValue(sampleRateValue);
     this.setLogFormatter(logFormatter);
-    this.populateDefaultLoggerAttributes(serviceName, environment, customAttributes);
+    this.populateLoggerData(serviceName, environment, customAttributes);
 
     return this;
   }
 
   private createLogItem(logLevel: LogLevel, message: string, customAttributes: LogAttributes = {}): LogItem {
-    this.addToDefaultLoggerAttributes({ logLevel, message, timestamp: new Date() });
+    const unformattedAttributes: UnformattedAttributes = merge({ logLevel, message, timestamp: new Date() }, this.getLoggerData());
 
-    return new LogItem().addAttributes(this.getLogFormatter().format(this.getDefaultLoggerAttributes() as UnformattedAttributes))
+    return new LogItem()
+      .addAttributes(this.getLogFormatter().format(unformattedAttributes))
       .addAttributes(customAttributes);
   }
 
   private getCustomConfigService(): ConfigServiceInterface | undefined {
     return this.customConfigService;
   }
 
-  private getDefaultLoggerAttributes(): DefaultLoggerAttributes {
-    return this.defaultLoggerAttributes;
-  }
-
   private getEnvVarsService(): EnvironmentVariablesService {
     if (!this.envVarsService) {
       this.setEnvVarsService();
@@ -136,25 +150,45 @@ class Logger implements LoggerInterface {
   }
 
   private getLogLevel(): LogLevel {
-    if (!this.logLevel) {
+    if (this.loggerData?.logLevel) {
       this.setLogLevel();
     }
 
     return <LogLevel> this.logLevel;
   }
 
-  private getSampleRateValue(): number | undefined {
-    return this.sampleRateValue;
+  private getLoggerData(): LoggerData {
+    return this.loggerData;
   }
 
-  private populateDefaultLoggerAttributes(serviceName?: string, environment?: Environment, customAttributes: LogAttributes = {}): void {
-    this.addToDefaultLoggerAttributes({
+  private getSampleRateValue(): number {
+    if (!this.loggerData?.sampleRateValue) {
+      this.setSampleRateValue();
+    }
+
+    return <number> this.loggerData?.sampleRateValue;
+  }
+
+  private isContextEnabled(): boolean {
+    return this.getCustomConfigService()?.getIsContextEnabled() === true || this.getEnvVarsService().getIsContextEnabled() === true;
+  }
+
+  private populateLoggerData(serviceName?: string, environment?: Environment, customAttributes: LogAttributes = {}): void {
+
+    if (this.isContextEnabled()) {
+      this.addToLoggerData( {
+        lambdaContext: {
+          coldStart: Logger.isColdStart(),
+          memoryLimitInMB: this.getEnvVarsService().getFunctionMemory(),
+          name: this.getEnvVarsService().getFunctionName(),
+          version:this.getEnvVarsService().getFunctionVersion(),
+        }
+      });
+    }
+
+    this.addToLoggerData({
       awsRegion: this.getEnvVarsService().getAwsRegion(),
       environment: environment || this.getCustomConfigService()?.getCurrentEnvironment() || this.getEnvVarsService().getCurrentEnvironment(),
-      functionName: this.getEnvVarsService().getFunctionName(),
-      functionVersion: this.getEnvVarsService().getFunctionVersion(),
-      logLevel: this.getLogLevel(),
-      memoryLimitInMB: this.getEnvVarsService().getFunctionMemory(),
       sampleRateValue: this.getSampleRateValue(),
       serviceName: serviceName || this.getCustomConfigService()?.getServiceName() || this.getEnvVarsService().getServiceName(),
       xRayTraceId: this.getEnvVarsService().getXrayTraceId(),
@@ -184,11 +218,13 @@ class Logger implements LoggerInterface {
   }
 
   private setLogLevel(logLevel?: LogLevel): void {
-    this.logLevel = (logLevel || this.getCustomConfigService()?.getLogLevel() || this.getEnvVarsService().getLogLevel() || Logger.defaultLogLevel) as LogLevel;
+    this.logLevel = (logLevel || this.getCustomConfigService()?.getLogLevel() || this.getEnvVarsService().getLogLevel()
+      || Logger.defaultLogLevel) as LogLevel;
   }
 
   private setSampleRateValue(sampleRateValue?: number): void {
-    this.sampleRateValue = sampleRateValue || this.getCustomConfigService()?.getSampleRateValue() || this.getEnvVarsService().getSampleRateValue();
+    this.loggerData.sampleRateValue = sampleRateValue || this.getCustomConfigService()?.getSampleRateValue()
+      || this.getEnvVarsService().getSampleRateValue() || Logger.defaultSampleRate;
   }
 
   private shouldPrint(logLevel: LogLevel): boolean {