Bootcamp backendontwikkeling met Node.js · Les

Applicatiemetrics beschikbaar maken en de RED-methode

Publiceer metrics voor rate, errors en duration in Prometheus-indeling en definieer betekenisvolle SLI's.

Les 3 van 413 stappen

Applicatiemetrics beschikbaar maken en de RED-methode is een gratis Bootcamp backendontwikkeling met Node.js-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Bootcamp backendontwikkeling met Node.js. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Bootcamp backendontwikkeling met Node.js bevat in totaal 4 lessen.

Waarom metrics belangrijk zijn

Logboeken vertellen je wat er is gebeurd in één request. Metrics vertellen je hoe je hele service zich gedraagt, nu en in de loop van de tijd. Ze zijn goedkoop op te slaan, goed te aggregeren en vormen de basis voor dashboards en waarschuwingen.

Een metric is een numerieke meting die in de loop van de tijd wordt bemonsterd. In een Node.js-backend exporteer je metrics doorgaans in de tekstindeling van Prometheus via een HTTP-eindpunt (conventioneel /metrics). Prometheus haalt elke paar seconden gegevens op bij dat eindpunt en slaat de tijdreeksen op.

Counter — neemt alleen toe (totaal aantal requests, totaal aantal fouten).
Gauge — neemt toe en af (actieve verbindingen, diepte van de wachtrij).
Histogram — verdeelt waarnemingen (requestduur) over intervallen om kwantielen te berekenen.

De tekstindeling van Prometheus

Voordat je bibliotheken aansluit, is het nuttig om te zien wat het /metrics-eindpunt daadwerkelijk teruggeeft. Elke regel heeft de vorm metric_name{label="value"} number. De commentaarregels # HELP en # TYPE beschrijven elke metric.

Met labels kan één metricnaam veel dimensies bevatten (per route, per statuscode). Hieronder staat een kleine generator die deze weergave-indeling handmatig opbouwt, zodat je precies kunt zien wat Prometheus parseert.

function renderMetrics(samples) {
  const lines = [
    '# HELP http_requests_total Total HTTP requests',
    '# TYPE http_requests_total counter',
  ];
  for (const s of samples) {
    const labels = Object.entries(s.labels)
      .map(([k, v]) => k + '="' + v + '"')
      .join(',');
    lines.push('http_requests_total{' + labels + '} ' + s.value);
  }
  return lines.join('\n');
}

const out = renderMetrics([
  { labels: { method: 'GET', route: '/users', status: '200' }, value: 1024 },
  { labels: { method: 'GET', route: '/users', status: '500' }, value: 7 },
]);
console.log(out);

Kennismaking met de RED-methode

De RED-methode is een gerichte aanpak voor het monitoren van services die requests verwerken. Voor elke service volg je drie signalen:

R — Rate: het aantal requests per seconde dat de service verwerkt.
E — Errors: het aantal mislukte requests per seconde (meestal HTTP 5xx, soms 4xx).
D — Duration: de verdeling van hoelang requests duren (latentie).

RED is de aanvulling aan de requestkant op USE (Utilization, Saturation, Errors), dat zich richt op resources zoals CPU en schijf. Voor een HTTP-API sluit RED vrijwel perfect aan op de gebruikerservaring: doorvoer, foutenpercentage en latentie.

Het elegante hieraan is dat alle drie voortkomen uit het instrumenteren van slechts één ding — de levenscyclus van een request.

prom-client installeren

In Node.js is de de-factobibliotheek prom-client. Deze beheert een register met metrics en geeft ze weer in de indeling van Prometheus. De bibliotheek levert ook standaardmetrics (vertraging van de eventlus, heapgebruik, garbagecollection) die je met één aanroep inschakelt.

Maak één gedeeld register, zodat elk onderdeel van je app metrics op dezelfde plek registreert.

const client = require('prom-client');

const register = new client.Registry();
register.setDefaultLabels({ app: 'orders-api' });

// Node.js runtime metrics: event loop lag, heap, GC, fd count...
client.collectDefaultMetrics({ register });

module.exports = { client, register };

R — Een counter voor het aantal requests

Rate wordt niet rechtstreeks opgeslagen. Je slaat een monotone counter van het totale aantal requests op, waarna Prometheus de rate per seconde tijdens het uitvoeren van de query berekent met rate(http_requests_total[1m]).

