Logging et monitoring NestJS

## Logging et monitoring NestJS

## Pourquoi Logging et monitoring NestJS ?

Logging et monitoring sont des aspects cruciaux de la qualité d'un service backend moderne, surtout lorsqu'il s'agit d'applications basées sur Node.js avec NestJS. Dans un environnement de production, les applications doivent être en mesure de répondre aux demandes de manière fiable et performante. Les logs fournissent une vue précieuse de ce qui se passe à l'intérieur de votre application, tandis que le monitoring permet d'obtenir des métriques quantitatives sur son état.

Un cas d'usage concret serait l'analyse des performances d'une API de blog. En enregistrant les temps de réponse et les erreurs associées, vous pouvez identifier les points de faiblesse et mettre en œuvre des améliorations. De plus, le monitoring continu permet de détecter rapidement tout changement inhabituel ou anomalie qui pourrait affecter la disponibilité du service.

## Prerequis

- Connaissance de base de Node.js
- Familiarité avec TypeScript
- Installation d'Node.js (v14+ recommandée)
- Installation de npm (paquetage Node.js)
- IDE comme Visual Studio Code

## Concepts fondamentaux

### 1. Logging

Le logging est le processus d'enregistrement des informations sur l'exécution d'une application. Ces informations peuvent être utilisées pour diagnostiquer les problèmes, surveiller le comportement de l'application et suivre son évolution au fil du temps.

**Schéma mental :**

[Application] ├── [Request] │ └── Log "Request received" └── [Response] └── Log "Response sent with status code 200" typescript // src/app.module.ts import { Module } from '@nestjs/common'; import { APP_FILTER, APP_INTERCEPTOR, APP_PIPE } from '@nestjs/core'; import { LoggingInterceptor } from './logging.interceptor'; import { AllExceptionsFilter } from './all-exceptions.filter'; import { ValidationPipe } from './validation.pipe';

@Module({ imports: [], controllers: [], providers: [ { provide: APP_INTERCEPTOR, useClass: LoggingInterceptor, }, { provide: APP_FILTER, useClass: AllExceptionsFilter, }, { provide: APP_PIPE, useClass: ValidationPipe, }, ], }) export class AppModule {} typescript // src/logging.interceptor.ts import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common'; import { Observable } from 'rxjs'; import { tap } from 'rxjs/operators';

@Injectable() export class LoggingInterceptor implements NestInterceptor { intercept(context: ExecutionContext, next: CallHandler): Observable { const request = context.switchToHttp().getRequest(); console.log(Request ${request.method} ${request.url});

return next.handle().pipe(
  tap(data => {
    console.log(`Response sent with status code ${context.switchToHttp().getResponse().statusCode}`);
  }),
);

} }

### 2. Monitoring

Le monitoring est le processus de surveillance et d'analyse des performances et de l'état d'une application en temps réel. Cela permet d'identifier les problèmes avant qu'ils ne deviennent gravissimes.

**Schéma mental :**

[Monitoring Tool] ├── [Metrics Collection] │ ├── CPU Usage │ ├── Memory Usage │ ├── HTTP Requests/Second │ └── Error Rate └── [Alerts and Notifications] ├── High CPU Usage Detected ├── High Error Rate Detected typescript // src/main.ts import { NestFactory } from '@nestjs/core'; import { AppModule } from './app.module';

