Merge pull request #1131 from hedgedoc/improve/logging

src/api/private/tokens/tokens.controller.spec.ts

@@ -12,6 +12,8 @@ import { Identity } from '../../../users/identity.entity';
 import { User } from '../../../users/user.entity';
 import { AuthToken } from '../../../auth/auth-token.entity';
 import { AuthModule } from '../../../auth/auth.module';
+import { ConfigModule } from '@nestjs/config';
+import appConfigMock from '../../../config/mock/app.config.mock';
 
 describe('TokensController', () => {
   let controller: TokensController;
@@ -19,7 +21,14 @@ describe('TokensController', () => {
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       controllers: [TokensController],
-      imports: [LoggerModule, AuthModule],
+      imports: [
+        ConfigModule.forRoot({
+          isGlobal: true,
+          load: [appConfigMock],
+        }),
+        LoggerModule,
+        AuthModule,
+      ],
     })
       .overrideProvider(getRepositoryToken(User))
       .useValue({})

src/auth/auth.service.spec.ts

@@ -15,6 +15,8 @@ import { LoggerModule } from '../logger/logger.module';
 import { AuthToken } from './auth-token.entity';
 import { NotInDBError, TokenNotValidError } from '../errors/errors';
 import { Repository } from 'typeorm';
+import { ConfigModule } from '@nestjs/config';
+import appConfigMock from '../config/mock/app.config.mock';
 
 describe('AuthService', () => {
   let service: AuthService;
@@ -32,7 +34,15 @@ describe('AuthService', () => {
           useClass: Repository,
         },
       ],
-      imports: [PassportModule, UsersModule, LoggerModule],
+      imports: [
+        ConfigModule.forRoot({
+          isGlobal: true,
+          load: [appConfigMock],
+        }),
+        PassportModule,
+        UsersModule,
+        LoggerModule,
+      ],
     })
       .overrideProvider(getRepositoryToken(Identity))
       .useValue({})

src/config/utils.spec.ts

@@ -5,9 +5,11 @@
  */
 
 import {
+  needToLog,
   replaceAuthErrorsWithEnvironmentVariables,
   toArrayConfig,
 } from './utils';
+import { Loglevel } from './loglevel.enum';
 
 describe('config utils', () => {
   describe('toArrayConfig', () => {
@@ -40,4 +42,46 @@ describe('config utils', () => {
       ).toEqual('"HD_AUTH_GITLAB_test_SCOPE');
     });
   });
+  describe('needToLog', () => {
+    it('currentLevel ERROR', () => {
+      const currentLevel = Loglevel.ERROR;
+      expect(needToLog(currentLevel, Loglevel.ERROR)).toBeTruthy();
+      expect(needToLog(currentLevel, Loglevel.WARN)).toBeFalsy();
+      expect(needToLog(currentLevel, Loglevel.INFO)).toBeFalsy();
+      expect(needToLog(currentLevel, Loglevel.DEBUG)).toBeFalsy();
+      expect(needToLog(currentLevel, Loglevel.TRACE)).toBeFalsy();
+    });
+    it('currentLevel WARN', () => {
+      const currentLevel = Loglevel.WARN;
+      expect(needToLog(currentLevel, Loglevel.ERROR)).toBeTruthy();
+      expect(needToLog(currentLevel, Loglevel.WARN)).toBeTruthy();
+      expect(needToLog(currentLevel, Loglevel.INFO)).toBeFalsy();
+      expect(needToLog(currentLevel, Loglevel.DEBUG)).toBeFalsy();
+      expect(needToLog(currentLevel, Loglevel.TRACE)).toBeFalsy();
+    });
+    it('currentLevel INFO', () => {
+      const currentLevel = Loglevel.INFO;
+      expect(needToLog(currentLevel, Loglevel.ERROR)).toBeTruthy();
+      expect(needToLog(currentLevel, Loglevel.WARN)).toBeTruthy();
+      expect(needToLog(currentLevel, Loglevel.INFO)).toBeTruthy();
+      expect(needToLog(currentLevel, Loglevel.DEBUG)).toBeFalsy();
+      expect(needToLog(currentLevel, Loglevel.TRACE)).toBeFalsy();
+    });
+    it('currentLevel DEBUG', () => {
+      const currentLevel = Loglevel.DEBUG;
+      expect(needToLog(currentLevel, Loglevel.ERROR)).toBeTruthy();
+      expect(needToLog(currentLevel, Loglevel.WARN)).toBeTruthy();
+      expect(needToLog(currentLevel, Loglevel.INFO)).toBeTruthy();
+      expect(needToLog(currentLevel, Loglevel.DEBUG)).toBeTruthy();
+      expect(needToLog(currentLevel, Loglevel.TRACE)).toBeFalsy();
+    });
+    it('currentLevel TRACE', () => {
+      const currentLevel = Loglevel.TRACE;
+      expect(needToLog(currentLevel, Loglevel.ERROR)).toBeTruthy();
+      expect(needToLog(currentLevel, Loglevel.WARN)).toBeTruthy();
+      expect(needToLog(currentLevel, Loglevel.INFO)).toBeTruthy();
+      expect(needToLog(currentLevel, Loglevel.DEBUG)).toBeTruthy();
+      expect(needToLog(currentLevel, Loglevel.TRACE)).toBeTruthy();
+    });
+  });
 });

src/config/utils.ts

@@ -4,6 +4,8 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
+import { Loglevel } from './loglevel.enum';
+
 export function toArrayConfig(configValue: string, separator = ','): string[] {
   if (!configValue) {
     return [];
@@ -87,3 +89,27 @@ export function replaceAuthErrorsWithEnvironmentVariables(
   message = message.replace('.accessRole', '_ACCESS_ROLE');
   return message;
 }
+
+export function needToLog(
+  currentLoglevel: Loglevel,
+  requestedLoglevel: Loglevel,
+): boolean {
+  const current = transformLoglevelToInt(currentLoglevel);
+  const requested = transformLoglevelToInt(requestedLoglevel);
+  return current >= requested;
+}
+
+function transformLoglevelToInt(loglevel: Loglevel): number {
+  switch (loglevel) {
+    case Loglevel.TRACE:
+      return 5;
+    case Loglevel.DEBUG:
+      return 4;
+    case Loglevel.INFO:
+      return 3;
+    case Loglevel.WARN:
+      return 2;
+    case Loglevel.ERROR:
+      return 1;
+  }
+}

src/groups/groups.service.spec.ts

@@ -11,6 +11,8 @@ import { Repository } from 'typeorm';
 import { Group } from './group.entity';
 import { NotInDBError } from '../errors/errors';
 import { LoggerModule } from '../logger/logger.module';
+import { ConfigModule } from '@nestjs/config';
+import appConfigMock from '../config/mock/app.config.mock';
 
 describe('GroupsService', () => {
   let service: GroupsService;
@@ -26,7 +28,13 @@ describe('GroupsService', () => {
           useClass: Repository,
         },
       ],
-      imports: [LoggerModule],
+      imports: [
+        ConfigModule.forRoot({
+          isGlobal: true,
+          load: [appConfigMock],
+        }),
+        LoggerModule,
+      ],
     }).compile();
 
     service = module.get<GroupsService>(GroupsService);

src/logger/console-logger.service.ts

@@ -4,17 +4,24 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import { Injectable, Optional, Scope } from '@nestjs/common';
+import { Inject, Injectable, Optional, Scope } from '@nestjs/common';
 import { isObject } from '@nestjs/common/utils/shared.utils';
 import clc = require('cli-color');
 import DateTimeFormatOptions = Intl.DateTimeFormatOptions;
+import appConfiguration, { AppConfig } from '../config/app.config';
+import { Loglevel } from '../config/loglevel.enum';
+import { needToLog } from '../config/utils';
 
 @Injectable({ scope: Scope.TRANSIENT })
 export class ConsoleLoggerService {
   private classContext: string;
   private lastTimestamp: number;
 
-  constructor(@Optional() context?: string) {
+  constructor(
+    @Inject(appConfiguration.KEY)
+    private appConfig: AppConfig,
+    @Optional() context?: string,
+  ) {
     this.classContext = context;
   }
 
@@ -29,47 +36,58 @@ export class ConsoleLoggerService {
       this.makeContextString(functionContext),
       false,
     );
-    this.printStackTrace(trace);
+    ConsoleLoggerService.printStackTrace(trace);
   }
 
   log(message: unknown, functionContext?: string): void {
-    this.printMessage(
+    if (needToLog(this.appConfig.loglevel, Loglevel.INFO)) {
-      message,
+      this.printMessage(
-      clc.green,
+        message,
-      this.makeContextString(functionContext),
+        clc.green,
-      false,
+        this.makeContextString(functionContext),
-    );
+        false,
+      );
+    }
   }
 
   warn(message: unknown, functionContext?: string): void {
-    this.printMessage(
+    if (needToLog(this.appConfig.loglevel, Loglevel.WARN)) {
-      message,
+      this.printMessage(
-      clc.yellow,
+        message,
-      this.makeContextString(functionContext),
+        clc.yellow,
-      false,
+        this.makeContextString(functionContext),
-    );
+        false,
+      );
+    }
   }
 
   debug(message: unknown, functionContext?: string): void {
-    this.printMessage(
+    if (needToLog(this.appConfig.loglevel, Loglevel.DEBUG)) {
-      message,
+      this.printMessage(
-      clc.magentaBright,
+        message,
-      this.makeContextString(functionContext),
+        clc.magentaBright,
-      false,
+        this.makeContextString(functionContext),
-    );
+        false,
+      );
+    }
   }
 
   verbose(message: unknown, functionContext?: string): void {
-    this.printMessage(
+    if (needToLog(this.appConfig.loglevel, Loglevel.TRACE)) {
-      message,
+      this.printMessage(
-      clc.cyanBright,
+        message,
-      this.makeContextString(functionContext),
+        clc.cyanBright,
-      false,
+        this.makeContextString(functionContext),
-    );
+        false,
+      );
+    }
   }
 
   private makeContextString(functionContext: string): string {
     let context = this.classContext;
+    if (!context) {
+      context = 'HedgeDoc';
+    }
     if (functionContext) {
       context += '.' + functionContext + '()';
     }
@@ -117,7 +135,7 @@ export class ConsoleLoggerService {
     return result;
   }
 
-  private printStackTrace(trace: string): void {
+  private static printStackTrace(trace: string): void {
     if (!trace) {
       return;
     }

src/logger/logger.module.ts

@@ -6,10 +6,9 @@
 
 import { Module } from '@nestjs/common';
 import { ConsoleLoggerService } from './console-logger.service';
-import { NestConsoleLoggerService } from './nest-console-logger.service';
 
 @Module({
-  providers: [ConsoleLoggerService, NestConsoleLoggerService],
+  providers: [ConsoleLoggerService],
-  exports: [ConsoleLoggerService, NestConsoleLoggerService],
+  exports: [ConsoleLoggerService],
 })
 export class LoggerModule {}

src/logger/nest-console-logger.service.ts

@@ -1,39 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021 The HedgeDoc developers (see AUTHORS file)
- *
- * SPDX-License-Identifier: AGPL-3.0-only
- */
-
-import { Injectable, LoggerService } from '@nestjs/common';
-import { ConsoleLoggerService } from './console-logger.service';
-
-Injectable();
-
-export class NestConsoleLoggerService implements LoggerService {
-  private consoleLoggerService = new ConsoleLoggerService();
-
-  debug(message: unknown, context?: string): void {
-    this.consoleLoggerService.setContext(context);
-    this.consoleLoggerService.debug(message);
-  }
-
-  error(message: unknown, trace?: string, context?: string): void {
-    this.consoleLoggerService.setContext(context);
-    this.consoleLoggerService.error(message, trace);
-  }
-
-  log(message: unknown, context?: string): void {
-    this.consoleLoggerService.setContext(context);
-    this.consoleLoggerService.log(message);
-  }
-
-  verbose(message: unknown, context?: string): void {
-    this.consoleLoggerService.setContext(context);
-    this.consoleLoggerService.verbose(message);
-  }
-
-  warn(message: unknown, context?: string): void {
-    this.consoleLoggerService.setContext(context);
-    this.consoleLoggerService.warn(message);
-  }
-}

src/main.ts

@@ -4,20 +4,22 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import { ValidationPipe } from '@nestjs/common';
+import { LogLevel, ValidationPipe } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { NestFactory } from '@nestjs/core';
 import { NestExpressApplication } from '@nestjs/platform-express';
 import { AppModule } from './app.module';
 import { AppConfig } from './config/app.config';
 import { MediaConfig } from './config/media.config';
-import { NestConsoleLoggerService } from './logger/nest-console-logger.service';
 import { setupPrivateApiDocs, setupPublicApiDocs } from './utils/swagger';
 import { BackendType } from './media/backends/backend-type.enum';
+import { ConsoleLoggerService } from './logger/console-logger.service';
 
 async function bootstrap(): Promise<void> {
-  const app = await NestFactory.create<NestExpressApplication>(AppModule);
+  const app = await NestFactory.create<NestExpressApplication>(AppModule, {
-  const logger = await app.resolve(NestConsoleLoggerService);
+    logger: ['error', 'warn', 'log'] as LogLevel[],
+  });
+  const logger = await app.resolve(ConsoleLoggerService);
   logger.log('Switching logger', 'AppBootstrap');
   app.useLogger(logger);
   const configService = app.get(ConfigService);
@@ -25,8 +27,16 @@ async function bootstrap(): Promise<void> {
   const mediaConfig = configService.get<MediaConfig>('mediaConfig');
 
   setupPublicApiDocs(app);
+  logger.log(
+    `Serving OpenAPI docs for public api under '/apidoc'`,
+    'AppBootstrap',
+  );
   if (process.env.NODE_ENV === 'development') {
     setupPrivateApiDocs(app);
+    logger.log(
+      `Serving OpenAPI docs for private api under '/private/apidoc'`,
+      'AppBootstrap',
+    );
   }
 
   app.useGlobalPipes(
@@ -38,7 +48,7 @@ async function bootstrap(): Promise<void> {
   );
   if (mediaConfig.backend.use === BackendType.FILESYSTEM) {
     logger.log(
-      `Serving ${mediaConfig.backend.filesystem.uploadPath} under 'uploads/'`,
+      `Serving the local folder '${mediaConfig.backend.filesystem.uploadPath}' under '/uploads'`,
       'AppBootstrap',
     );
     app.useStaticAssets(mediaConfig.backend.filesystem.uploadPath, {

src/users/users.service.spec.ts

@@ -9,6 +9,8 @@ import { getRepositoryToken } from '@nestjs/typeorm';
 import { LoggerModule } from '../logger/logger.module';
 import { User } from './user.entity';
 import { UsersService } from './users.service';
+import { ConfigModule } from '@nestjs/config';
+import appConfigMock from '../config/mock/app.config.mock';
 
 describe('UsersService', () => {
   let service: UsersService;
@@ -22,7 +24,13 @@ describe('UsersService', () => {
           useValue: {},
         },
       ],
-      imports: [LoggerModule],
+      imports: [
+        ConfigModule.forRoot({
+          isGlobal: true,
+          load: [appConfigMock],
+        }),
+        LoggerModule,
+      ],
     })
       .overrideProvider(getRepositoryToken(User))
       .useValue({})

test/private-api/media.e2e-spec.ts

@@ -17,7 +17,6 @@ import customizationConfigMock from '../../src/config/mock/customization.config.
 import externalConfigMock from '../../src/config/mock/external-services.config.mock';
 import { GroupsModule } from '../../src/groups/groups.module';
 import { LoggerModule } from '../../src/logger/logger.module';
-import { NestConsoleLoggerService } from '../../src/logger/nest-console-logger.service';
 import { MediaModule } from '../../src/media/media.module';
 import { NotesModule } from '../../src/notes/notes.module';
 import { NotesService } from '../../src/notes/notes.service';
@@ -26,6 +25,7 @@ import { AuthModule } from '../../src/auth/auth.module';
 import { join } from 'path';
 import { PrivateApiModule } from '../../src/api/private/private-api.module';
 import { UsersService } from '../../src/users/users.service';
+import { ConsoleLoggerService } from '../../src/logger/console-logger.service';
 
 describe('Media', () => {
   let app: NestExpressApplication;
@@ -67,7 +67,7 @@ describe('Media', () => {
       prefix: '/uploads',
     });
     await app.init();
-    const logger = await app.resolve(NestConsoleLoggerService);
+    const logger = await app.resolve(ConsoleLoggerService);
     logger.log('Switching logger', 'AppBootstrap');
     app.useLogger(logger);
     const notesService: NotesService = moduleRef.get('NotesService');

test/public-api/media.e2e-spec.ts

@@ -15,7 +15,6 @@ import mediaConfigMock from '../../src/config/mock/media.config.mock';
 import appConfigMock from '../../src/config/mock/app.config.mock';
 import { GroupsModule } from '../../src/groups/groups.module';
 import { LoggerModule } from '../../src/logger/logger.module';
-import { NestConsoleLoggerService } from '../../src/logger/nest-console-logger.service';
 import { MediaModule } from '../../src/media/media.module';
 import { MediaService } from '../../src/media/media.service';
 import { NotesModule } from '../../src/notes/notes.module';
@@ -25,6 +24,7 @@ import { AuthModule } from '../../src/auth/auth.module';
 import { TokenAuthGuard } from '../../src/auth/token-auth.guard';
 import { MockAuthGuard } from '../../src/auth/mock-auth.guard';
 import { join } from 'path';
+import { ConsoleLoggerService } from '../../src/logger/console-logger.service';
 
 describe('Media', () => {
   let app: NestExpressApplication;
@@ -64,7 +64,7 @@ describe('Media', () => {
       prefix: '/uploads',
     });
     await app.init();
-    const logger = await app.resolve(NestConsoleLoggerService);
+    const logger = await app.resolve(ConsoleLoggerService);
     logger.log('Switching logger', 'AppBootstrap');
     app.useLogger(logger);
     const notesService: NotesService = moduleRef.get('NotesService');