Kuvasz

Kuvasz is a fully‑featured, self‑hosted uptime and SSL monitoring platform written in Go. It exposes a rich REST API and optional OpenTelemetry/Prometheus metrics, enabling developers to embed uptime checks into existing observability pipelines or build custom dashboards. Internally, the service orchestrates periodic HTTP(S) probes, certificate expiry checks, and per‑monitor notification routing. The application is deliberately modular: the core probe engine runs in a lightweight Go routine pool, while the web UI and API are served via an embedded Gin framework. All configuration is persisted in a PostgreSQL database, but the schema can be swapped for SQLite or MySQL with minimal effort thanks to GORM‑based migrations.

• Language & Runtime: Go 1.22+, leveraging goroutines for concurrent monitoring and the net/http package for HTTP(S) probes.
• Web Layer: Gin‑based REST API with JWT authentication, coupled to a Vue.js/TypeScript SPA for the status‑page UI. The API follows RESTful conventions and provides full CRUD over monitors, notification channels, and status pages.
• Data Store: PostgreSQL (default) accessed via GORM; migrations are idempotent and can be run in CI. The schema stores monitors, alerts, notification subscriptions, and status page metadata.
• Metrics Export: OpenTelemetry exporter pushes to any OTLP‑compatible backend; a Prometheus scrape endpoint exposes counters for probe latency, failures, and notification deliveries.
• Notification Engine: A pluggable system that routes alerts to email, Slack, Discord, Telegram, or PagerDuty. Each monitor can specify its own set of channels; the engine is decoupled via a simple interface so new providers can be added by implementing Notifier.

• HTTP(S) Monitoring: Custom headers, query parameters, body checks, status‑code validation, and response‑time thresholds.
• SSL Certificate Checks: Daily validation of expiry dates with configurable pre‑warning windows.
• Per‑Monitor Notifications: Fine‑grained control over which channels fire for each monitor, including suppression windows and retry policies.
• Status Pages: Public or private branded pages that display real‑time uptime, incident history, and RSS feeds.
• REST API: Endpoints for creating monitors (POST /monitors), retrieving status (GET /status/:id), managing notification channels, and exporting metrics.
• Metrics Exporters: /metrics endpoint for Prometheus; OTLP exporter for OpenTelemetry ingestion.

Kuvasz ships as a Docker image (kuvaszmonitoring/kuvasz) and can be deployed on any platform that supports Docker or Kubernetes. The image is built with a multi‑stage Go build, resulting in a lightweight binary (~30 MB). For production use, the recommended stack is:

1. PostgreSQL (or any GORM‑compatible DB) for persistence.
2. Redis optional, for rate‑limiting and caching of notification delivery status.
3. NGINX or Traefik as a reverse proxy to handle TLS termination and path routing.
4. Kubernetes with a Deployment that uses a HorizontalPodAutoscaler on CPU usage, ensuring probe scalability as the number of monitors grows.

The service is stateless beyond its database, making horizontal scaling trivial. Each probe routine runs in a bounded worker pool (maxConcurrentProbes), preventing resource exhaustion even when monitoring thousands of endpoints.

• Plugin System: The notifier interface allows developers to drop in custom notification logic. A simple go get can fetch a new notifier package, and the configuration schema supports adding arbitrary JSON payloads for custom endpoints.
• Webhooks: Users can register HTTP callbacks that fire on monitor state changes, enabling integration with ticketing systems or custom dashboards.
• SDKs & Clients: While not bundled, the public REST API can be consumed by any HTTP client; community projects provide Go and Python SDKs.
• Custom UI Themes: The SPA is built with Vue.js and supports theme overrides via CSS variables, allowing branding without code changes.

The project follows a clean monorepo layout with comprehensive test coverage (~80 %+). Documentation is hosted at kuvasz-uptime.dev, featuring a detailed API reference, deployment guides, and a roadmap. The community actively maintains a Discord channel for real‑time support, and the issue tracker is well‑organised with labels for bugs, enhancements, and documentation. The Apache 2.0 license removes licensing friction, encouraging enterprise adoption.

1. Internal Ops – Teams can expose a private status page for internal services, integrating alerts into existing Slack channels and Prometheus dashboards.
2. SaaS Providers – Offer a branded uptime portal to customers, with customizable incident logs and RSS feeds.
3. DevOps Toolchains – Embed Kuvasz probes into CI/CD pipelines to gate releases on service availability checks.
4. Educational Platforms – Students can deploy a self‑hosted monitoring stack to learn about observability and alerting.

• Open Source & Self‑Hosted: Full control over data, compliance with internal security policies, and no vendor lock‑in.
• Performance: Go’s concurrency model ensures low overhead even with thousands of monitors; the probe engine is