async function bootstrap() { const app = await NestFactory.create(AppModule); // Configuration du serveur de monitoring (par exemple, Prometheus) await app.listen(3000); } bootstrap();

## Mise en pratique : projet fil rouge

### Mini-projet complet : Gestionnaire de tâches

#### Étape 1 : Créer un nouveau projet NestJS

```bash
nest new task-manager
cd task-manager
npm install --save @nestjs/platform-express
npm install --save-dev @types/express

Étape 2 : Configurer le logging et le monitoring

Ajoutez les fichiers suivants :

• src/logging.interceptor.ts
• src/all-exceptions.filter.ts
• src/validation.pipe.ts

Étape 3 : Créer un module pour la gestion des tâches

// src/tasks/tasks.module.ts
import { Module } from '@nestjs/common';
import { TasksController } from './tasks.controller';
import { TasksService } from './tasks.service';

@Module({
  controllers: [TasksController],
  providers: [TasksService],
})
export class TasksModule {}

Étape 4 : Créer le service pour la gestion des tâches

// src/tasks/tasks.service.ts
import { Injectable } from '@nestjs/common';
import { Task } from './task.model';

@Injectable()
export class TasksService {
  private tasks: Task[] = [];

  findAll(): Task[] {
    return this.tasks;
  }

  findOne(id: number): Task {
    return this.tasks.find(task => task.id === id);
  }

  create(task: Task): Task {
    this.tasks.push(task);
    return task;
  }

  update(id: number, task: Task): Task {
    const index = this.tasks.findIndex(t => t.id === id);
    if (index !== -1) {
      this.tasks[index] = { ...this.tasks[index], ...task };
      return this.tasks[index];
    }
    throw new Error('Task not found');
  }

  remove(id: number): void {
    const index = this.tasks.findIndex(t => t.id === id);
    if (index !== -1) {
      this.tasks.splice(index, 1);
    } else {
      throw new Error('Task not found');
    }
  }
}

Étape 5 : Créer le contrôleur pour la gestion des tâches

// src/tasks/tasks.controller.ts
import { Controller, Get, Post, Body, Put, Param, Delete } from '@nestjs/common';
import { TasksService } from './tasks.service';
import { Task } from './task.model';

@Controller('tasks')
export class TasksController {
  constructor(private readonly tasksService: TasksService) {}

  @Get()
  findAll(): Task[] {
    return this.tasksService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: number): Task {
    return this.tasksService.findOne(id);
  }

  @Post()
  create(@Body() task: Task): Task {
    return this.tasksService.create(task);
  }

  @Put(':id')
  update(@Param('id') id: number, @Body() task: Task): Task {
    return this.tasksService.update(id, task);
  }

  @Delete(':id')
  remove(@Param('id') id: number): void {
    this.tasksService.remove(id);
  }
}

Étape 6 : Définir le modèle de tâche

// src/tasks/task.model.ts
export interface Task {
  id: number;
  title: string;
  description?: string;
}

Erreurs frequentes et debugging

Erreur 1 : Cannot find module 'express'

npm install --save express

Erreur 2 : Error: Cannot find module '@nestjs/common'

npm install --save @nestjs/common

Erreur 3 : Type 'Task' is not assignable to type 'string | number | boolean | undefined'

Ajoutez les types appropriés dans le fichier task.model.ts :

// src/tasks/task.model.ts
export interface Task {
  id: number;
  title: string;
  description?: string;
}

Erreur 4 : Cannot read property 'id' of undefined

Vérifiez que les objets envoyés au service ne sont pas undefined :

// src/tasks/tasks.service.ts
update(id: number, task: Task): Task {
  const index = this.tasks.findIndex(t => t.id === id);
  if (index !== -1) {
    return { ...this.tasks[index], ...task };
  }
  throw new Error('Task not found');
}

Erreur 5 : Error: Cannot find module 'nest'

npm install --save @nestjs/core

Pour aller plus loin

1. Intégration avec Prometheus et Grafana

Prometheus est un système de monitoring open source, tandis que Grafana est un outil d'analyse et de visualisation de données. L'intégration de NestJS avec ces outils vous permettra d'avoir une vision complète des performances de votre application.

2. Utilisation de Serilog

Serilog est un framework de logging pour .NET, mais il existe des adaptations pour Node.js comme pino. Son utilisation peut améliorer la performance et la flexibilité du logging dans votre application NestJS.

3. Déploiement continu (CI/CD)

Intégrez NestJS avec des outils de CI/CD tels que Jenkins, GitLab CI ou GitHub Actions pour automatiser le déploiement et la validation continue de votre application.

Défi pratique

Créez un mini-projet NestJS qui inclut une API pour gérer des utilisateurs. L'API doit permettre les opérations suivantes :

• Créer un utilisateur
• Consulter tous les utilisateurs
• Consulter un utilisateur par ID
• Mettre à jour un utilisateur
• Supprimer un utilisateur

Assurez-vous d'inclure des intercepteurs de logging et des filtres pour gérer les exceptions. ```