Geef de counter labels voor method, route en status_code. Gebruik vooral de routemal (/users/:id) en niet de onbewerkte URL (/users/42) — anders wordt elke id een nieuwe tijdreeks en explodeert je kardinaliteit.

const client = require('prom-client');

const httpRequestsTotal = new client.Counter({
  name: 'http_requests_total',
  help: 'Total number of HTTP requests',
  labelNames: ['method', 'route', 'status_code'],
});

// On each finished request:
httpRequestsTotal.inc({
  method: 'GET',
  route: '/users/:id',   // template, NOT /users/42
  status_code: '200',
});

D — Een histogram voor de duur

Voor de duur heb je een histogram nodig, zodat je percentielen (p50, p95, p99) kunt berekenen. Een histogram telt waarnemingen in vooraf gedefinieerde buckets (bovengrenzen in seconden). Kies buckets die het verwachte bereik van de latentie omvatten.

Een histogram maakt automatisch drie tijdreeksen per labelset beschikbaar: _bucket, _sum en _count. Met _sum en _count krijg je ook het gemiddelde; met _bucket schat je kwantielen met histogram_quantile().

const client = require('prom-client');

const httpRequestDuration = new client.Histogram({
  name: 'http_request_duration_seconds',
  help: 'HTTP request duration in seconds',
  labelNames: ['method', 'route', 'status_code'],
  // Tuned for a typical web API (5ms .. 5s)
  buckets: [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5],
});

// Observe a completed request that took 0.137s
httpRequestDuration.observe(
  { method: 'GET', route: '/users/:id', status_code: '200' },
  0.137
);

Eén middleware om R, E en D vast te leggen

Het hele idee achter RED is dat één stuk instrumentatie alle drie de signalen voedt. Een Express-achtige middleware start een timer, laat het request uitvoeren en registreert vervolgens bij res.finish het aantal en de duur, met de statuscode als label.

Fouten hebben geen afzonderlijke metric nodig — het zijn gewoon de counterresultaten die tijdens het uitvoeren van de query worden gefilterd met status_code=~"5..". Dit is frameworkcode (Express), dus beschouw het als een referentiepatroon en niet als een zelfstandig programma.

function metricsMiddleware(req, res, next) {
  const end = httpRequestDuration.startTimer({ method: req.method });

  res.on('finish', () => {
    // req.route?.path gives the template, e.g. '/users/:id'
    const route = (req.route && req.route.path) || req.path;
    const labels = {
      method: req.method,
      route,
      status_code: String(res.statusCode),
    };
    httpRequestsTotal.inc(labels);
    end(labels); // stops timer and records duration with these labels
  });

  next();
}

app.use(metricsMiddleware);

Het eindpunt /metrics beschikbaar maken

Prometheus haalt metrics op, dus je moet ze via HTTP beschikbaar maken. Voeg een GET /metrics-route toe die register.metrics() teruggeeft met het juiste inhoudstype. Dit is het eindpunt dat je als scrape-doel opgeeft in prometheus.yml.

Houd dit eindpunt intern (bind het aan een private interface of beveilig het) — het kan operationele details lekken en is een aantrekkelijk doelwit voor DoS-aanvallen.

const { register } = require('./metrics');

app.get('/metrics', async (req, res) => {
  res.set('Content-Type', register.contentType);
  res.end(await register.metrics());
});

// prometheus.yml scrape config:
// scrape_configs:
//   - job_name: 'orders-api'
//     scrape_interval: 15s
//     static_configs:
//       - targets: ['orders-api:3000']

RED opvragen met PromQL

Zodra de gegevens binnenstromen, druk je elk RED-signaal uit als een PromQL-query voor dashboards en waarschuwingen:

Rate: sum(rate(http_requests_total[5m])) by (route)
Fouten (verhouding): sum(rate(http_requests_total{status_code=~"5.."}[5m])) / sum(rate(http_requests_total[5m]))
Duur (p95): histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket[5m])) by (le))

Let erop dat de foutverhouding een fractie van alle requests is, geen onbewerkt aantal. Een foutenpercentage van 0.02 betekent dat 2% van de requests is mislukt — veel betekenisvoller dan "40 errors" zonder noemer.

