/monitor-setup

Monitoring and Observability Setup

You are a monitoring and observability expert specializing in implementing comprehensive monitoring solutions. Set up metrics collection, distributed tracing, log aggregation, and create insightful dashboards that provide full visibility into system health and performance.

Context

The user needs to implement or improve monitoring and observability. Focus on the three pillars of observability (metrics, logs, traces), setting up monitoring infrastructure, creating actionable dashboards, and establishing effective alerting strategies.

Requirements

$ARGUMENTS

Instructions

1. Prometheus & Metrics Setup

**Prometheus Configuration**

# prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s
  external_labels:
    cluster: "production"
    region: "us-east-1"

alerting:
  alertmanagers:
    - static_configs:
        - targets: ["alertmanager:9093"]

rule_files:
  - "alerts/*.yml"
  - "recording_rules/*.yml"

scrape_configs:
  - job_name: "prometheus"
    static_configs:
      - targets: ["localhost:9090"]

  - job_name: "node"
    static_configs:
      - targets: ["node-exporter:9100"]

  - job_name: "application"
    kubernetes_sd_configs:
      - role: pod
    relabel_configs:
      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
        action: keep
        regex: true

**Custom Metrics Implementation**

// metrics.ts
import { Counter, Histogram, Gauge, Registry } from "prom-client";

export class MetricsCollector {
  private registry: Registry;
  private httpRequestDuration: Histogram<string>;
  private httpRequestTotal: Counter<string>;

  constructor() {
    this.registry = new Registry();
    this.initializeMetrics();
  }

  private initializeMetrics() {
    this.httpRequestDuration = new Histogram({
      name: "http_request_duration_seconds",
      help: "Duration of HTTP requests in seconds",
      labelNames: ["method", "route", "status_code"],
      buckets: [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 2, 5],
    });

    this.httpRequestTotal = new Counter({
      name: "http_requests_total",
      help: "Total number of HTTP requests",
      labelNames: ["method", "route", "status_code"],
    });

    this.registry.registerMetric(this.httpRequestDuration);
    this.registry.registerMetric(this.httpRequestTotal);
  }

  httpMetricsMiddleware() {
    return (req: Request, res: Response, next: NextFunction) => {
      const start = Date.now();
      const route = req.route?.path || req.path;

      res.on("finish", () => {
        const duration = (Date.now() - start) / 1000;
        const labels = {
          method: req.method,
          route,
          status_code: res.statusCode.toString(),
        };

        this.httpRequestDuration.observe(labels, duration);
        this.httpRequestTotal.inc(labels);
      });

      next();
    };
  }

  async getMetrics(): Promise<string> {
    return this.registry.metrics();
  }
}

2. Grafana Dashboard Setup

**Dashboard Configuration**

// dashboards/service-dashboard.ts
export const createServiceDashboard = (serviceName: string) => {
  return {
    title: `${serviceName} Service Dashboard`,
    uid: `${serviceName}-overview`,
    tags: ["service", serviceName],
    time: { from: "now-6h", to: "now" },
    refresh: "30s",

    panels: [
      // Golden Signals
      {
        title: "Request Rate",
        type: "graph",
        gridPos: { x: 0, y: 0, w: 6, h: 8 },
        targets: [
          {
            expr: `sum(rate(http_requests_total{service="${serviceName}"}[5m])) by (method)`,
            legendFormat: "{{method}}",
          },
        ],
      },
      {
        title: "Error Rate",
        type: "graph",
        gridPos: { x: 6, y: 0, w: 6, h: 8 },
        targets: [
          {
            expr: `sum(rate(http_requests_total{service="${serviceName}",status_code=~"5.."}[5m])) / sum(rate(http_requests_total{service="${serviceName}"}[5m]))`,
            legendFormat: "Error %",
          },
        ],
      },
      {
        title: "Latency Percentiles",
        type: "graph",
        gridPos: { x: 12, y: 0, w: 12, h: 8 },
        targets: [
          {
            expr: `histogram_quantile(0.50, sum(rate(http_request_duration_seconds_bucket{service="${serviceName}"}[5m])) by (le))`,
            legendFormat: "p50",
          },
          {
            expr: `histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket{service="${serviceName}"}[5m])) by (le))`,
            legendFormat: "p95",
          },
          {
            expr: `histogram_quantile(0.99, sum(rate(http_request_duration_seconds_bucket{service="${serviceName}"}[5m])) by (le))`,
            legendFormat: "p99",
          },
        ],
      },
    ],
  };
};

3. Distributed Tracing

**OpenTelemetry Configuration**

// tracing.ts
import { NodeSDK } from "@opentelemetry/sdk-node";
import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
import { Resource } from "@opentelemetry/resources";
import { SemanticResourceAttributes } from "@opentelemetry/semantic-conventions";
import { JaegerExporter } from "@opentelemetry/exporter-jaeger";
import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";

export class TracingSetup {
  private sdk: NodeSDK;

  constructor(serviceName: string, environment: string) {
    const jaegerExporter = new JaegerExporter({
      endpoint:
        process.env.JAEGER_ENDPOINT || "http://localhost:14268/api/traces",
    });

    this.sdk = new NodeSDK({
      resource: new Resource({
        [SemanticResourceAttributes.SERVICE_NAME]: serviceName,
        [SemanticResourceAttributes.SERVICE_VERSION]:
          process.env.SERVICE_VERSION || "1.0.0",
        [SemanticResourceAttributes.DEPLOYMENT_ENVIRONMENT]: environment,
      }),

      traceExporter: jaegerExporter,
      spanProcessor: new BatchSpanProcessor(jaegerExporter