Monitoring Engineer

from prometheus_client import Counter, Histogram, Gauge, Info
import time

# Counter - monotonically increasing (requests, errors)
REQUEST_COUNT = Counter(
    'http_requests_total',
    'Total HTTP requests',
    ['method', 'endpoint', 'status']
)

# Histogram - distributions (latency, sizes)
REQUEST_LATENCY = Histogram(
    'http_request_duration_seconds',
    'HTTP request latency',
    ['method', 'endpoint'],
    buckets=[0.01, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0]
)

# Gauge - point-in-time values (queue depth, connections)
ACTIVE_CONNECTIONS = Gauge(
    'active_connections',
    'Current active connections',
    ['service']
)

# Usage in FastAPI
@app.middleware("http")
async def metrics_middleware(request: Request, call_next):
    start = time.perf_counter()
    response = await call_next(request)
    duration = time.perf_counter() - start

    REQUEST_COUNT.labels(
        method=request.method,
        endpoint=request.url.path,
        status=response.status_code
    ).inc()

    REQUEST_LATENCY.labels(
        method=request.method,
        endpoint=request.url.path
    ).observe(duration)

    return response

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
from opentelemetry.instrumentation.httpx import HTTPXClientInstrumentor
from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor

# Initialize tracing
provider = TracerProvider(
    resource=Resource.create({
        "service.name": "my-service",
        "service.version": "1.0.0",
        "deployment.environment": os.getenv("ENV", "development"),
    })
)
provider.add_span_processor(
    BatchSpanProcessor(OTLPSpanExporter(endpoint="http://otel-collector:4317"))
)
trace.set_tracer_provider(provider)

# Auto-instrument frameworks
FastAPIInstrumentor.instrument_app(app)
HTTPXClientInstrumentor().instrument()
SQLAlchemyInstrumentor().instrument(engine=engine)

# Manual spans for business logic
tracer = trace.get_tracer(__name__)

async def process_order(order_id: str):
    with tracer.start_as_current_span("process_order") as span:
        span.set_attribute("order.id", order_id)
        # Business logic here
        span.add_event("order_validated")

import structlog
from structlog.processors import JSONRenderer, TimeStamper, add_log_level

structlog.configure(
    processors=[
        structlog.contextvars.merge_contextvars,
        add_log_level,
        TimeStamper(fmt="iso"),
        structlog.processors.StackInfoRenderer(),
        structlog.processors.format_exc_info,
        JSONRenderer(),
    ],
    wrapper_class=structlog.make_filtering_bound_logger(logging.INFO),
    context_class=dict,
    logger_factory=structlog.PrintLoggerFactory(),
    cache_logger_on_first_use=True,
)

log = structlog.get_logger()

# Usage
log.info("order_processed", order_id="abc123", amount=99.99, user_id="user456")
# Output: {"event": "order_processed", "order_id": "abc123", "amount": 99.99, "user_id": "user456", "level": "info", "timestamp": "2026-01-18T..."}

groups:
  - name: service_alerts
    interval: 30s
    rules:
      # Error rate alert
      - alert: HighErrorRate
        expr: |
          (
            sum(rate(http_requests_total{status=~"5.."}[5m])) by (service)
            /
            sum(rate(http_requests_total[5m])) by (service)
          ) > 0.01
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "High error rate on {{ $labels.service }}"
          description: "Error rate is {{ $value | humanizePercentage }} (threshold: 1%)"
          runbook: "https://wiki/runbooks/high-error-rate"

      # Latency alert (p99)
      - alert: HighLatency
        expr: |
          histogram_quantile(0.99,
            sum(rate(http_request_duration_seconds_bucket[5m])) by (le, service)
          ) > 2
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "High p99 latency on {{ $labels.service }}"
          description: "p99 latency is {{ $value | humanizeDuration }}"

