Skip to main content
skill CX Codex

monitoring-observability · rohitg00 — Claude Code skill for monitoring

monitoring-observability is a Claude Code skill that adds tracing, metrics, structured logs, and alert rules to Node.js services. It connects application signals to dashboards and SLOs.

Apache-2.0 ★ 2,858 updated 2026-05-12

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add rohitg00/awesome-claude-code-toolkit --skill monitoring-observability -a claude-code
Open on GitHub

What monitoring-observability does

The examples configure OpenTelemetry instrumentation for HTTP and PostgreSQL, then add custom spans and metrics around order creation. Prometheus configuration shows how to scrape API servers and expose request-duration metrics at /metrics.

Pino logs request details and redacts authorization headers, passwords, and tokens. The skill also includes alerts for error rate and latency, plus guidance on keeping metric labels bounded and correlating logs with traces. The trace exporters point to otel-collector:4318, so the collector endpoint must match your setup for those examples to send data.

What it helps with

  • trace HTTP requests and PostgreSQL operations
  • instrument a business operation with custom spans and metrics
  • expose request-duration metrics for Prometheus
  • log request fields while redacting secrets
  • alert on error rates and latency

Example prompts for the agent

  • Set up OpenTelemetry instrumentation for HTTP and PostgreSQL in my Node.js service.
  • Add Prometheus metrics for HTTP request duration and expose /metrics.
  • Configure Pino request logs that redact passwords and tokens.

How to install monitoring-observability

1Skills CLI (Vercel)

npx skills add rohitg00/awesome-claude-code-toolkit --skill monitoring-observability -a claude-code

2Manually: put the files in place

~/.claude/skills/monitoring-observability/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/monitoring-observability/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about monitoring-observability

How do I install monitoring-observability in Claude Code?

Run npx skills add rohitg00/awesome-claude-code-toolkit --skill monitoring-observability -a claude-code. The skill file is at ~/.claude/skills/monitoring-observability/SKILL.md.

What does monitoring-observability do?

It provides patterns for OpenTelemetry tracing, Prometheus metrics, structured logging, and alert rules for service monitoring.

Which secrets does the logging example redact?

The Pino setup redacts req.headers.authorization, password, and token. The skill also cautions against using user IDs as metric labels.

Source text

SKILL.md · Apache-2.0
---
name: monitoring-observability
description: Monitoring and observability with OpenTelemetry, Prometheus, Grafana dashboards, and structured logging
---

# Monitoring & Observability

## OpenTelemetry Setup

```typescript
import { NodeSDK } from "@opentelemetry/sdk-node";
import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
import { PgInstrumentation } from "@opentelemetry/instrumentation-pg";
import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";

const sdk = new NodeSDK({
  serviceName: "order-service",
  traceExporter: new OTLPTraceExporter({
    url: "http://otel-collector:4318/v1/traces",
  }),
  metricReader: new PeriodicExportingMetricReader({
    exporter: new OTLPMetricExporter({
      url: "http://otel-collector:4318/v1/metrics",
    }),
    exportIntervalMillis: 15000,
  }),
  instrumentations: [
    new HttpInstrumentation(),
    new PgInstrumentation(),
  ],
});

sdk.start();
process.on("SIGTERM", () => sdk.shutdown());
```

## Custom Spans and Metrics

```typescript
import { trace, metrics, SpanStatusCode } from "@opentelemetry/api";

const tracer = trace.getTracer("order-service");
const meter = metrics.getMeter("order-service");

const orderCounter = meter.createCounter("orders.created", {
  description: "Number of orders created",
});

const orderDuration = meter.createHistogram("orders.processing_duration_ms", {
  description: "Order processing duration in milliseconds",
  unit: "ms",
});

async function createOrder(input: CreateOrderInput) {
  return tracer.startActiveSpan("createOrder", async (span) => {
    try {
      span.setAttributes({
        "order.customer_id": input.customerId,
        "order.item_count": input.items.length,
      });

      const start = performance.now();
      const order = await db.order.create({ data: input });

      orderCounter.add(1, { status: "success" });
      orderDuration.record(performance.now() - start);

      span.setStatus({ code: SpanStatusCode.OK });
      return order;
    } catch (error) {
      span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
      orderCounter.add(1, { status: "error" });
      throw error;
    } finally {
      span.end();
    }
  });
}
```

## Prometheus Metrics

```yaml
# prometheus.yml
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: "api-servers"
    static_configs:
      - targets: ["api-1:9090", "api-2:9090"]
    metrics_path: /metrics

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

```typescript
import { collectDefaultMetrics, Counter, Histogram, Registry } from "prom-client";

const registry = new Registry();
collectDefaultMetrics({ register: registry });

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],
  registers: [registry],
});

app.use((req, res, next) => {
  const end = httpRequestDuration.startTimer();
  res.on("finish", () => {
    end({ method: req.method, route: req.route?.path ?? req.path, status: res.statusCode });
  });
  next();
});

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

## Structured Logging

```typescript
import pino from "pino";

const logger = pino({
  level: process.env.LOG_LEVEL ?? "info",
  formatters: {
    level: (label) => ({ level: label }),
  },
  redact: ["req.headers.authorization", "password", "token"],
});

function requestLogger(req, res, next) {
  const start = Date.now();
  res.on("finish", () => {
    logger.info({
      method: req.method,
      url: req.url,
      status: res.statusCode,
      duration_ms: Date.now() - start,
      trace_id: req.headers["x-trace-id"],
    });
  });
  next();
}
```

