NestJS Enterprise Backend APIs · Lezione

Monitoraggio con Prometheus

Integri Prometheus per raccogliere metriche e crei dashboard per monitorare le prestazioni e lo stato di salute della sua applicazione NestJS.

Lezione 3 di 312 passaggi

Monitoraggio con Prometheus è una lezione NestJS Enterprise Backend APIs gratuita su CoddyKit. Questa è la lezione 3 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento NestJS Enterprise Backend APIs, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso NestJS Enterprise Backend APIs include 3 lezioni in totale.

Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.

Why Monitor Your App?

Monitoring is crucial for understanding your application's health and performance. It helps you catch issues early, debug problems, and ensure a smooth user experience.

Performance: Is your API fast enough?
Availability: Is your service online and responding?
Errors: Are there unexpected failures?
Resource Usage: How much CPU, memory, or disk space is being used?

Without monitoring, you're flying blind!

Meet Prometheus

Prometheus is an open-source monitoring system designed for reliability and scalability. It collects metrics from your applications and infrastructure, storing them as time-series data.

Think of it as a vigilant observer, constantly gathering data points about your system's behavior over time.

Prometheus Architecture

Prometheus works by scraping (pulling) metrics from configured targets. Key components:

Prometheus Server: The core component that scrapes, stores, and queries metrics.
Exporters: Specialized agents that expose existing metrics from third-party systems (like databases, OS) in a Prometheus-compatible format.
Client Libraries: Integrate directly into application code to expose custom metrics (what we'll use in NestJS).
Grafana: A popular dashboard tool for visualizing Prometheus data.

NestJS & `nestjs-prometheus`

To integrate Prometheus with a NestJS application, we use the nestjs-prometheus library. It simplifies exposing metrics and creating custom ones.

This library acts as a bridge, allowing your NestJS app to generate and expose metrics that the Prometheus server can then scrape.

Setting Up `nestjs-prometheus`

First, install the package:

npm install --save @willsoto/nestjs-prometheus prom-client

Then, import PrometheusModule into your root module (e.g., AppModule) and configure it:

import { Module } from '@nestjs/common';
import { PrometheusModule } from '@willsoto/nestjs-prometheus';
import { AppController } from './app.controller';

@Module({
  imports: [
    PrometheusModule.register({
      path: '/metrics',
      collectDefaultMetrics: true
    })
  ],
  controllers: [AppController],
  providers: [],
})
export class AppModule {}

Exposing Default HTTP Metrics

With collectDefaultMetrics: true, nestjs-prometheus automatically exposes basic Node.js process metrics. To also expose HTTP request metrics, you need to add an interceptor.

Update your main.ts to enable this:

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { PrometheusInterceptor } from '@willsoto/nestjs-prometheus';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalInterceptors(new PrometheusInterceptor());
  await app.listen(3000);
  console.log('App is running on port 3000');
  // Access metrics at http://localhost:3000/metrics
}
bootstrap();

Custom Metrics: Counter

A Counter is a cumulative metric that represents a single monotonically increasing value. It can only go up or be reset to zero on restart. Use it for things like the total number of requests served, errors encountered, or items processed.

Here's how to inject and use a custom counter in a service:

import { Injectable } from '@nestjs/common';
import { InjectMetric } from '@willsoto/nestjs-prometheus';
import { Counter } from 'prom-client';

@Injectable()
export class UserService {
  constructor(
    @InjectMetric('users_created_total') public usersCreatedCounter: Counter,
  ) {}

  createUser(name: string): string {
    // Logic to create a user...
    this.usersCreatedCounter.inc(); // Increment the counter
    return `User ${name} created`;
  }
}

Custom Metrics: Gauge

A Gauge is a metric that represents a single numerical value that can arbitrarily go up and down. Use it for things like current memory usage, number of concurrent requests, or the current queue size.

Let's track active connections with a Gauge:

import { Injectable } from '@nestjs/common';
import { InjectMetric } from '@willsoto/nestjs-prometheus';
import { Gauge } from 'prom-client';

@Injectable()
export class ConnectionService {
  constructor(
    @InjectMetric('active_connections_count') public activeConnectionsGauge: Gauge,
  ) {}

  connectUser(): void {
    // User connects logic...
    this.activeConnectionsGauge.inc(); // Increment active connections
  }

  disconnectUser(): void {
    // User disconnects logic...
    this.activeConnectionsGauge.dec(); // Decrement active connections
  }
}

Other Metric Types

Prometheus also offers other metric types for more specific use cases:

Histogram: Samples observations (e.g., request durations) and counts them in configurable buckets. Useful for understanding distributions and percentiles.
Summary: Similar to Histogram but calculates configurable quantiles over a sliding time window. Good for latency.

For most common scenarios, Counters and Gauges are often sufficient.

Visualizing with Grafana

While Prometheus collects metrics, Grafana is typically used to visualize them. Grafana connects to Prometheus as a data source and allows you to build powerful, customizable dashboards.

You can create graphs, charts, and alerts based on the metrics exposed by your NestJS application, giving you real-time insights into its performance and health.

Quick Check

You've learned about setting up Prometheus monitoring in NestJS.

Rispondi nella lezione interattiva

Recap: Monitoring with Prometheus

In this lesson, you learned the importance of monitoring and how Prometheus helps collect time-series metrics from your NestJS application.

We explored the Prometheus architecture and its components.
You saw how to integrate nestjs-prometheus to expose default and custom metrics.
We distinguished between Counter and Gauge metric types.
Finally, we touched on how Grafana is used for powerful visualization.

Monitoring is a vital practice for maintaining robust and performant applications!

Gratis per iniziare

Impara TypeScript con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 20
Lezioni: 76

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Monitoraggio con Prometheus» è gratuita?

Sì — il testo completo di «Monitoraggio con Prometheus» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso NestJS Enterprise Backend APIs, passa a CoddyKit PRO. Il corso NestJS Enterprise Backend APIs include 3 lezioni in totale.

Cosa imparerò in «Monitoraggio con Prometheus»?

Integri Prometheus per raccogliere metriche e crei dashboard per monitorare le prestazioni e lo stato di salute della sua applicazione NestJS. Eserciti NestJS Enterprise Backend APIs con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare NestJS Enterprise Backend APIs?

Non è richiesta alcuna esperienza precedente. NestJS Enterprise Backend APIs su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 3.

Quanto tempo richiede la lezione «Monitoraggio con Prometheus»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione NestJS Enterprise Backend APIs?

Sì. Ogni lezione NestJS Enterprise Backend APIs include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a NestJS Enterprise Backend APIs