Van metrics naar SLI's en SLO's

Een Service Level Indicator (SLI) is een nauwkeurig gedefinieerde maatstaf voor de gezondheid van een service, meestal uitgedrukt als good events / valid events. RED-metrics zijn precies het ruwe materiaal voor SLI's:

Beschikbaarheids-SLI: niet-5xx-antwoorden / alle antwoorden.
Latentie-SLI: requests die sneller zijn dan 300 ms / alle requests.

Een Service Level Objective (SLO) is een doel voor een SLI over een bepaalde periode, bijvoorbeeld "99.9% van de requests slaagt gedurende 30 dagen." Het complement van de SLO is je foutbudget (0.1%), dat aangeeft hoeveel fouten je kunt tolereren voordat je moet stoppen met het uitbrengen van functies en de betrouwbaarheid moet verbeteren.

Een latentie-SLI berekenen uit buckets

Een latentie-SLI zoals "fractie van de requests onder 300 ms" komt rechtstreeks uit de aantallen in histogram-buckets: neem het cumulatieve aantal in de bucket le="0.3" en deel dit door het totale aantal. Hier zie je een zelfstandige simulatie van die berekening over twee scrape-monsters.

// Cumulative bucket counts from a histogram, le = upper bound (seconds)
const sample = {
  total: 10000,
  buckets: {
    '0.1': 6000,
    '0.3': 9700,  // 9700 requests finished within 300ms
    '1.0': 9990,
    '+Inf': 10000,
  },
};

function latencySLI(s, thresholdLabel) {
  const good = s.buckets[thresholdLabel];
  return good / s.total;
}

const sli = latencySLI(sample, '0.3');
console.log('Latency SLI (<300ms): ' + (sli * 100).toFixed(2) + '%');
console.log('Meets 99% SLO? ' + (sli >= 0.99));

Snelle controle

Test je begrip van kardinaliteit en de RED-methode.

Beantwoord dit in de interactieve les

Samenvatting

Je kunt nu betekenisvolle applicatiemetrics beschikbaar maken in de indeling van Prometheus en ze analyseren met de RED-methode.

Counter, Gauge, Histogram zijn de belangrijkste metrictypen; prom-client beheert een register en geeft de weergave-indeling weer.
RED = Rate, Errors, Duration — alle drie ontstaan door de levenscyclus van een request één keer te instrumenteren, in één middleware.
Rate komt via rate() uit een counter; Errors zijn die counter, gefilterd met status_code=~"5.."; Duration komt via histogram_quantile() uit een histogram.
Gebruik altijd de routemal als label, nooit onbewerkte URL's, om de kardinaliteit te beheersen.
Maak metrics beschikbaar op /metrics en laat Prometheus ze ophalen; houd het eindpunt intern.
Zet RED-metrics om in SLI's (goede/geldige gebeurtenissen), stel SLO's in en houd je foutbudget bij.

Gratis beginnen

Leer JavaScript met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 22
Lessen: 92

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Applicatiemetrics beschikbaar maken en de RED-methode” gratis?

Ja — de volledige tekst van “Applicatiemetrics beschikbaar maken en de RED-methode” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Bootcamp backendontwikkeling met Node.js wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Bootcamp backendontwikkeling met Node.js bevat in totaal 4 lessen.

Wat leer ik in “Applicatiemetrics beschikbaar maken en de RED-methode”?

Publiceer metrics voor rate, errors en duration in Prometheus-indeling en definieer betekenisvolle SLI's. Je oefent met Bootcamp backendontwikkeling met Node.js door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Bootcamp backendontwikkeling met Node.js te beginnen?

Ervaring vooraf is niet nodig. Bootcamp backendontwikkeling met Node.js op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Applicatiemetrics beschikbaar maken en de RED-methode”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Bootcamp backendontwikkeling met Node.js?

Ja. Elke les over Bootcamp backendontwikkeling met Node.js bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Gestructureerd loggen met correlatie-ID's
Distributed tracing met OpenTelemetry-spans
Applicatiemetrics beschikbaar maken en de RED-methode
Contextpropagatie met AsyncLocalStorage

← Terug naar Bootcamp backendontwikkeling met Node.js