Feature request: Allow me to set the Logger `console` property

[webdeveric]

Use case

When running my projects locally, I have lots of log messages and it can be hard to see the message I'm looking for. To fix this, I created styled-json-console, which creates a custom Console object that adds syntax highlighting (ANSI colors) to the JSON output.

In order for me to use my custom Console with Powertools Logger, I have to use Reflect.set() to get around the private access modifier.

Example:

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

const logger = new Logger({
  // Options omitted for brevity
});

if (process.env.IS_OFFLINE === "true") {
  const { createConsole } = await import("styled-json-console");

  const styledConsole = createConsole({
    // Options omitted for brevity
  });

  Reflect.set(logger, "console", styledConsole);
}

This works, but I noticed that when doing this, the console.trace() patch gets undone.

powertools-lambda-typescript/packages/logger/src/Logger.ts

Lines 1110 to 1115 in e055e70

	/**
	* Patch `console.trace` to avoid printing a stack trace and aligning with AWS Lambda behavior - see #2902
	*/
	this.console.trace = (message: string, ...optionalParams: unknown[]) => {
	this.console.log(message, ...optionalParams);
	};

It would be nice if there was an official way to do this instead of using Reflect.set().

Solution/User Experience

Add a devConsole option to Logger and use it in setConsole().

Alternative solutions

Remove `private` from `setConsole()` and add an argument for the `Console` I want to use.

Example:


setConsole(devConsole = console): void {
  this.console = isDevMode() ? devConsole : new Console({
    stdout: process.stdout,
    stderr: process.stderr,
  });

  /**
   * Patch `console.trace` to avoid printing a stack trace and aligning with AWS Lambda behavior - see #2902
   */
  this.console.trace = (message: string, ...optionalParams: unknown[]) => {
    this.console.log(message, ...optionalParams);
  };
}

Acknowledgment

• This feature request meets Powertools for AWS Lambda (TypeScript) Tenets
• Should this be considered in other Powertools for AWS Lambda languages? i.e. Python, Java, and .NET

Future readers

Please react with 👍 and your use case to help us understand customer demand.

[dreamorosi]

Hi @webdeveric, thank you for opening the issue and for using Powertools for AWS Lambda Logger.

While I understand the need, I am not inclined to support this feature request as it promotes a use case that we're not officially supporting and goes against our first tenet:

AWS Lambda only. We optimise for AWS Lambda function environments and supported runtimes only. Utilities might work with web frameworks and non-Lambda environments, though they are not officially supported.

Adding a method to modify the console might lead to data loss on AWS Lambda, which is ultimately detrimental to the goal of the project.

I'd be however open to considering changes to how we patch this.console.trace so that it doesn't override the Reflect.set() (if there is even a way to do that) - but only as long as it doesn't modify the existing behavior.

Happy also to hear other maintainers' opinions if they disagree.

[webdeveric]

I didn't see a way to patch this.console.trace easily after calling Reflect.set().

Would you be open to something like this example?

It maintains the current behavior and allows subclasses greater flexibility to do what they need.

class Logger {
  protected getConsole(): Console {
    return isDevMode()
      ? console
      : new Console({
          stdout: process.stdout,
          stderr: process.stderr,
        });
  }

  protected patchConsole(): void {
    if (this.console) {
      this.console.trace = (message: string, ...optionalParams: unknown[]) => {
        this.console.log(message, ...optionalParams);
      };
    }
  }

  private setConsole(): void {
    this.console = this.getConsole();
    this.patchConsole();
  }
}

Subclass:

class MyLogger extends Logger {
  override getConsole(): Console {
    // These logs be in a local terminal only and will never get sent to CloudWatch.
    if (process.env.IS_OFFLINE === "true") {
      return createConsole({
        // my settings
      });
    }

    return super.getConsole();
  }
}

[dreamorosi]

Hi @webdeveric,

After investigating this thoroughly, I found that you can achieve exactly what you're looking for today using class extension, without requiring any changes to the Logger API or internals.

Here's a working solution that I tested using your package and the example in your repo:

import { Logger } from '@aws-lambda-powertools/logger';
import type { ConstructorOptions } from '@aws-lambda-powertools/logger/types';
import { createConsole } from 'styled-json-console';
class DevLogger extends Logger {
  constructor(options?: ConstructorOptions) {
    super(options);
    if (process.env.NODE_ENV === 'development') {
      const customConsole = createConsole({
        // Your styled-json-console configuration here
        inspectOptions: {
          depth: null,
          colors: true,
        },
        json: [{
          space: 2,
          style: {
            bracket: ['white'],
            quoteKey: ['cyan'],
            quoteString: ['green'],
            key: ['cyan'],
            string: ['green'],
            number: ['yellowBright'],
            boolean: ['blueBright'],
            null: ['redBright'],
          },
        }],
      });
      // Important: Apply the same trace patch that Logger uses for AWS Lambda compatibility
      customConsole.trace = (message: string, ...optionalParams: unknown[]) => {
        customConsole.log(message, ...optionalParams);
      };
      (this as any).console = customConsole;
    }
  }
}
// Use your custom logger
const logger = new DevLogger({
  serviceName: 'my-service',
  logLevel: 'debug',
});

This approach, while not particularly ergonomic, works today without waiting for API changes.

At this stage, our focus is to preserve AWS Lambda compatibility so making changes to the internals to support a local-only use case is out of scope I am afraid. The class extension pattern is the recommended approach for this type of customization in Logger.

The manual trace patch is necessary because as you've noticed Logger patches console.trace() to align with AWS Lambda's runtime behavior. When you override the console, you need to reapply this patch to maintain compatibility - assuming your code uses logger.trace() at all - otherwise it'll work without.

Given that this fully addresses your use case through existing Logger capabilities, I'm inclined to close this issue as the functionality is already available.

[github-actions]

This issue has not received a response in 2 weeks. If you still think there is a problem, please leave a comment to avoid the issue from automatically closing.