home / skills / jeremylongshore / claude-code-plugins-plus-skills / monitoring-apis

monitoring-apis skill

/plugins/api-development/api-monitoring-dashboard/skills/monitoring-apis

This skill helps you build and maintain real-time API monitoring dashboards with metrics, alerts, and health checks.

npx playbooks add skill jeremylongshore/claude-code-plugins-plus-skills --skill monitoring-apis

Review the files below or copy the command above to add this skill to your agents.

Files (4)

SKILL.md

2.4 KB

---
name: monitoring-apis
description: |
  Build real-time API monitoring dashboards with metrics, alerts, and health checks.
  Use when tracking API health and performance metrics.
  Trigger with phrases like "monitor the API", "add API metrics", or "setup API monitoring".
  
allowed-tools: Read, Write, Edit, Grep, Glob, Bash(api:monitor-*)
version: 1.0.0
author: Jeremy Longshore <[email protected]>
license: MIT
---

# Monitoring Apis

## Overview


This skill provides automated assistance for api monitoring dashboard tasks.
This skill provides automated assistance for the described functionality.

## Prerequisites

Before using this skill, ensure you have:
- API design specifications or requirements documented
- Development environment with necessary frameworks installed
- Database or backend services accessible for integration
- Authentication and authorization strategies defined
- Testing tools and environments configured

## Instructions

1. Use Read tool to examine existing API specifications from {baseDir}/api-specs/
2. Define resource models, endpoints, and HTTP methods
3. Document request/response schemas and data types
4. Identify authentication and authorization requirements
5. Plan error handling and validation strategies
1. Generate boilerplate code using Bash(api:monitor-*) with framework scaffolding
2. Implement endpoint handlers with business logic
3. Add input validation and schema enforcement
4. Integrate authentication and authorization middleware
5. Configure database connections and ORM models
1. Write integration tests covering all endpoints


See `{baseDir}/references/implementation.md` for detailed implementation guide.

## Output

- `{baseDir}/src/routes/` - Endpoint route definitions
- `{baseDir}/src/controllers/` - Business logic handlers
- `{baseDir}/src/models/` - Data models and schemas
- `{baseDir}/src/middleware/` - Authentication, validation, logging
- `{baseDir}/src/config/` - Configuration and environment variables
- OpenAPI 3.0 specification with complete endpoint definitions

## Error Handling

See `{baseDir}/references/errors.md` for comprehensive error handling.

## Examples

See `{baseDir}/references/examples.md` for detailed examples.

## Resources

- Express.js and Fastify for Node.js APIs
- Flask and FastAPI for Python APIs
- Spring Boot for Java APIs
- Gin and Echo for Go APIs
- OpenAPI Specification 3.0+ for API documentation

Overview

This skill helps you build real-time API monitoring dashboards with metrics, alerts, and health checks. It automates the setup of metric collection, dashboard panels, alert rules, and basic health endpoints. Use it to turn API specs and codebases into observable services quickly.

How this skill works

The skill inspects API specifications, endpoint definitions, and project scaffolding to identify key metrics and health probes to expose. It generates monitoring artifacts such as metric instruments, alert rules, dashboard panels, and health-check endpoints, and suggests integration points for middleware and exporters. It also outlines tests and configuration needed to wire metrics into a monitoring stack.

When to use it

When you need live visibility into API latency, error rates, throughput, and resource usage
When launching or operating production APIs that require SLOs and alerts
When integrating APIs with Prometheus, Grafana, or other observability tools
When converting OpenAPI specs into monitored endpoints and health checks
When adding automated alerting for regressions after deployments

Best practices

Start from documented API specs and resource models to identify critical transactions and endpoints
Instrument at both request-level (latency, status codes) and system-level (CPU, memory, DB latency) metrics
Define meaningful alert thresholds and use burn-in windows to avoid noisy alerts
Expose standardized health endpoints (readiness/liveness) and attach simple probes in orchestration layers
Write integration tests for metrics and alerts to validate telemetry after changes

Example use cases

Generate Prometheus-compatible metric instruments for all endpoints and create Grafana dashboards for latency and error trends
Add readiness and liveness endpoints with dependency checks (DB, cache, external APIs) and wire them to Kubernetes probes
Create alert rules for high error rates, elevated p95 latency, and low request throughput with automated notification channels
Scaffold middleware to record timing, request counts, and status buckets for new API routes
Produce OpenAPI-driven monitoring lists that prioritize endpoints to monitor and test after deployment

FAQ

What inputs does this skill need to start?

Provide API specifications (OpenAPI/OpenAPI-like), project structure, and authentication details so the skill can map endpoints to monitoring targets.

Which monitoring stacks are supported?

The guidance and artifacts target common stacks like Prometheus and Grafana and include patterns applicable to other exporters or APM tools.