Intended best practices to avoid cross-cutting concerns

[codyfrisch]

Okay this is probably 100% due to my lack of experience with TS.

But is there an intended pattern with the powertools to provide access to an instance of the logger which contains the injected context (and will clear state) that I can use in the classes called by my handler?

At this point I'm just passing logger as a parameter when instantiating the classes, and calling this.logger throughout. But it means I have to pass the logger to all of my classes to use it.

I just want to make sure in my own inexperience, I'm not missing "a better way" using decorators thats already a part of the package. (beyond on the handler to inject context, event, clearstate, etc.)

[dreamorosi]

Hi @codyfrisch, thank you for starting this discussion!

I understand that you'd like to reuse the same instance of logger throughout your different classes/functions, and ideally this instance should have already been injected with the context.

A pattern that we recommend would be to have your logger object instantiated in a shared file that can be imported throughout your codebase:

For instance, have a file called powertools.ts:

import { Logger } from '@aws-lambda-powertools/logger';

export const logger = new Logger();

Then, in your main index.ts file, have your class:

import { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from 'aws-lambda';
import { logger } from './common/powertools';

class Lambda implements LambdaInterface {
  private someMethod() {
    logger.info('hello from someMethod');
  }

  @logger.injectLambdaContext({ logEvent: true })
  public async handler(event: unknown, context: Context): Promise<unknown> {
    logger.info('hello from handler');
    // ... do things
    this.someMethod();
  }

}

const handlerClass = new Lambda();
export const handler = handlerClass.handler.bind(handlerClass);

Both the logs (the one in handler and the one in someMethod) will have the context info injected since the entry point is always handler in this case.

Now, let's image you have another class/module/file otherUtility.ts:

export class OtherClass {
  public constructor () {}

  public doSomething() {
    // ... do stuff
    logger.info('foo bar');
  }
}

We want to emit a log inside the doSomething method, and we want this log to also have the context info injected.

To do this you have two options:

1. Pass the logger as parameter to the class

otherUtility.ts

export class OtherClass {
-  public constructor () {
+  public constructor (logger: any) {
+    this.logger = logger;
+  }

  public doSomething() {
    // ... do stuff
-    logger.info('foo bar');
+   this.logger.info('foo bar'); 
  }
}

index.ts

import { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from 'aws-lambda';
import { logger } from './common/powertools';
+ import { OtherClass } from './otherUtility.ts';
+
+ const otherClass = new OtherClass(logger);

class Lambda implements LambdaInterface {
  private someMethod() {
    logger.info('hello from someMethod');
  }

  @logger.injectLambdaContext({ logEvent: true })
  public async handler(event: unknown, context: Context): Promise<unknown> {
    logger.info('hello from handler');
    // ... do things
    this.someMethod();
+  otherClass.doSomething()
  }

}

const handlerClass = new Lambda();
export const handler = handlerClass.handler.bind(handlerClass);

In this case, since the entry point is always the handler method, by the time logger is used in the OtherClass class, it'll have been already injected with the context, so the logs emitted will have the context info.

2. Import the shared module in your other class/module/file

otherUtility.ts

+ import { logger } from './common/powertools';
+ 
export class OtherClass {
  public constructor () {}

  public doSomething() {
    // ... do stuff
    logger.info('foo bar');
  }
}

index.ts

import { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from 'aws-lambda';
import { logger } from './common/powertools';
+ import { OtherClass } from './otherUtility.ts';
+
+ const otherClass = new OtherClass();

class Lambda implements LambdaInterface {
  private someMethod() {
    logger.info('hello from someMethod');
  }

  @logger.injectLambdaContext({ logEvent: true })
  public async handler(event: unknown, context: Context): Promise<unknown> {
    logger.info('hello from handler');
    // ... do things
    this.someMethod();
+  otherClass.doSomething()
  }

}

const handlerClass = new Lambda();
export const handler = handlerClass.handler.bind(handlerClass);

In this second option we don't have to pass around the logger instance but we instead import it throughout the code.

Conclusion

As a part of both methods you could also consider creating a child logger. This child logger would inherit all the characteristics and attributes of the original logger instance, but would allow you to independently mutate the child instance (i.e. appending a new attribute) without impacting the main one.

The key aspect of both methods, is that the "context injection" happens around the handler method. This is because the context itself is scoped and inherent to the function handler. With this in mind, if you are trying to use the logger outside of the handler but before the function has been invoked, it's impossible for Logger to have the context info.

Does this help? If not, could you please provide an example of what you're trying to achieve and a bit more details?

[codyfrisch]

Thank you GitHub, I clicked mark as answer after writing a reply but before sending... and poof!

These were the two patterns I was looking at. I was just making sure people who have been doing this longer than I didn't have some magic pattern I just wasn't conceiving.

My plan is to use both, creating a child logger from the imported instance in the class constructor and storing it in a class property. This is because I need to have dozens of the same classes, but each is constructed with different properties - which I want to add as attributes to the child in the constructor.

Thank you for confirming the two patterns I thought of were the most reasonable :)