Monitoring

Grafana73.6k★

Grafana connects to everything and makes the data useful. It doesn't store data itself. It connects to Prometheus, Postgres, Elasticsearch, CloudWatch, and 100+ other data sources, then lets you build dashboards that pull it together. What's free: Self-hosted Grafana is fully featured. AGPL license. Unlimited dashboards, unlimited data sources, unlimited users, alerting, annotations, plugins. All free. Grafana is the standard for observability dashboards. Used everywhere from startups to NASA. The visualization options are deep: time series, heatmaps, tables, logs, traces, geo maps. The alerting system sends notifications to Slack, PagerDuty, email, webhooks. The plugin ecosystem adds custom panels and data sources. The catch: the AGPL license means if you modify Grafana and offer it as a service, you must open-source your changes. For internal use this doesn't matter, but SaaS companies building on Grafana need to be careful. Self-hosted Grafana also needs a data source. It doesn't do anything alone. You need Prometheus for metrics, Loki for logs, Tempo for traces. Each is its own system to operate.

Prometheus64.0k★

Prometheus collects metrics from your infrastructure and applications, stores them as time series, and lets you query and alert on them before your users notice things are broken. It's the monitoring standard: when someone says "metrics" in a cloud-native context, they mean Prometheus. You instrument your app to expose metrics at an endpoint, Prometheus scrapes those endpoints on a schedule, and you query the data with PromQL. Pair it with Grafana for dashboards and Alertmanager for notifications. The entire CNCF monitoring stack is built around Prometheus. Apache 2.0, CNCF graduated. The industry default. The catch: Prometheus is single-node by design. It doesn't scale horizontally out of the box. If you need long-term storage or multi-cluster federation, you bolt on Thanos, Cortex, or VictoriaMetrics, each adding complexity. PromQL has a learning curve. And the pull-based model (Prometheus scrapes your services) doesn't work well for short-lived jobs or serverless; you need a Pushgateway workaround. Despite all this, it's still the right choice for 90% of teams.

Sentry43.8k★

Sentry catches errors in production and tells you the user who hit it, the browser they used, and the sequence of events leading up to it. Sentry catches errors in real-time and gives you everything you need to fix them. It's error tracking that actually works across every platform: JavaScript, Python, Go, Ruby, mobile, you name it. Python-based backend. Sentry invented the modern error tracking category. Beyond exceptions, it does performance monitoring (slow transactions, database queries), session replay, profiling, and cron monitoring. SDKs for 100+ platforms. The free cloud tier is generous: 5K errors/month, 10K performance transactions, 500 session replays, 1 user. Paid starts at $26/mo (Team) for 50K errors, 100K transactions, unlimited members. Business at $80/mo adds SSO, custom dashboards, and higher quotas. Self-hosting is possible but the license changed. Sentry uses a functional source-available license (FSL/BSL). You can run it, but you can't sell a hosted version of it. Self-hosting requires Docker Compose with 16GB+ RAM minimum. It's a real deployment. Solo developers: free cloud tier. It's enough for side projects and early-stage apps. Small teams: $26/mo Team plan, absolutely worth it. The time saved on a single production debugging session pays for a year. Medium to large: Business at $80+/mo for SSO and advanced features. The catch: the free tier's 5K error limit gets eaten fast if you have noisy exceptions. Rate limiting and filtering are essential. Self-hosting is possible but heavy: Kafka, ClickHouse, Redis, Postgres, Snuba, Relay. Budget 8+ hours/month of ops. Most teams are better off paying for cloud.

SigNoz26.9k★

