Setup Monitoring

Step 3: Set up structured logging

Replace or enhance existing logging with structured JSON logs:

Node.js (pino):

import pino from 'pino';
export const logger = pino({
  level: process.env.LOG_LEVEL || 'info',
  transport: process.env.NODE_ENV === 'development'
    ? { target: 'pino-pretty' }
    : undefined,
});

Python (structlog):

import structlog
structlog.configure(
    processors=[
        structlog.processors.TimeStamper(fmt="iso"),
        structlog.processors.JSONRenderer(),
    ],
)
logger = structlog.get_logger()

Go (slog):

logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo}))
slog.SetDefault(logger)

Add logging to:

• HTTP request/response (method, path, status, duration)
• Database queries (query, duration, error)
• Business events (user actions, transactions)
• Errors (with stack trace and context)

Step 4: Set up error tracking

Sentry (most common):

// Node.js
import * as Sentry from '@sentry/node';
Sentry.init({
  dsn: process.env.SENTRY_DSN,
  environment: process.env.NODE_ENV,
  tracesSampleRate: process.env.NODE_ENV === 'production' ? 0.1 : 1.0,
  integrations: [
    Sentry.httpIntegration(),
    Sentry.expressIntegration(),
    Sentry.prismaIntegration(),
  ],
});

Configure:

• Source maps upload for stack trace deobfuscation
• Environment and release tagging
• User context attachment (without PII)
• Performance monitoring sample rate
• Ignored errors (network errors, user-aborted requests)

Step 5: Set up metrics

Application metrics to track:

• Request rate (requests/second by endpoint)
• Error rate (errors/second by type)
• Response time (p50, p95, p99 by endpoint)
• Active connections/sessions
• Queue depth and processing time (if applicable)
• Database query duration and connection pool usage

System metrics:

• CPU and memory usage
• Disk I/O and space
• Network throughput

Prometheus (self-hosted) setup:

import { Registry, Counter, Histogram } from 'prom-client';
const httpRequestDuration = new Histogram({
  name: 'http_request_duration_seconds',
  help: 'HTTP request duration in seconds',
  labelNames: ['method', 'route', 'status'],
  buckets: [0.01, 0.05, 0.1, 0.5, 1, 5],
});

OpenTelemetry (vendor-neutral):

import { NodeSDK } from '@opentelemetry/sdk-node';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
const sdk = new NodeSDK({
  traceExporter: new OTLPTraceExporter(),
  instrumentations: [getNodeAutoInstrumentations()],
});
sdk.start();

Step 6: Set up health checks

Create standardized health check endpoints:

// GET /health — basic liveness
app.get('/health', (req, res) => {
  res.json({ status: 'ok', timestamp: new Date().toISOString() });
});

// GET /health/ready — readiness (check dependencies)
app.get('/health/ready', async (req, res) => {
  const checks = {
    database: await checkDatabase(),
    redis: await checkRedis(),
  };
  const healthy = Object.values(checks).every(c => c.status === 'ok');
  res.status(healthy ? 200 : 503).json({ status: healthy ? 'ok' : 'degraded', checks });
});

Step 7: Set up alerting

Define alert rules for critical conditions:

# alerts.yml (Prometheus/Grafana format)