在调试级别写日志最合理的地方在哪里？

Question

My team and I are lost in deep thoughts for a couple of days to figure out the right place for writing a debug-level log during development.

We're using winston and winston-daily-rotate-file to decouple parts of the logging process, and nest-winston , a nest module wrapper for winston logger.

We have decided to create a flexible custom logger as a service by extending built-in Logger class.

@Injectable()
export class LoggerService extends Logger {
  constructor(
    @Inject('winston')
    private readonly logger: winston.Logger,
  ) { super(); }

 info(message: string, context?: string): void {
   this.logger.info(message, { context });
   super.log(message, context);
  }

 debug(message: string, context?: string): void {
   // To delegate the call to the parent class, no winston used.
   super.debug(message, context);
  }

 error(message: string, trace: string, context?: string): void {
   this.logger.error(message, { context });
   super.error(message, trace, context);
  }
}

As you may have noticed from a method debug() , the storage device ( Transports ) has not configured at debug level on purpose. We want them to be printed out through the console only in development.

Now we could use our LoggerService from anywhere in the same context. For example,

@Controller('users')
export class UsersController {
  constructor(private readonly logger: LoggerService) {}

}

@Injectable()
export class UsersService {
  constructor(private readonly logger: LoggerService) {}

  // Inside a method, debug some logic.
  this.logger.debug(message, UsersService.name);
}

The approach looks fine at a glance, but it could become very messy when the code overused by elsewhere.

For this reason, we thought to have a place where dealing with a debugging process in one shared spot and came up with an idea to let the interceptors handle the work.

import { LoggerService } from '../../logger/logger.service';

@Injectable()
export class DebuggingInterceptor implements NestInterceptor {
  constructor(private readonly logger: LoggerService) {}

  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const ctx = `${context.getClass().name} ➜ ${context.getHandler().name}()`;

    return next
      .handle()
      .pipe(
        tap((response) => {
          if (process.env.NODE_ENV === 'development') {
            this.logger.debug(response, ctx);
          }
        }),
      );
  }
}

Before printing out the debug log, checking the environment whether it's in development or not looks a bit ugly to me.

I'm afraid that what if the approach of using an interceptor above might be completely wrong?

How can I fix this issue in a better way?

Answer 1

I think the approach of using an interceptor is fine. If you don't like the idea of checking the environment in the interceptor you could always check it in the LoggerService class to decide whether or not to call the super.debug() method or not, that way you can just call this.logger.debug(response, ctx) .

As a side note, I'm working on my own version of the overwritten logger and working out the kinks of injecting the class name into the logger so that the context is set in the logger and used from there, but that's taking some time to work with. Just a thought to another idea.