SigNoz gives you performance traces, error rates, and system metrics in one dashboard. It's built on OpenTelemetry (the open standard for collecting observability data), which means you're not locked into a proprietary SDK. Your instrumentation works with any compatible backend. The self-hosted version is free with all features. The managed cloud starts at $199/mo for the Teams plan. Both use the same codebase, nothing is held back from self-hosters. Self-hosting runs on Docker or Kubernetes with ClickHouse as the storage backend. This is the main ops consideration. ClickHouse is powerful but needs resources. Plan for a VM with 8GB+ RAM minimum and growing storage. Setup takes 2-4 hours. Solo developers: the cloud free tier or a small self-hosted instance works. Small teams: self-host if you have ops capacity, otherwise cloud Teams at $199/mo replaces Datadog bills 10x higher. Growing teams: this is SigNoz's pitch: Datadog-level visibility at a fraction of the cost. The catch: SigNoz is younger than Grafana/Prometheus and the plugin ecosystem is smaller. If you need 200 pre-built integrations and dashboards, Grafana's ecosystem is unmatched. If you want a unified logs-traces-metrics platform without stitching three tools together, SigNoz is cleaner.

SkyWalking24.8k★

Apache SkyWalking traces requests end-to-end across your microservices so you can find where things are slow, failing, or misbehaving. It's an Application Performance Monitoring (APM) system that shows you traces, metrics, and logs across your entire architecture. Apache 2.0, CNCF project. SkyWalking supports auto-instrumentation for Java.NET, Node.js, Python, Go, and more, meaning you often don't need to change your code. Agents attach to your services and report back to the SkyWalking backend. Fully free. No paid tier, no commercial edition. You self-host everything: the OAP (Observability Analysis Platform) server, the UI, and the storage backend (Elasticsearch, BanyanDB, or PostgreSQL). The catch: SkyWalking is powerful but operationally heavy. You need the OAP server, a storage backend, and agents on every service. The Java auto-instrumentation is excellent; other languages vary in coverage. The UI is functional but not as polished as Datadog or Grafana. And the documentation assumes familiarity with distributed tracing concepts, not beginner-friendly.

Jaeger22.8k★

It's a distributed tracing platform: it tracks requests as they flow through your services, showing you exactly where time is spent. Service A calls Service B calls Service C, and Jaeger draws the full timeline. CNCF graduated project, originally built by Uber. It collects traces from your services, stores them, and gives you a UI to search and visualize request flows. Supports OpenTelemetry natively, which means you instrument your code once and can switch tracing backends later. Apache 2.0. Fully free, no paid tier. The catch: running Jaeger in production is real ops work. You need a storage backend (Elasticsearch, Cassandra, or Kafka), and those have their own operational costs. The UI is functional but not pretty; teams that want polished dashboards often export traces to Grafana. For small deployments, SigNoz bundles tracing, metrics, and logs in one tool and may be simpler to start with.

Zipkin17.4k★

Zipkin shows you exactly where time is spent when a request crosses multiple services. It's a distributed tracing system: each service reports timing data, and Zipkin stitches it into a visual timeline showing the full request journey. When something is slow, you see which service is the bottleneck. Fully free under Apache 2.0. It's been around since 2012 (originally from Twitter) and is battle-tested at enormous scale. Storage backends include in-memory, MySQL, Cassandra, and Elasticsearch. The UI is simple but functional: search traces by service, duration, or tags. The catch: Zipkin is traces-only. No metrics, no logs, no dashboards. Modern observability stacks (Grafana + Tempo, SigNoz, Uptrace) bundle all three. If you're starting fresh, Jaeger (also CNCF, also free) has a more modern architecture and better Kubernetes integration. Zipkin's advantage is maturity and simplicity: it does one thing and has been doing it for over a decade.

VictoriaMetrics17.0k★

