Uptime Kuma is a self-hosted, open-source uptime monitoring application that periodically checks the availability and response time of services (HTTP, TCP, DNS, databases, Docker containers, and many more) and sends alerts via 90+ notification providers. The system is a monolithic Node.js/Express backend with a Vue 3 SPA frontend, using Socket.IO for real-time updates and SQLite or MariaDB for persistence. It provides status pages, maintenance windows, certificate/domain expiry monitoring, and a Prometheus metrics endpoint. The architecture follows a plugin pattern for monitor types and notification providers, both built on base classes, and includes a condition evaluation system for advanced alerting logic. The codebase is well-structured with clear separation of concerns, extensive tests (unit, integration, e2e), and active community contributions.
OpenStatus is a production-grade, self-hostable uptime monitoring, incident management, and status page platform. In production, it runs multi-region synthetic checks (HTTP, TCP, DNS, ICMP, gRPC) from Go-based checker and private-location services, streams check results into Tinybird for time-series analytics, persists workspace state (monitors, pages, incidents, API keys, OAuth clients) in SQLite via Drizzle ORM, and renders results through a Next.js dashboard and a public, i18n-enabled status page app with custom-domain proxy support, password/email/IP access gating, themes, and RSS/JSON/markdown feeds. A Hono-based API server exposes three API surfaces - a frozen legacy REST v1 (OpenAPI), tRPC, and ConnectRPC - plus an MCP server for AI agents and a Slack bot that can resolve incidents conversationally. The architecture is a deliberately polyglot monorepo: 8+ apps (dashboard, status-page, web marketing, Hono server, Go checker, Go private-location, Deno workflows, Go ssh-server) and 20+ internal packages. Business logic is centralized in packages/services behind a consistent ServiceContext + withTransaction + requireScope + emitAudit mutation pattern, then adapted to tRPC, ConnectRPC, and REST entry points. Multi-tenant workspaces include plan-based limits, API keys with scopes, a full OAuth 2.0 authorization server (PKCE), WorkOS SSO, Stripe billing, and append-only audit logging. Background Deno workflows handle cron maintenance: outbox draining, status drift repair, OAuth client pruning, and uptime freezing. Craftsmanship is strong: the service-layer pattern is applied uniformly, there is an explicit ServiceError hierarchy mapped to both tRPC and gRPC errors, external services (Upstash, Tinybird, Slack, analytics) have thorough test doubles, and several packages are genuinely standalone and reusable (CDN header analysis, assertion engine, schema-driven data-table filters, Effect-based status fetchers). Caveats are real but not disqualifying: the REST v1 API is explicitly frozen and bypasses the service layer, identical composition/chart utilities are duplicated across dashboard and status-page apps, a deprecated screenshot-service remains in-tree, the Go/TypeScript protobuf boundary requires manual synchronization, and an in-progress auth migration has left Clerk-era references alongside NextAuth. Overall this is a well-architected, actively maintained codebase that does what it claims.
Ciao is a self-contained, zero-external-dependency HTTP(S) endpoint monitoring application built with Ruby on Rails 8. It schedules periodic health checks with cron syntax using the in-process rufus-scheduler, stores state in a local SQLite database, and notifies users of status changes via email or configurable webhooks (e.g., Slack, Rocket.Chat). The application also monitors TLS certificate expiration for HTTPS endpoints and sends alerts when certificates are due to expire. It provides a web UI with a dashboard, a RESTful JSON API, optional Prometheus metrics, and HTTP Basic authentication. The codebase is a standard Rails monolith with a single process for web server, scheduler, and background work, making it easy to deploy (Docker, Helm chart, or direct Ruby). The architecture is simple but effective for small-to-medium monitoring needs.
This repository provides a Helm chart for deploying Uptime-Kuma, a self-hosted uptime monitoring tool, on Kubernetes. The chart is well-structured with support for Deployment or StatefulSet, persistent storage, ingress, external database (MariaDB/MySQL), Prometheus ServiceMonitor, and network policies. It includes comprehensive helm-unittest tests, CI/CD pipelines for linting, testing, and releasing, and automated dependency updates via Renovate. The chart is actively maintained and follows Helm best practices.
Updo is a production-grade CLI tool for multi-target website uptime and performance monitoring. It continuously checks HTTP endpoints from the command line or a TOML configuration file, displaying real-time results in an interactive TUI or simple text output. The core monitoring engine performs configurable HTTP requests (GET/POST/PUT, custom headers, assertion text, redirect handling, SSL verification) and captures detailed timing breakdowns (DNS, TCP, TTFB, download). It can also deploy and invoke AWS Lambda functions across 13 global regions for geographically distributed probing, aggregating results from multiple vantage points. The tool integrates with Prometheus via Remote Write for long-term metric storage and visualization, and supports desktop alerts via beeep plus webhook notifications to Slack, Discord, or custom endpoints with auto-detected formatting. Architecture is a monolith Go application built on cobra for CLI management, termui for the TUI, and AWS SDK v2 for Lambda operations. Key entry points are the `updo monitor` and `updo aws` subcommands. Data flows from config or CLI flags through a monitoring loop that calls the HTTP checker or Lambda invoker, accumulates stats (t-digest for percentiles, rolling uptime), and pushes structured logs or Prometheus time series.
This repository implements a static site that reconstructs and visualizes GitHub's historical status incidents and downtime. It ingests the official GitHub Status history Atom feed (committed into git via Flat Data), parses entries into structured incident timelines with status transitions, downtime windows, and impacted components. The frontend displays a 90-day and all-time uptime overview, per-service uptime bars, an incident timeline with filters, and a rolling uptime chart. The system is designed as a data pipeline: a GitHub Action fetches the Atom feed daily, another Action runs the extractor script to produce parsed artifacts (CSV, JSONL), and a third Action deploys the static site to GitHub Pages. The repository also includes an experimental GLiNER-based component extraction fallback to infer affected services from incident postmortems when the structured data is missing. The codebase demonstrates strong craftsmanship with well-isolated pure functions, testable frontend modules, and defensive caching patterns, though it remains tightly coupled to GitHub's specific status page format and prose patterns.