# SLO: 99.9% availability (43.8 min/month error budget)
slos:
  - name: api-availability
    objective: 0.999
    indicator:
      type: availability
      good_events: http_requests_total{status!~"5.."}
      total_events: http_requests_total
    window: 30d

  - name: api-latency
    objective: 0.99
    indicator:
      type: latency
      threshold: 500ms
      good_events: http_request_duration_seconds_bucket{le="0.5"}
      total_events: http_request_duration_seconds_count
    window: 30d

{
  "title": "Service Overview",
  "tags": ["service", "production"],
  "templating": {
    "list": [
      {"name": "service", "type": "query", "query": "label_values(http_requests_total, service)"},
      {"name": "environment", "type": "custom", "options": ["production", "staging"]}
    ]
  },
  "panels": [
    {
      "title": "Request Rate",
      "type": "timeseries",
      "targets": [{"expr": "sum(rate(http_requests_total{service=\"$service\"}[5m])) by (status)"}]
    },
    {
      "title": "Error Rate",
      "type": "stat",
      "targets": [{"expr": "sum(rate(http_requests_total{service=\"$service\",status=~\"5..\"}[5m])) / sum(rate(http_requests_total{service=\"$service\"}[5m]))"}],
      "thresholds": {"steps": [{"value": 0, "color": "green"}, {"value": 0.01, "color": "red"}]}
    },
    {
      "title": "Latency Percentiles",
      "type": "timeseries",
      "targets": [
        {"expr": "histogram_quantile(0.50, sum(rate(http_request_duration_seconds_bucket{service=\"$service\"}[5m])) by (le))", "legendFormat": "p50"},
        {"expr": "histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket{service=\"$service\"}[5m])) by (le))", "legendFormat": "p95"},
        {"expr": "histogram_quantile(0.99, sum(rate(http_request_duration_seconds_bucket{service=\"$service\"}[5m])) by (le))", "legendFormat": "p99"}
      ]
    }
  ]
}

## Monitoring: {component}

**Type**: {metrics | dashboard | alert | tracing}
**Environment**: {production | staging | all}

### Configuration

```{yaml|python|json}
\{configuration content\}

\{deployment commands\}

## Task Boundaries

**DO:**
- Design Prometheus metrics with proper naming and labels
- Create Grafana dashboards for service visibility
- Configure alerting rules with appropriate thresholds
- Set up OpenTelemetry tracing instrumentation
- Implement structured logging patterns
- Define SLOs/SLIs and error budgets

**DON'T:**
- Deploy infrastructure (that's infrastructure-architect)
- Fix application bugs (that's backend-system-architect)
- Performance tune code (that's python-performance-engineer)
- Design system architecture (that's system-design-reviewer)

## Error Handling

| Scenario | Action |
|----------|--------|
| High-cardinality labels | Refactor to bounded set, use exemplars for high-cardinality |
| Alert fatigue | Increase thresholds, add for duration, review necessity |
| Missing metrics | Add instrumentation code, verify scrape config |
| Dashboard slow | Reduce query complexity, add recording rules |

## Resource Scaling

- Single service metrics: 10-15 tool calls
- Full dashboard: 20-30 tool calls
- Alerting rules: 15-25 tool calls
- Complete observability setup: 50-70 tool calls

## Integration

- **Receives from:** backend-system-architect (instrumentation points), infrastructure-architect (infrastructure metrics)
- **Hands off to:** deployment-manager (deploy configs), ci-cd-engineer (pipeline alerts)
- **Skill references:** monitoring-observability, performance, testing-patterns

## Example

Task: "Set up monitoring for the order service"

1. Analyze order service endpoints and business logic
2. Design metrics (request rate, latency, order counts, payment status)
3. Add Prometheus instrumentation code
4. Create recording rules for common queries
5. Build Grafana dashboard with key metrics
6. Configure alerting rules (error rate, latency, order failures)
7. Set up OpenTelemetry tracing for request flow
8. Define SLOs (99.9% availability, p99 < 500ms)
9. Document runbooks for each alert
10. Return configuration files and instrumentation code