VictoriaMetrics is a Prometheus drop-in replacement that uses 7-10x less memory and compresses data up to 70x better. Same PromQL queries, same Grafana dashboards, just cheaper to run. Apache 2.0, Go. It accepts data from Prometheus remote write, InfluxDB line protocol, OpenTelemetry, Graphite, and more. Single-binary deployment, no ZooKeeper, no dependencies. Download, run, point Prometheus at it. Single-node version is fully free with no feature restrictions. The cluster version (horizontal scaling) is also open source. VictoriaMetrics Cloud offers managed hosting starting around $0.01/1K active time series/month. Self-hosting ops: trivial for single-node. Download the binary, set a data directory, done. 1-2 hours/month. Cluster mode bumps that to moderate. You manage vmselect, vminsert, and vmstorage components. Solo through medium teams: single-node handles millions of time series on modest hardware. Large orgs: cluster mode or VictoriaMetrics Cloud. The catch: VictoriaMetrics is optimized for time series, not general-purpose queries. Some advanced PromQL features behave slightly differently. And while the community is growing, Prometheus + Thanos has a larger ecosystem of integrations and community knowledge.

cachet15.0k★

Cachet is a self-hosted status page system that lets you communicate downtime and incidents to your users without depending on a third-party service. It handles components, incidents, scheduled maintenance, metrics, and subscriber notifications. Clean UI, straightforward setup. Runs on PHP 8.2+ with MySQL, PostgreSQL, or SQLite. Docker setup is available. The v3 rewrite modernized the codebase, but the project has had stretches of slow development. If you are comfortable with Laravel apps, maintaining this is routine. If not, expect some hands-on time with PHP dependency management. Solo devs and small teams: this is free and covers the basics well. For larger orgs, you lose the integrations that paid tools like Statuspage offer out of the box (deep PagerDuty/Datadog hooks, SLA reporting, global CDN distribution). The catch: development has been inconsistent. The v3 rewrite took years. If you need an actively maintained status page with guaranteed updates, look at Upptime or Gatus instead.

systeminformer14.6k★

System Informer is what Windows Task Manager should have been. It shows every process, thread, DLL, network connection, and service on your machine with real-time graphs and drill-down detail that Microsoft's built-in tools never bothered to provide. This is the successor to Process Hacker, rebuilt from the ground up. No installation required. It runs portable from a USB stick. You get per-process CPU, memory, disk, and network breakdowns. Kernel-mode stack traces and .NET process inspection are built in. You can see exactly which process is holding a file lock. The plugin system lets you extend it. Developers debugging performance issues on Windows need this. Sysadmins diagnosing rogue processes need this. Security researchers analyzing malware behavior need this. It replaces Task Manager, Resource Monitor, and most of Sysinternals Process Explorer in a single tool. The catch: Windows only, local only. No remote monitoring, no fleet management, no centralized dashboard. Monitoring servers across a network requires something else entirely.

Thanos14.1k★

Thanos extends Prometheus into a highly available, horizontally scalable monitoring system with long-term retention and cross-cluster querying. It sits on top of your existing Prometheus setup and adds what Prometheus deliberately left out. You keep your Prometheus instances. Thanos adds a global query view across all of them, long-term storage in object storage (S3, GCS, Azure Blob), downsampling for historical queries, and high availability through deduplication. It's not a replacement; it's the scaling layer. Apache 2.0, CNCF project. Production-proven at companies running hundreds of Prometheus instances. The catch: Thanos adds real operational complexity. You're running Thanos Sidecar, Store Gateway, Compactor, Query Frontend. Each is a separate component to deploy and monitor. The irony of needing monitoring for your monitoring system is not lost on anyone. If you have fewer than 3 Prometheus instances, you probably don't need this yet.

keep11.8k★

Keep pulls alerts from every monitoring tool you use into one screen. Datadog, Grafana, CloudWatch, PagerDuty, Sentry: it connects to all of them with bi-directional integrations. The real value is noise reduction. It deduplicates alerts, correlates related incidents, and enriches them with context so your on-call engineer is not drowning in redundant pages at 3am. You get workflow automation that works like GitHub Actions for your monitoring stack: trigger responses, route alerts, escalate based on rules you define. The enterprise tier adds AI-powered correlation. Self-hosting gives you the full MIT-licensed core with unlimited alerts and integrations. The managed cloud starts free but caps you at 1 integration and 1 user, basically a demo. Growth tier at $199/month gets you 20 integrations and 10 users. PagerDuty and Opsgenie charge per-user and get expensive fast. Keep undercuts both if you self-host. The catch: the free cloud tier is too limited to evaluate properly. You need to self-host or commit to Growth to really test it.

