Bootcamp i backendutvikling med Node.js · leksjon

Eksponering av applikasjonsmetrikker og RED-metoden

Publiser metrikker for rate, feil og varighet i Prometheus-format, og definer meningsfulle SLI-er.

Leksjon 3 av 413 trinn

Eksponering av applikasjonsmetrikker og RED-metoden er en gratis leksjon i Bootcamp i backendutvikling med Node.js på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Bootcamp i backendutvikling med Node.js, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Bootcamp i backendutvikling med Node.js inneholder totalt 4 leksjoner.

Hvorfor metrikker er viktige

Logger forteller deg hva som skjedde i én enkelt forespørsel. Metrikker forteller deg hvordan hele tjenesten din oppfører seg akkurat nå og over tid. De er billige å lagre, egner seg godt for aggregering og driver dashbord og varsler.

En metrikk er en numerisk måling som samles inn over tid. I en Node.js-backend eksporterer du vanligvis metrikker i Prometheus-tekstformat via et HTTP-endepunkt (vanligvis /metrics). Prometheus henter data fra dette endepunktet med noen sekunders mellomrom og lagrer tidsseriene.

Counter — går bare oppover (totalt antall forespørsler, totalt antall feil).
Gauge — går opp og ned (aktive tilkoblinger, kødybde).
Histogram — deler observasjoner inn i intervaller (forespørselsvarigheter) for å beregne kvantiler.

Prometheus-tekstformatet

Før du kobler til biblioteker, er det nyttig å se hva endepunktet /metrics faktisk returnerer. Hver linje er metric_name{label="value"} number. Kommentarlinjene # HELP og # TYPE beskriver hver metrikk.

Med etiketter kan ett metrikknavn inneholde mange dimensjoner (per rute, per statuskode). Nedenfor finner du en liten generator som bygger dette eksponeringsformatet for hånd, slik at du kan se nøyaktig hva Prometheus tolker.

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);

Introduksjon til RED-metoden

RED-metoden er en målrettet oppskrift for overvåking av forespørselsdrevne tjenester. For hver tjeneste følger du tre signaler:

R — Rate: antall forespørsler per sekund som tjenesten håndterer.
E — Errors: frekvensen av mislykkede forespørsler (vanligvis HTTP 5xx, noen ganger 4xx).
D — Duration: fordelingen av hvor lang tid forespørsler tar (forsinkelse).

RED er forespørselssiden av USE (Utilization, Saturation, Errors), som retter seg mot ressurser som CPU og disk. For et HTTP-API samsvarer RED nesten perfekt med brukeropplevelsen: gjennomstrømning, feilfrekvens og forsinkelse.

Det elegante er at alle tre signalene kan utledes ved å instrumentere bare én ting — forespørselens livssyklus.

Installere prom-client

I Node.js er prom-client det de facto-standarden. Det administrerer et register med metrikker og gjengir dem i Prometheus-format. Det leveres også med standardmetrikker (forsinkelse i event loop, heap-bruk og GC) som du aktiverer med ett kall.

Opprett ett enkelt, delt register slik at alle deler av appen registrerer metrikker på samme sted.

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 — En Counter for forespørselsfrekvens

Frekvens lagres ikke direkte. Du lagrer en monoton teller for totalt antall forespørsler, og Prometheus beregner frekvensen per sekund ved spørringstidspunktet med rate(http_requests_total[1m]).

Gi telleren etiketter for method, route og status_code. Det er avgjørende at du bruker rutemalen (/users/:id) og ikke den rå URL-en (/users/42) — ellers blir hver id en ny tidsserie, og kardinaliteten eksploderer.

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 — Et Histogram for varighet

For varighet trenger du et histogram slik at du kan beregne persentiler (p50, p95, p99). Et histogram teller observasjoner i forhåndsdefinerte buckets (øvre grenser i sekunder). Velg intervaller som dekker det forventede forsinkelsesområdet.

Et histogram eksponerer automatisk tre tidsserier per etikettsett: _bucket, _sum og _count. Fra _sum og _count får du også gjennomsnittet, og fra _bucket kan du estimere kvantiler med 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
);

Én middleware for å samle inn R, E og D

Hele poenget med RED er at én enkelt instrumentering leverer data til alle tre signalene. En Express-lignende middleware starter en tidtaking, lar forespørselen kjøre og registrerer deretter antallet og varigheten ved res.finish, med statuskoden som etikett.

Feil trenger ingen separat metrikk — de er ganske enkelt telleren filtrert med status_code=~"5.." ved spørringstidspunktet. Dette er rammeverkskode (Express), så bruk den som et referansemønster og ikke som et frittstående program.

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);

