How to disable or control log levels used by library?

[ermurri]

Hi @nartc, how can we control or disable the usage of console from the library? I'm using a NestJS app, and it completely bypasses all of my logging and is making things quite noisy. It would be great if you could control this via an environment variable or could hook it into the NestJS logging framework.

For example, at every app startup, I see something like this:

[12:26:20 PM] Found 0 errors. Watching for file changes.

Debugger listening on ws://127.0.0.1:9229/0239bc27-8069-4d3c-9714-ba0f662513d2
For help, see: https://nodejs.org/en/docs/inspector

Cannot determine type metadata of "xxx" on class xxxDto.
"xxx" metadata has been skipped.
Manually provide the "type" metadata to prevent unexpected behavior.

....... lots of similar messages as above .....

[Nest] 90086  - 06/22/2022, 12:26:22 PM     LOG [NestFactory] Starting Nest application...
[Nest] 90086  - 06/22/2022, 12:26:22 PM     LOG [InstanceLoader] AutomapperModule dependencies initialized +45ms

It also shows up during tests, etc. It's quite noisy, I like having the logs there for troubleshooting but don't want this going into other environments, and would like to disable it/control it. Using the native console in the framework is not ideal when importing this into apps. This is running before the Nest app initializes.

I would prefer being able to see this voluntarily by enabling a log level or by being able to pipe these log messages to my Nest logger, etc.

I attempted to leverage the ErrorHandler interface and the registration in Nest, but it doesn't seem to work or hit the error.

export class AutoMapperErrorHandler implements ErrorHandler {
  handle(error: unknown): void {
    if (error) return;
  }
}

In Nest module imports:

    AutomapperModule.forRoot({
      strategyInitializer: classes(),
      errorHandler: new AutoMapperErrorHandler(),
    }),

It'd be great if you could pass a logger to this configuration in the imports or inject your logger to the ErrorHandler or something.

If this is already possible, can you please update the documentation? If not, can you please consider adding this to your roadmap?

Thank you!

[nartc]

Hm...this is tricky because those logs are in the @AutoMap decorator which runs pretty early on and not coupled with the forRoot() initialization options. I'll have to think about this as I don't know off top of my head how to accept customization for the logger in the decorator without making the decorator accept a Logger implementation. If you have any suggestions, I'm all ears

[nartc]

That could work. Thanks!

[nartc]

@ermurri In v8.5.0, I added a AutoMapperLogger class that can be configured via AutoMapperLogger.configure(). However, one huge caveat is that you'd need to call the configure() function AS SOON AS POSSIBLE. In a NestJS app, this can be the top of app.module.ts. This needs to be invoked BEFORE the decorators (@AutoMap()) is invoked.

I cannot use the Environment Variable approach because that won't work on the browser side as AutoMapper also supports the web platform. If this is too awkward to use, I can consider adding environment variable for nodejs users.

Try it out and let me know. Thanks

[ermurri]

thanks, I will take a look and let you know how it works out!

[ermurri]

I took a look, is there any particular reason that for the AutoMapperLogger you created for Nest specifically, is there any particular reason why you didn't make your logger extend from the default Nest logger classes or allowing injecting a Nest logger that we can control (see docs)? Also, it's not really staying within the conventions of Nest to force people to register your static instance before everything else happens. It'd be much better to stick with how Nest works if you're going to add Nest integrations.

For example, in my project, I have already wrapped AutoMapper inside of my own Mapper module, for the sake of simplicity, it looks like this:

import { Module } from '@nestjs/common';
import { LoggerModule } from '$/common/logging/LoggerModule';
import { CustomLogger } from '$/common/logging/providers/CustomLogger';
import { AutoMapperErrorHandler } from '$/common/mapping/AutoMapperErrorHandler';
import { MapperConstants } from '$/common/mapping/MapperConstants';
import { classes } from '@automapper/classes';
import { createMapper, Mapper } from '@automapper/core';

@Module({
  imports: [LoggerModule],
  providers: [
    LoggerModule,
    {
      provide: MapperConstants.MapperClassProvider,
      inject: [CustomLogger],
      useFactory: (logger: CustomLogger): Mapper => {
        logger.setContext(MapperModule.name);
        return createMapper({
          strategyInitializer: classes(),
          errorHandler: new AutoMapperErrorHandler(logger),
        });
      },
    },
  ],
  exports: [MapperConstants.MapperClassProvider],
})
export class MapperModule {}

And I import the MapperModule where I need to use it in other modules, app start, wherever.

It would be much more consistent with Nest app development if you allowed configuring and injecting your mapper more like this:

import { Module } from '@nestjs/common';
import { LoggerModule } from '$/common/logging/LoggerModule';
import { CustomLogger } from '$/common/logging/providers/CustomLogger';
import { AutoMapperErrorHandler } from '$/common/mapping/AutoMapperErrorHandler';
import { MapperConstants } from '$/common/mapping/MapperConstants';
import { classes } from '@automapper/classes';
import { AutoMapperLogger, createMapper, Mapper } from '@automapper/core';

@Module({
  imports: [LoggerModule],
  providers: [
    LoggerModule,
    {
      provide: MapperConstants.MapperClassProvider,
      inject: [CustomLogger],
      useFactory: (logger: CustomLogger): Mapper => {
        logger.setContext(MapperModule.name);

        AutoMapperLogger.configure({
          log: (message) => logger.log(message),
          info: (message) => logger.debug(message),
          warn: (message) => logger.warn(message),
          error: (message) => logger.error(message),
        });
        AutoMapperLogger.info('AutoMapperLogger configured');
        AutoMapperLogger.info(`Initializing default Entity<=> DTO class mapper...`);

        return createMapper({
          strategyInitializer: classes(),
          errorHandler: new AutoMapperErrorHandler(logger),
        });
      },
    },
  ],
  exports: [MapperConstants.MapperClassProvider],
})
export class MapperModule {}

I have tried the approach above but it doesn't work, because as you said, it must log before everything else happens, which isn't a very clean pattern, IMHO. I'm not sure I want to implement the logger the way you have done it because I want to use my own or a Nest logger, which can only occur after the Nest app has been created at app startup. You need to delay the binding of your internal logger to the console or provide a way to override it after app startup for your logger implementation to make sense in a Nest context.

Alternatively, you could possibly update your AutoMapperLogger.configure({...}) function to accept a Nest logger.

[nartc]

It is tricky because at the core, AutoMapper is an isomorphic library which means it runs the same on the browser as the server. If I were only to target NodeJS, then process.env would have been enough to configure the internal logger.

The trickiest part is the log (that you're looking to suppress) is inside of a TypeScript decorator (@AutoMap) which means that we need to make sure the Logger is initialized (and overridden) BEFORE the decorators are run.

If you have an implementation that works for NestJS, feel free to submit a PR and we can discuss further.