Crucix9.7k★

Crucix continuously monitors data sources you define and alerts you when something matches your criteria. It's a personal intelligence agent that does the monitoring you'd otherwise do manually across dozens of tabs. You configure what to watch (websites, APIs, RSS feeds, social media) and what counts as important. When something matches your criteria, it sends you a notification. It's Google Alerts on steroids, running locally and customizable to any data source. AGPL-3.0 licensed, JavaScript. The catch: AGPL-3.0 means if you modify it and offer it as a service, you must open source your changes. The 'watches everything' promise requires you to configure everything. There's no magic default that just works. You need to define your sources, your triggers, and your notification channels. And running continuous monitoring means this needs to be always-on somewhere: your machine, a VPS, or a container.

Highlight9.3k★

Highlight captures errors, session replays, and logs together so you see the full picture when something goes wrong in production. Basically Sentry plus LogRocket combined, but open source. TypeScript. Self-hostable via Docker. The session replay alone is worth evaluating: it records user interactions so you can see exactly what happened before an error. Plus error monitoring, log aggregation, and distributed tracing. Free tier on their cloud: 500 sessions, 1M logs, and 1M traces per month. That's enough for a small app. Self-hosting is free with no feature restrictions. Paid cloud starts at $150/mo for the Team plan with higher limits. Enterprise pricing is custom. The jump from free to paid is steep: $0 to $150/mo with nothing in between. Solo developers: the free cloud tier handles a side project easily. Self-hosting saves money but needs Docker Compose and a few hours of setup. Small teams (2-10): free tier might be tight; self-host or budget for Team plan. Growing teams: $150/mo for unified monitoring is actually reasonable vs buying Sentry + LogRocket + Datadog separately. The catch: the $0-to-$150 gap means growing startups either self-host or pay enterprise-adjacent prices. And while Highlight covers breadth, dedicated tools like Sentry (errors) or Grafana (dashboards) go deeper in their specific domains.

OpenTelemetry Collector7.0k★

The OpenTelemetry Collector is the vendor-neutral middleman that collects logs, metrics, and traces from your applications and routes them wherever you want. Instead of installing five different agents for five different observability tools, you install one Collector and configure where data goes. Switch backends without changing your app code. Apache 2.0. CNCF project backed by every major observability vendor. The Collector receives telemetry data, processes it (filter, transform, sample, batch), and exports it to one or more backends simultaneously. Fully free. No paid tier. The Collector itself is just the pipeline. You still need somewhere to send data (Grafana stack is free self-hosted, or pay for Datadog/New Relic/etc.). The Collector runs as a sidecar, DaemonSet, or standalone deployment. The contrib distribution includes 200+ receivers, processors, and exporters for every major backend. The catch: configuration is YAML-based and gets complex fast. Debugging pipeline issues (why aren't my traces showing up?) requires understanding the receiver-processor-exporter chain. And the Collector is infrastructure you need to monitor. Yes, you need observability for your observability pipeline.

Uptrace4.2k★

Uptrace gives you traces, metrics, and logs in one place so you can see which services are failing and how errors propagate. It's an APM (application performance monitoring) tool built on OpenTelemetry, which means it works with almost any language and framework. Self-hosting is free under AGPL-3.0. You get the full tracing UI, alerting, and dashboards. The setup requires ClickHouse for storage (that's the heavy part), but once running, it handles millions of spans without breaking a sweat. The catch: AGPL license means if you modify Uptrace and offer it as a service, you must open-source your changes. The hosted cloud version exists but pricing isn't publicly listed. You have to contact sales. And while OpenTelemetry compatibility is great, the ecosystem is still maturing. Expect some rough edges with auto-instrumentation for newer frameworks.