## Alerting Rules

```yaml
groups:
  - name: api-alerts
    rules:
      - alert: HighErrorRate
        expr: rate(http_request_duration_seconds_count{status=~"5.."}[5m]) / rate(http_request_duration_seconds_count[5m]) > 0.05
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Error rate above 5% for {{ $labels.route }}"

      - alert: HighLatency
        expr: histogram_quantile(0.99, rate(http_request_duration_seconds_bucket[5m])) > 2
        for: 10m
        labels:
          severity: warning
```

## Anti-Patterns

- Logging sensitive data (passwords, tokens, PII) without redaction
- Using string interpolation in log messages instead of structured fields
- Creating unbounded cardinality in metric labels (e.g., user IDs as labels)
- Not correlating logs and traces with a shared trace ID
- Alerting on symptoms (high CPU) without understanding root cause
- Missing SLO definitions before building dashboards

## Checklist

- [ ] OpenTelemetry SDK initialized with auto-instrumentation for HTTP, DB, and messaging
- [ ] Custom spans added for business-critical operations
- [ ] Metrics use bounded label cardinality
- [ ] Structured logging with JSON output and secret redaction
- [ ] Trace context propagated across service boundaries
- [ ] Alerting rules based on SLOs (error rate, latency percentiles)
- [ ] Dashboards show RED metrics (Rate, Errors, Duration) per service
- [ ] Log retention and rotation policies configured

© rohitg00 · Apache-2.0 · rohitg00/awesome-claude-code-toolkit

Similar skills

All skills for DevOps and infrastructure →

monitoring-observability by other authors comes first.

monitoring-observability ahmedasmar monitoring-observability — a skill for building monitoring and observability: metrics strategy, alerts, dashboards, SLOs and incident troubleshooting. CX Codex +1 504installs monitoring-observability OrchestKit monitoring-observability — a skill for Claude Code that configures Prometheus metrics, Grafana dashboards, and Langfuse v4 tracing. Activates when adding logging, distributed tracing, or LLM cost tracking. CX Codex +1 270installs monitoring-observability akillness monitoring-observability turns service, data-pipeline, or live-ops context into a monitoring brief with a primary mode, useful signals, and a small first implementation slice. CX Codex +1 371installs monitoring-observability travisjneuman monitoring-observability equips AI coding agents to set up OpenTelemetry, structured JSON logging, and distributed tracing. Useful when defining SLO alerts or instrumenting services. CX Codex +1 146installs monitoring-expert https://github.com/Jeffallan monitoring-expert — a skill that walks your agent through setting up metrics, structured logs, tracing and alerts. Useful when production is slow and you need to find out why. CX Codex +1 6,200installs implementing-observability ancoleman The implementing-observability skill wires metrics, logs and traces through OpenTelemetry and shows how to run Loki, Grafana, Tempo and Mimir yourself. Useful once one request crosses several services. CX Codex +1 1installs setup-monitoring-observability davila7 The setup-monitoring-observability command inspects a project and guides setup for metrics, logs, tracing, and alerts. Choose one area or request the full observability stack. CX Codex +1 279installs monitoring-specialist davila7 monitoring-specialist is a Claude Code subagent for monitoring and observability work. It handles requests about metrics, alerting, log aggregation, and distributed tracing. CX Codex 1,677installs observability-sre majiayu000 The observability-sre skill guides monitoring, SLO design, tracing, logging, and incident response. Use it when a project needs Prometheus, Grafana, or OpenTelemetry practices. CX Codex +1 165installs observability-setup patricio0312rev observability-setup brings OpenTelemetry tracing, Prometheus metrics and structured logging into one setup, with a Grafana dashboard and starter alert rules attached. CX Codex +1 289installs

From the same set178

The whole set →
healthcare-engineer healthcare-engineer designs HIPAA-compliant architectures and HL7 FHIR interfaces. Useful when connecting EHR platforms, mapping clinical vocabularies, or de-identifying records. CX Codex ★ 2,858repo stars continuous-learning The continuous-learning skill turns session corrections and successful approaches into reusable project knowledge. It helps when you want the agent to account for earlier feedback. CX Codex +1 ★ 2,858repo stars developer-portal Subagent for building internal developer portals using Backstage with service catalogs, project templates, and self-service infrastructure provisioning. Replaces scattered wikis and manual setup with unified discovery and CI/CD integration. CX Codex ★ 2,858repo stars websocket-realtime websocket-realtime provides real-time communication patterns for Claude Code, covering raw WebSocket implementations, Socket.io rooms, SSE, and Redis scaling. CX Codex +1 ★ 2,858repo stars database-optimizer database-optimizer — a subagent that diagnoses slow queries, designs indexes, implements partitioning schemes, and plans capacity for PostgreSQL, MySQL, and distributed databases. CX Codex ★ 2,858repo stars accessibility-wcag The accessibility-wcag skill for Claude Code provides WCAG 2.2 patterns for semantic HTML, ARIA dialogs, keyboard navigation, and color contrast. CX Codex +1 ★ 2,858repo stars content-strategist The content-strategist subagent plans SEO content, groups topics into clusters, and connects publishing work to performance metrics. It targets technical products and developer audiences. CX Codex ★ 2,858repo stars authentication-patterns authentication-patterns is a Claude Code skill with authentication and authorization patterns: JWT, OAuth2 with PKCE, role-based access control, and Express middleware. For securing a Node.js backend. CX Codex +1 ★ 2,858repo stars

More in the catalog

Project sponsors

Companies that keep this analytics open