[FEATURE REQUEST] Provide context per class

Is your feature request related to a problem? Please describe.

I’m using globally imported pino logger module. Every time when I make a log line I would like to know from which class the log was created. Right now, I have to include the context manually. Like the following lines in the README.md: https://github.com/iamolegga/nestjs-pino/blob/master/README.md#L56 https://github.com/iamolegga/nestjs-pino/blob/master/README.md#L72

Currently, we can set base context per configuration of logger module. That’s too broad for my use case. Even if I migrate my logger module import from global to per module import, I’d prefer finer level of granularity in defining base context. (But not as fine as log line 😃 )

Describe the solution you’d like

I would like to write log lines using injected logger without manually providing class context on each log line. I’d like the context to be either set up once per class (injection) or somehow dynamically configured to use class name (or whatever else) per module configuration.

I’m probably off on these, but my superficial suggestions would be:

• configure the module with an option to always fork a child logger for each class it’s injected into OR
• expose child functionality so we can fork (child) a logger manually. Then we could set it up with context in each class constructor (or wherever we deem useful)

[iamolegga]

I would agree with @trymoto because I would prefer to KISS, and actually get rid of all not necessary extra API, and make library users not to remember complex API with this @PinoLogger.Inject or InjectLogger.

I think that injecting it as regular service is more preferred, and makes setting context optional, so PinoLogger users may use it without required context setting, and use it just like pino and not thinking about context property, that actually came up from LoggerService 🤔

[iamolegga]

Hey, I’ve almost done with it, but just need add tests and docs, so I guess it will be shipped in several hours. The api of new PinoLogger will be like:

import { Controller, Get } from "@nestjs/common";
import { MyService } from "./my.service";
import { PinoLogger } from "../src/PinoLogger";

@Controller()
export class AppController {
  constructor(
    private readonly myService: MyService,
    @PinoLogger.Inject("MY_CONTEXT_VALUE") private readonly logger: PinoLogger
  ) {}

  @Get()
  getHello(): string {
    this.logger.info("getHello(%O)", arguments); // <-- "info" and  "trace" methods (like pino has) as opposite to "log" and "verbose" (like LoggerService has)
    return `Hello ${this.myService.getWorld()}`;
  }
}

And I’m still in doubt, which varian of injection and setting context is better:

1. via @PinoLogger.Inject like above or
2. via normal injection and manually setting context:

import { Controller, Get } from "@nestjs/common";
import { MyService } from "./my.service";
import { PinoLogger } from "../src/PinoLogger";

@Controller()
export class AppController {
  constructor(
    private readonly myService: MyService,
    private readonly logger: PinoLogger
  ) {
    logger.context = "MY_CONTEXT_VALUE";
  }

  @Get()
  getHello(): string {
    this.logger.info("getHello(%O)", arguments); // <-- "info" and  "trace" methods (like pino has) as opposite to "log" and "verbose" (like LoggerService has)
    return `Hello ${this.myService.getWorld()}`;
  }
}

@maricn @valerio-battaglia what do you think?