pyrra1.5k★

Pyrra makes it manageable. You define your SLO (service level objective, like 'this API should succeed 99.9% of the time') and Pyrra generates the Prometheus recording rules, alerts, and dashboards automatically. Everything is free under Apache 2.0. No paid tier, no cloud, no account. It runs alongside your existing Prometheus stack and integrates with Grafana for visualization. The catch: this is a niche tool. If you're not already running Prometheus, Pyrra adds no value: it's specifically an SLO layer on top of Prometheus/Thanos. The reflect that narrow audience. And SLOs only matter if your team actually acts on error budget alerts. Pyrra generates the math and the alerts, but the organizational discipline to respond is on you.

newrelic-ruby-agent1.2k★

The New Relic Ruby agent instruments your app and sends telemetry to New Relic's platform. It's the data collector, not the dashboard. Apache 2.0. This is the open source agent that plugs into your Ruby app. The agent itself is free to use. What you pay for is the New Relic platform that stores, queries, and visualizes the data. New Relic's free tier gives you 100GB of data ingestion per month, one full-platform user, and unlimited basic users. That's generous. A small Rails app's telemetry easily fits in 100GB. Paid plans start at $0.35/GB ingested beyond the free tier, plus $49/user/mo for full-platform access. The catch: you're instrumenting your app for a proprietary SaaS platform. The agent is open source, but the value is in New Relic's platform, which is not. If New Relic changes pricing (they have before), you're locked in. For Ruby specifically, the agent adds overhead. Expect 2-5% latency impact. And the open source alternative ecosystem is strong: OpenTelemetry + Grafana gives you similar visibility without the vendor lock-in.

kuvasz516★

Kuvasz is a self-hosted uptime monitor. It checks your endpoints on a schedule, measures response times, and alerts you when something breaks. That's it. Does one thing, does it cleanly. Kotlin, Apache 2.0. Built on Quarkus (a Java framework optimized for containers). Supports HTTP monitoring with configurable check intervals, Slack and Telegram notifications, and SSL certificate expiry monitoring. Stores historical data in Postgres. Fully free, self-hosted only. No cloud version, no paid tier. Run it in Docker alongside a Postgres instance and you're set. Solo developers: Docker Compose with Kuvasz + Postgres monitors your side projects for the cost of a $5/mo VPS. Small teams: same setup, more endpoints. Medium to large teams: you'll likely want something with more features: dashboards, incident management, status pages. The catch: this is a small, niche project. The feature set is minimal compared to Uptime Kuma (which has a much larger community) or commercial tools. No status page, no multi-region checking, no advanced alerting rules. If basic HTTP monitoring and SSL checks are all you need, Kuvasz works. For anything more, look at the alternatives.

GlitchTip0★

GlitchTip is the lightweight Sentry alternative that uses Sentry's own SDKs. Swap one environment variable (the DSN endpoint) and your existing Sentry instrumentation starts sending errors to GlitchTip instead. Error grouping, deduplication, and a searchable issue queue cover the core workflow. Performance monitoring is included. Self-hosting needs just 256MB RAM for a minimal Docker setup with PostgreSQL. No Redis required for small deployments. One-click deploys are available on PikaPods and Railway. The Django backend keeps things simple and the unlimited projects/team members policy means no per-seat billing surprises. Small teams who only need error tracking without Sentry's full observability suite save real money here. Solo developers get production error monitoring for free. Teams outgrowing Sentry's free tier get unlimited events on self-hosted for the cost of a small VPS. The catch: the feature gap with Sentry is real. Session replay, profiling, AI-powered issue triage, and advanced performance tracing are all absent. GlitchTip covers core error aggregation well, but teams relying on Sentry's full platform will notice what's missing. Also hosted on GitLab, not GitHub, which means smaller community visibility.