100 Monitoring & Observability resources for developers

Implement the Sentry SDK to capture unhandled exceptions and performance bottlenecks. Use the 'breadcrumbs' feature to reconstruct the state leading to a crash.

Deploy Prometheus for scraping metrics from exporters. Use it to store system-level data like CPU/RAM and custom application business metrics.

Connect Prometheus and Loki data sources to build real-time dashboards. Use community templates for Node Exporter and PostgreSQL monitoring.

Configure external heartbeat monitoring and status pages. Integrate with Slack to receive immediate notification if the public endpoint fails.

A high-performance, cost-effective drop-in replacement for Prometheus. Use it for long-term storage of metrics with better compression ratios.

Deploy Vector as a sidecar or aggregator to collect, transform, and route logs from various sources to Loki, S3, or Datadog.

A horizontally scalable, highly available, multi-tenant log aggregation system inspired by Prometheus. It indexes metadata rather than the full log content.

Write Playwright scripts to simulate user flows in production. Checkly runs these on a schedule to ensure critical paths (like checkout) work.

Install on individual nodes for per-second granularity monitoring. Ideal for troubleshooting immediate performance spikes on specific servers.

Open-source full-stack monitoring that includes session replay, allowing you to see exactly what the user did before an error occurred.

Route OpenAI or Anthropic requests through Helicone to get an instant dashboard of costs, latency, and request/response logs.

Use LangChain's observability tool to debug complex chains. It visualizes the inputs and outputs of every step in your LLM pipeline.

A unified interface to call 100+ LLMs. Use its logging feature to export data to S3, Langfuse, or Mixpanel for centralized analysis.

Self-hostable alternative for LLM application tracing. It provides specific metrics for token usage and latency across different model providers.

An open-source library for ML observability that helps in evaluating LLM responses and detecting embedding drift in vector databases.

Control your LLM traffic with features like fallback, retries, and load balancing while collecting detailed observability data.

Run test cases against your prompts to measure output quality and regression before deploying new prompt versions to production.

Visualize the execution flow of your LLM programs and track model performance over time with their specialized prompt logging.

Open-source observability for LLMs including cost tracking, user analytics, and prompt versioning in a single dashboard.

A developer platform to debug, test, and monitor LLM apps. It allows you to run evaluations on production data to find edge case failures.

Set up a central collector to receive OTLP data and export it to multiple backends simultaneously (e.g., Jaeger and Datadog).

Deploy Jaeger to visualize the path of a request across microservices. Essential for finding latency bottlenecks in complex AI pipelines.

An open-source alternative to Datadog that combines metrics, traces, and logs in one UI, built on top of OpenTelemetry and ClickHouse.

Use Honeycomb for debugging complex systems where you need to group by user ID, request ID, or other high-cardinality fields.

A high-scale distributed tracing backend that is deeply integrated with Grafana and Loki, allowing you to jump from logs to traces.

An open-source distributed tracing tool that uses ClickHouse to store data and provides an easy-to-use UI for OTel data analysis.

An open-source tool that correlates logs and traces automatically, making it easier to find the root cause of an error in a microservice.

Utilize ClickHouse as the storage engine for logs and traces due to its superior columnar compression and query performance for analytical data.

Use OTel zero-code instrumentation for Java, Python, or Node.js to start collecting traces without modifying your application code.

Integrate Pyroscope to continuously monitor CPU and memory usage at the function level, identifying lines of code causing performance regressions.