Monitoring op Budget: Kosten Beheersen Zonder Blindvlekken

Monitoring is essentieel. Maar het kan ook een geldzinkput zijn. Datadog, New Relic, Splunk — de facturen voor enterprise observability-tools lopen snel op tot duizenden euro's per maand. Vooral wanneer je schaalt. Toch bestaat er geen enkele goede reden om blind te vliegen omdat je budget beperkt is.

Met de juiste strategieën bouw je een robuuste monitoring stack die praktisch niets kost, of blijven de kosten voorspelbaar als je voor betaalde tools kiest. Dit zijn de tactieken die werken.

De Kostendrijvers in Monitoring

Voordat je optimalisaties doormaakt, snap je waar het geld heen gaat:

Datavolume — Hoe meer metrics, logs en traces je verzamelt, hoe meer je betaalt. Veel vendors rekenen per GB ingested data.

Retention — Data bewaren kost opslag. Sommige platforms houden alles standaard 90 dagen vast, terwijl je na twee weken eigenlijk alles al weet.

Query's — Bij sommige platforms betaal je per zoekopdracht of dashboard refresh.

Hosts & containers — Per-agent pricing wordt duur zodra je veel kleine services draait.

Alerting & integrations — Premium features zoals PagerDuty integraties, custom webhooks of ML-based anomaly detection verhogen de factuur snel.

Open-Source First: Prometheus + Grafana

De grootste kostenbesparing zit in open-source tooling. Prometheus en Grafana draaien prima op een klein VPS of in je Kubernetes cluster, zonder licentiekosten.

Prometheus verzamelt metrics via scraping. Geen agents die geld kosten per host — gewoon een HTTP endpoint exposen. Voor systeem-metrics gebruik je Node Exporter, voor containers cAdvisor. Setup in Docker Compose:

version: '3.8'

services:
  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus-data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.retention.time=15d'
    ports:
      - "9090:9090"
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    volumes:
      - grafana-data:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD}
      - GF_USERS_ALLOW_SIGN_UP=false
    ports:
      - "3000:3000"
    restart: unless-stopped

volumes:
  prometheus-data:
  grafana-data:

Kosten? Een VPS van €10/maand met 4GB RAM en 80GB opslag draait dit probleemloos voor 20-30 services.

Retention Policies: Niet Alles Hoeft Eeuwig

Standaard bewaren veel tools alles maandenlang. Maar na twee weken zijn de meeste incidents al opgelost. Waarom blijf je betalen voor oude data?

Prometheus retention instellen:

command:
  - '--storage.tsdb.retention.time=15d'

Logrotatie met Loki: In plaats van alle logs eindeloos te bewaren, gebruik je verschillende retention tiers:

Log Type	Retention	Reden
ERROR logs	30 dagen	Compliance & debugging
WARN logs	14 dagen	Troubleshooting
INFO logs	7 dagen	Recent context
DEBUG logs	3 dagen	Development only

In Loki configureer je dit met stream selectors in limits_config:

limits_config:
  retention_period: 168h  # 7 dagen default
  per_stream_rate_limit: 5MB
  per_stream_rate_limit_burst: 10MB

Voor specifieke streams gebruik je retention rules in de compactor config. Errors blijven langer, debug-logs verdwijnen snel. Dit scheelt gigabytes per week.

Sampling: Niet Elk Request Hoeft Getracet

Distributed tracing kan enorm datavolume genereren. Als je 10.000 requests per minuut hebt en elk request tracet, zit je snel op terabytes per maand. Dat is niet nodig.

Tail-based sampling is de slimme aanpak: trace alles tijdelijk, maar bewaar alleen interessante requests — errors, langzame calls, specifieke endpoints.

Met OpenTelemetry Collector:

processors:
  tail_sampling:
    decision_wait: 10s
    policies:
      - name: errors
        type: status_code
        status_code:
          status_codes: [ERROR]
      - name: slow-requests
        type: latency
        latency:
          threshold_ms: 500
      - name: sample-normal
        type: probabilistic
        probabilistic:
          sampling_percentage: 5

Dit bewaart:

• Alle errors (100%)
• Alle requests > 500ms (100%)
• 5% van normale requests (voor baseline)

Het resultaat? 95% minder trace data, zonder belangrijke informatie te missen.

Cardinality Onder Controle: Metrics Exploderen

High-cardinality labels maken metrics sets exponentieel groter. Een simpel voorbeeld:

http_requests_total{endpoint="/api/users/12345"}

Als endpoint de user ID bevat, heb je straks miljoenen unieke time-series. Prometheus crasht, storage groeit explosief.

Fix: Gebruik template endpoints:

http_requests_total{endpoint="/api/users/:id"}

Check je metrics regelmatig op cardinality problemen:

# Top 10 metrics met hoogste cardinality
curl -s http://localhost:9090/api/v1/label/__name__/values | jq '.data[]' | head -10

Verwijder labels die te gedetailleerd zijn (zoals user IDs, session tokens, timestamps). Die horen in traces of logs, niet in metrics.

Gratis Alternatives voor Betaalde Features

Sommige features lijken premium, maar zijn gratis te repliceren:

Uptime monitoring → Gebruik Uptime Kuma (self-hosted) in plaats van Pingdom.

Alerting → Prometheus Alertmanager + webhook naar Discord/Slack kost niets. PagerDuty is €29/maand per user.

Log aggregation → Loki (Grafana's log stack) is gratis. Splunk kost €1500/GB/maand.

Synthetics / End-to-end tests → Playwright in een cron job + simpel dashboard. Datadog Synthetics is $5 per test per maand.

Cloud-Hosted: Kies Verstandig

Soms is managed monitoring de betere keuze — minder overhead, betere integraties. Dan zijn er slimmere opties dan de grote namen:

Grafana Cloud — Free tier: 10K series, 50GB logs, 50GB traces per maand. Genoeg voor kleinere projecten.

Sentry (errors only) — 5K events/maand gratis. Voor error tracking vaak voldoende.

Axiom (logs) — 500GB ingested per maand gratis. Schaalbaar en simpel.

Vergelijk dat met Datadog ($15/host/maand) en New Relic ($99/user/maand). De kostenbesparingen stapelen snel op.

Dashboards: Minder is Meer

Veel teams bouwen gigantische dashboards met honderd panels. Dat is niet alleen visueel overweldigend, het vertraagt ook query performance en verhoogt de cloud bill als je betaalt per query.

Best practice: Eén dashboard per service, max 8-12 panels. Focus op:

• Golden signals (latency, traffic, errors, saturation)
• Resource usage (CPU, memory, disk)
• Business metrics (orders, signups, etc.)

Alles daarbuiten hoort in ad-hoc queries, niet in auto-refresh dashboards.

Conclusie

Monitoring hoeft geen budgetkiller te zijn. Met open-source tools, slimme sampling, retention policies en cardinality management krijg je volledige observability voor een fractie van wat enterprise vendors rekenen. Begin met Prometheus + Grafana voor metrics, Loki voor logs, en OpenTelemetry voor traces. Schaal op waar nodig, maar betaal nooit voor data die je toch niet gebruikt.

English summary: This article covers practical cost optimization strategies for monitoring infrastructure — from using open-source tools like Prometheus and Grafana, to implementing smart retention policies, tail-based sampling for traces, and avoiding high-cardinality metrics. It shows how to build production-grade observability on a budget without blind spots.