1---
2title: Use Structured Logging
3impact: MEDIUM-HIGH
4impactDescription: Structured logging enables effective debugging and monitoring
5tags: devops, logging, structured-logs, pino
6---
7 
8## Use Structured Logging
9 
10Use NestJS Logger with structured JSON output in production. Include contextual information (request ID, user ID, operation) to trace requests across services. Avoid console.log and implement proper log levels.
11 
12**Incorrect (using console.log in production):**
13 
14```typescript
15// Use console.log in production
16@Injectable()
17export class UsersService {
18  async createUser(dto: CreateUserDto): Promise<User> {
19    console.log('Creating user:', dto);
20    // Not structured, no levels, lost in production logs
21 
22    try {
23      const user = await this.repo.save(dto);
24      console.log('User created:', user.id);
25      return user;
26    } catch (error) {
27      console.log('Error:', error); // Using log for errors
28      throw error;
29    }
30  }
31}
32 
33// Log sensitive data
34console.log('Login attempt:', { email, password }); // SECURITY RISK!
35 
36// Inconsistent log format
37logger.log('User ' + userId + ' created at ' + new Date());
38// Hard to parse, no structure
39```
40 
41**Correct (use structured logging with context):**
42 
43```typescript
44// Configure logger in main.ts
45async function bootstrap() {
46  const app = await NestFactory.create(AppModule, {
47    logger:
48      process.env.NODE_ENV === 'production'
49        ? ['error', 'warn', 'log']
50        : ['error', 'warn', 'log', 'debug', 'verbose'],
51  });
52}
53 
54// Use NestJS Logger with context
55@Injectable()
56export class UsersService {
57  private readonly logger = new Logger(UsersService.name);
58 
59  async createUser(dto: CreateUserDto): Promise<User> {
60    this.logger.log('Creating user', { email: dto.email });
61 
62    try {
63      const user = await this.repo.save(dto);
64      this.logger.log('User created', { userId: user.id });
65      return user;
66    } catch (error) {
67      this.logger.error('Failed to create user', error.stack, {
68        email: dto.email,
69      });
70      throw error;
71    }
72  }
73}
74 
75// Custom logger for JSON output
76@Injectable()
77export class JsonLogger implements LoggerService {
78  log(message: string, context?: object): void {
79    console.log(
80      JSON.stringify({
81        level: 'info',
82        timestamp: new Date().toISOString(),
83        message,
84        ...context,
85      }),
86    );
87  }
88 
89  error(message: string, trace?: string, context?: object): void {
90    console.error(
91      JSON.stringify({
92        level: 'error',
93        timestamp: new Date().toISOString(),
94        message,
95        trace,
96        ...context,
97      }),
98    );
99  }
100 
101  warn(message: string, context?: object): void {
102    console.warn(
103      JSON.stringify({
104        level: 'warn',
105        timestamp: new Date().toISOString(),
106        message,
107        ...context,
108      }),
109    );
110  }
111 
112  debug(message: string, context?: object): void {
113    console.debug(
114      JSON.stringify({
115        level: 'debug',
116        timestamp: new Date().toISOString(),
117        message,
118        ...context,
119      }),
120    );
121  }
122}
123 
124// Request context logging with ClsModule
125import { ClsModule, ClsService } from 'nestjs-cls';
126 
127@Module({
128  imports: [
129    ClsModule.forRoot({
130      global: true,
131      middleware: {
132        mount: true,
133        generateId: true,
134      },
135    }),
136  ],
137})
138export class AppModule {}
139 
140// Middleware to set request context
141@Injectable()
142export class RequestContextMiddleware implements NestMiddleware {
143  constructor(private cls: ClsService) {}
144 
145  use(req: Request, res: Response, next: NextFunction): void {
146    const requestId = req.headers['x-request-id'] || randomUUID();
147    this.cls.set('requestId', requestId);
148    this.cls.set('userId', req.user?.id);
149 
150    res.setHeader('x-request-id', requestId);
151    next();
152  }
153}
154 
155// Logger that includes request context
156@Injectable()
157export class ContextLogger {
158  constructor(private cls: ClsService) {}
159 
160  log(message: string, data?: object): void {
161    console.log(
162      JSON.stringify({
163        level: 'info',
164        timestamp: new Date().toISOString(),
165        requestId: this.cls.get('requestId'),
166        userId: this.cls.get('userId'),
167        message,
168        ...data,
169      }),
170    );
171  }
172 
173  error(message: string, error: Error, data?: object): void {
174    console.error(
175      JSON.stringify({
176        level: 'error',
177        timestamp: new Date().toISOString(),
178        requestId: this.cls.get('requestId'),
179        userId: this.cls.get('userId'),
180        message,
181        error: error.message,
182        stack: error.stack,
183        ...data,
184      }),
185    );
186  }
187}
188 
189// Pino integration for high-performance logging
190import { LoggerModule } from 'nestjs-pino';
191 
192@Module({
193  imports: [
194    LoggerModule.forRoot({
195      pinoHttp: {
196        level: process.env.NODE_ENV === 'production' ? 'info' : 'debug',
197        transport:
198          process.env.NODE_ENV !== 'production'
199            ? { target: 'pino-pretty' }
200            : undefined,
201        redact: ['req.headers.authorization', 'req.body.password'],
202        serializers: {
203          req: (req) => ({
204            method: req.method,
205            url: req.url,
206            query: req.query,
207          }),
208          res: (res) => ({
209            statusCode: res.statusCode,
210          }),
211        },
212      },
213    }),
214  ],
215})
216export class AppModule {}
217 
218// Usage with Pino
219@Injectable()
220export class UsersService {
221  constructor(private logger: PinoLogger) {
222    this.logger.setContext(UsersService.name);
223  }
224 
225  async findOne(id: string): Promise<User> {
226    this.logger.info({ userId: id }, 'Finding user');
227    // Pino uses first arg for data, second for message
228  }
229}
230```
231 
232Reference: [NestJS Logger](https://docs.nestjs.com/techniques/logger)
233