NestJSログ設計 - LoggerServiceでアプリケーションログを構造化する

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// src/users/users.service.ts
import { Injectable, Logger } from '@nestjs/common';

@Injectable()
export class UsersService {
  private readonly logger = new Logger(UsersService.name);

  findAll() {
    this.logger.log('Finding all users');
    return [];
  }

  findOne(id: number) {
    this.logger.debug(`Finding user with id: ${id}`);
    return { id, name: 'Test User' };
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// src/example/example.service.ts
import { Injectable, Logger } from '@nestjs/common';

@Injectable()
export class ExampleService {
  private readonly logger = new Logger(ExampleService.name);

  demonstrateLogLevels() {
    this.logger.log('This is a log message');
    this.logger.fatal('This is a fatal message');
    this.logger.error('This is an error message');
    this.logger.warn('This is a warning message');
    this.logger.debug('This is a debug message');
    this.logger.verbose('This is a verbose message');
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// src/main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule, {
    logger: ['error', 'warn', 'log'],
  });
  await app.listen(3000);
}
bootstrap();

1
2
3
4

// src/main.ts
const app = await NestFactory.create(AppModule, {
  logger: false,
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// src/main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { LogLevel } from '@nestjs/common';

async function bootstrap() {
  const isProduction = process.env.NODE_ENV === 'production';
  
  const logLevels: LogLevel[] = isProduction
    ? ['error', 'warn', 'log']
    : ['error', 'warn', 'log', 'debug', 'verbose'];

  const app = await NestFactory.create(AppModule, {
    logger: logLevels,
  });
  await app.listen(3000);
}
bootstrap();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// src/users/users.service.ts
import { Injectable, Logger } from '@nestjs/common';

@Injectable()
export class UsersService {
  private readonly logger = new Logger(UsersService.name, { timestamp: true });

  processData() {
    this.logger.log('Starting data processing');
    // 何らかの処理
    this.logger.log('Data processing completed');
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// src/main.ts
import { NestFactory } from '@nestjs/core';
import { ConsoleLogger } from '@nestjs/common';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule, {
    logger: new ConsoleLogger({
      json: true,
    }),
  });
  await app.listen(3000);
}
bootstrap();

1
2
3
4
5
6
7

{
  "level": "log",
  "pid": 19096,
  "timestamp": 1736172000000,
  "message": "Starting Nest application...",
  "context": "NestFactory"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// src/main.ts
import { NestFactory } from '@nestjs/core';
import { ConsoleLogger } from '@nestjs/common';
import { AppModule } from './app.module';

async function bootstrap() {
  const isProduction = process.env.NODE_ENV === 'production';

  const app = await NestFactory.create(AppModule, {
    logger: new ConsoleLogger({
      json: isProduction,
      colors: !isProduction,
      prefix: 'MyApp',
      logLevels: isProduction 
        ? ['error', 'warn', 'log'] 
        : ['error', 'warn', 'log', 'debug', 'verbose'],
    }),
  });
  await app.listen(3000);
}
bootstrap();

1
2
3
4
5
6
7
8

export interface LoggerService {
  log(message: any, ...optionalParams: any[]): any;
  fatal(message: any, ...optionalParams: any[]): any;
  error(message: any, ...optionalParams: any[]): any;
  warn(message: any, ...optionalParams: any[]): any;
  debug?(message: any, ...optionalParams: any[]): any;
  verbose?(message: any, ...optionalParams: any[]): any;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

// src/common/logger/custom-logger.service.ts
import { Injectable, LoggerService, LogLevel } from '@nestjs/common';

@Injectable()
export class CustomLoggerService implements LoggerService {
  private context?: string;

  setContext(context: string) {
    this.context = context;
  }

  log(message: any, context?: string) {
    this.printLog('LOG', message, context);
  }

  fatal(message: any, context?: string) {
    this.printLog('FATAL', message, context);
  }

  error(message: any, trace?: string, context?: string) {
    this.printLog('ERROR', message, context);
    if (trace) {
      console.error(trace);
    }
  }

  warn(message: any, context?: string) {
    this.printLog('WARN', message, context);
  }

  debug(message: any, context?: string) {
    this.printLog('DEBUG', message, context);
  }

  verbose(message: any, context?: string) {
    this.printLog('VERBOSE', message, context);
  }

  private printLog(level: string, message: any, context?: string) {
    const timestamp = new Date().toISOString();
    const ctx = context || this.context || 'Application';
    console.log(JSON.stringify({
      timestamp,
      level,
      context: ctx,
      message,
    }));
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// src/common/logger/extended-logger.service.ts
import { ConsoleLogger, Injectable } from '@nestjs/common';

@Injectable()
export class ExtendedLoggerService extends ConsoleLogger {
  private requestId?: string;

  setRequestId(requestId: string) {
    this.requestId = requestId;
  }

  protected formatMessage(
    logLevel: string,
    message: unknown,
    pidMessage: string,
    formattedLogLevel: string,
    contextMessage: string,
    timestampDiff: string,
  ): string {
    const requestIdPart = this.requestId ? `[${this.requestId}] ` : '';
    const baseMessage = super.formatMessage(
      logLevel,
      message,
      pidMessage,
      formattedLogLevel,
      contextMessage,
      timestampDiff,
    );
    return requestIdPart + baseMessage;
  }

  error(message: any, stack?: string, context?: string) {
    // エラー時に追加のメタデータを記録
    super.error(message, stack, context);
  }
}

1
2
3
4
5
6
7
8
9

// src/common/logger/logger.module.ts
import { Module } from '@nestjs/common';
import { AppLoggerService } from './app-logger.service';

@Module({
  providers: [AppLoggerService],
  exports: [AppLoggerService],
})
export class LoggerModule {}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

// src/common/logger/app-logger.service.ts
import { ConsoleLogger, Injectable, Scope } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';

@Injectable({ scope: Scope.TRANSIENT })
export class AppLoggerService extends ConsoleLogger {
  private readonly isProduction: boolean;

  constructor(private readonly configService: ConfigService) {
    super();
    this.isProduction = this.configService.get('NODE_ENV') === 'production';
  }

  log(message: any, context?: string) {
    if (this.isProduction) {
      // 本番環境ではJSON形式で出力
      console.log(JSON.stringify({
        timestamp: new Date().toISOString(),
        level: 'log',
        context: context || this.context,
        message,
      }));
    } else {
      super.log(message, context);
    }
  }

  error(message: any, stack?: string, context?: string) {
    if (this.isProduction) {
      console.error(JSON.stringify({
        timestamp: new Date().toISOString(),
        level: 'error',
        context: context || this.context,
        message,
        stack,
      }));
    } else {
      super.error(message, stack, context);
    }
  }

  warn(message: any, context?: string) {
    if (this.isProduction) {
      console.warn(JSON.stringify({
        timestamp: new Date().toISOString(),
        level: 'warn',
        context: context || this.context,
        message,
      }));
    } else {
      super.warn(message, context);
    }
  }

  debug(message: any, context?: string) {
    if (!this.isProduction) {
      super.debug(message, context);
    }
  }

  verbose(message: any, context?: string) {
    if (!this.isProduction) {
      super.verbose(message, context);
    }
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// src/users/users.service.ts
import { Injectable } from '@nestjs/common';
import { AppLoggerService } from '../common/logger/app-logger.service';

@Injectable()
export class UsersService {
  constructor(private readonly logger: AppLoggerService) {
    this.logger.setContext(UsersService.name);
  }

  findAll() {
    this.logger.log('Finding all users');
    return [];
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// src/main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { AppLoggerService } from './common/logger/app-logger.service';

async function bootstrap() {
  const app = await NestFactory.create(AppModule, {
    bufferLogs: true,
  });
  
  // DIコンテナからLoggerインスタンスを取得
  const logger = app.get(AppLoggerService);
  app.useLogger(logger);
  
  await app.listen(3000);
}
bootstrap();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

// src/common/interceptors/logging.interceptor.ts
import {
  Injectable,
  NestInterceptor,
  ExecutionContext,
  CallHandler,
  Logger,
} from '@nestjs/common';
import { Observable } from 'rxjs';
import { tap } from 'rxjs/operators';
import { Request, Response } from 'express';
import { v4 as uuidv4 } from 'uuid';

@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  private readonly logger = new Logger('HTTP');

  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const ctx = context.switchToHttp();
    const request = ctx.getRequest<Request>();
    const response = ctx.getResponse<Response>();
    
    const requestId = uuidv4();
    const { method, originalUrl, ip } = request;
    const userAgent = request.get('user-agent') || '';
    const startTime = Date.now();

    return next.handle().pipe(
      tap({
        next: () => {
          const { statusCode } = response;
          const contentLength = response.get('content-length') || 0;
          const duration = Date.now() - startTime;

          this.logger.log(
            JSON.stringify({
              requestId,
              method,
              url: originalUrl,
              statusCode,
              contentLength,
              duration: `${duration}ms`,
              ip,
              userAgent,
            }),
          );
        },
        error: (error) => {
          const duration = Date.now() - startTime;
          
          this.logger.error(
            JSON.stringify({
              requestId,
              method,
              url: originalUrl,
              statusCode: error.status || 500,
              duration: `${duration}ms`,
              ip,
              userAgent,
              error: error.message,
            }),
          );
        },
      }),
    );
  }
}

1
2

npm install uuid
npm install -D @types/uuid

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// src/app.module.ts
import { Module } from '@nestjs/common';
import { APP_INTERCEPTOR } from '@nestjs/core';
import { LoggingInterceptor } from './common/interceptors/logging.interceptor';

@Module({
  providers: [
    {
      provide: APP_INTERCEPTOR,
      useClass: LoggingInterceptor,
    },
  ],
})
export class AppModule {}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

{
  "requestId": "550e8400-e29b-41d4-a716-446655440000",
  "method": "GET",
  "url": "/users",
  "statusCode": 200,
  "contentLength": 256,
  "duration": "45ms",
  "ip": "127.0.0.1",
  "userAgent": "Mozilla/5.0..."
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

{
  "requestId": "550e8400-e29b-41d4-a716-446655440001",
  "method": "POST",
  "url": "/users",
  "statusCode": 400,
  "duration": "12ms",
  "ip": "127.0.0.1",
  "userAgent": "Mozilla/5.0...",
  "error": "Validation failed"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

// src/common/filters/http-exception-logging.filter.ts
import {
  ExceptionFilter,
  Catch,
  ArgumentsHost,
  HttpException,
  HttpStatus,
  Logger,
} from '@nestjs/common';
import { Request, Response } from 'express';

@Catch()
export class HttpExceptionLoggingFilter implements ExceptionFilter {
  private readonly logger = new Logger('ExceptionFilter');

  catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse<Response>();
    const request = ctx.getRequest<Request>();

    const status =
      exception instanceof HttpException
        ? exception.getStatus()
        : HttpStatus.INTERNAL_SERVER_ERROR;

    const message =
      exception instanceof HttpException
        ? exception.message
        : 'Internal server error';

    const stack = exception instanceof Error ? exception.stack : undefined;

    // エラーログの出力
    const logPayload = {
      timestamp: new Date().toISOString(),
      path: request.url,
      method: request.method,
      statusCode: status,
      message,
      stack: status >= 500 ? stack : undefined,
      body: request.body,
      query: request.query,
      params: request.params,
      ip: request.ip,
      userAgent: request.get('user-agent'),
    };

    if (status >= 500) {
      this.logger.error(JSON.stringify(logPayload));
    } else if (status >= 400) {
      this.logger.warn(JSON.stringify(logPayload));
    }

    // クライアントへのレスポンス
    const errorResponse = {
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: request.url,
      message,
    };

    response.status(status).json(errorResponse);
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// src/main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { HttpExceptionLoggingFilter } from './common/filters/http-exception-logging.filter';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalFilters(new HttpExceptionLoggingFilter());
  await app.listen(3000);
}
bootstrap();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// src/common/utils/log-sanitizer.ts
export function sanitizeForLog(data: Record<string, any>): Record<string, any> {
  const sensitiveKeys = ['password', 'token', 'secret', 'authorization', 'cookie'];
  const sanitized = { ...data };

  for (const key of Object.keys(sanitized)) {
    if (sensitiveKeys.some(sk => key.toLowerCase().includes(sk))) {
      sanitized[key] = '[REDACTED]';
    }
  }

  return sanitized;
}

1

npm install pino pino-pretty nestjs-pino

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// src/app.module.ts
import { Module } from '@nestjs/common';
import { LoggerModule } from 'nestjs-pino';

@Module({
  imports: [
    LoggerModule.forRoot({
      pinoHttp: {
        level: process.env.NODE_ENV === 'production' ? 'info' : 'debug',
        transport: process.env.NODE_ENV !== 'production'
          ? { target: 'pino-pretty' }
          : undefined,
      },
    }),
  ],
})
export class AppModule {}