Eksponere endepunktet /metrics

Prometheus henter metrikker, så du må eksponere dem via HTTP. Legg til en GET /metrics-rute som returnerer register.metrics() med riktig innholdstype. Dette er endepunktet du oppgir som et mål for innsamling i prometheus.yml.

Hold dette endepunktet internt (bind det til et privat grensesnitt eller beskytt det) — det kan lekke driftsinformasjon og er et fristende mål for tjenestenektangrep.

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']

Spørre RED med PromQL

Når dataene strømmer inn, uttrykker du hvert RED-signal som en PromQL-spørring for dashbord og varsler:

Frekvens: sum(rate(http_requests_total[5m])) by (route)
Feil (forhold): sum(rate(http_requests_total{status_code=~"5.."}[5m])) / sum(rate(http_requests_total[5m]))
Varighet (p95): histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket[5m])) by (le))

Merk at feilforholdet er en andel av alle forespørsler, ikke et rått antall. En feilfrekvens på 0.02 betyr at 2 % av forespørslene mislyktes — langt mer meningsfullt enn «40 feil» uten en nevner.

Fra metrikker til SLI-er og SLO-er

En Service Level Indicator (SLI) er et presist definert mål på tjenestens helse, vanligvis uttrykt som good events / valid events. RED-metrikker er nettopp råmaterialet for SLI-er:

Tilgjengelighets-SLI: svar som ikke er 5xx / alle svar.
Forsinkelses-SLI: forespørsler som er raskere enn 300 ms / alle forespørsler.

Et Service Level Objective (SLO) er et mål for en SLI over et tidsvindu, for eksempel «99,9 % av forespørslene lykkes over 30 dager». Det som gjenstår av SLO-et, er ditt feilbudsjett (0,1 %), som forteller hvor mye feil du kan tåle før du må slutte å levere nye funksjoner og utbedre påliteligheten.

Beregne en forsinkelses-SLI fra buckets

En forsinkelses-SLI som «andel forespørsler under 300 ms» kommer direkte fra antallet i histogrammets buckets: ta det kumulative antallet i le="0.3"-bucken og del på det totale antallet. Her er en frittstående simulering av denne beregningen over to innsamlede prøver.

// 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));

Hurtigsjekk

Test forståelsen din av kardinalitet og RED-metoden.

Besvar den i den interaktive leksjonen

Oppsummering

Du kan nå eksponere meningsfulle applikasjonsmetrikker i Prometheus-format og analysere dem med RED-metoden.

Counter, Gauge, Histogram er de sentrale metrikkt ypene; prom-client administrerer et register og gjengir eksponeringsformatet.
RED = Rate, Errors, Duration — alle tre kommer fra å instrumentere forespørselens livssyklus én gang, i én enkelt middleware.
Frekvens kommer fra en counter via rate(); feil er denne telleren filtrert med status_code=~"5.."; varighet kommer fra et histogram via histogram_quantile().
Bruk alltid etiketter basert på rutemalen, aldri rå URL-er, for å kontrollere kardinaliteten.
Eksponer metrikker på /metrics og la Prometheus hente dem; hold endepunktet internt.
Gjør RED-metrikker om til SLI-er (gode gyldige hendelser), fastsett SLO-er og følg med på feilbudsjettet.

Gratis å komme i gang

Lær deg JavaScript med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 22
Leksjoner: 92

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Eksponering av applikasjonsmetrikker og RED-metoden» gratis?

Ja – hele teksten i «Eksponering av applikasjonsmetrikker og RED-metoden» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Bootcamp i backendutvikling med Node.js-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Bootcamp i backendutvikling med Node.js inneholder totalt 4 leksjoner.

Hva lærer jeg i «Eksponering av applikasjonsmetrikker og RED-metoden»?

Publiser metrikker for rate, feil og varighet i Prometheus-format, og definer meningsfulle SLI-er. Du øver på Bootcamp i backendutvikling med Node.js med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Bootcamp i backendutvikling med Node.js?

Ingen tidligere erfaring er nødvendig. Bootcamp i backendutvikling med Node.js på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Eksponering av applikasjonsmetrikker og RED-metoden»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Bootcamp i backendutvikling med Node.js-leksjonen?

Ja. Alle Bootcamp i backendutvikling med Node.js-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Strukturert logging med korrelasjons-ID-er
Distribuert sporing med OpenTelemetry-spans
Eksponering av applikasjonsmetrikker og RED-metoden
Kontekstpropagering med AsyncLocalStorage

← Tilbake til Bootcamp i backendutvikling med Node.js