🔔 Better Uptime

A high-performance, real-time website uptime monitoring platform built entirely in Rust.
Inspired by Better Uptime

---

📖 Overview

Better Uptime is an open-source uptime monitoring platform that continuously checks your websites and tracks their availability, response times, and health status across multiple regions. It's designed as a distributed system of microservices — all written in Rust — communicating through Redis Streams for low-latency, high-throughput event processing.

✨ Key Features

• Continuous Monitoring — Automatically pings your websites at regular intervals and records response times
• Multi-Region Checks — Supports health checks from multiple geographic regions to detect localized outages
• Real-time Event Pipeline — Redis Streams power the event-driven architecture for instant data flow between services
• Status Tracking — Tracks Up, Down, and Unknown states for every monitored endpoint
• User Authentication — Secure signup/signin with Argon2 password hashing and JWT-based auth
• REST API — Full CRUD API for managing monitored websites and viewing uptime data
• Structured Logging — JSON-formatted, span-based tracing across all services via tracing
• Dockerized — One-command deployment with Docker Compose

---

🏗️ Architecture

┌─────────────┐       ┌──────────────────────────────────────────────┐
│   Frontend   │◄─────►│                  API Server                  │
│  (Planned)   │       │            (Poem • Port 8080)               │
└─────────────┘       └───────────────────┬──────────────────────────┘
                                          │
                                          │  Diesel ORM
                                          ▼
                      ┌──────────────────────────────────────────────┐
                      │              PostgreSQL 17                    │
                      │  users │ websites │ website_ticks │ regions  │
                      └──────────────────────────────────────────────┘
                                          ▲
                                          │
              ┌───────────────────────────┼───────────────────────────┐
              │                           │                           │
   ┌──────────┴──────────┐    ┌──────────┴──────────┐    ┌──────────┴──────────┐
   │      Producer       │    │       Worker        │    │    Site Writer      │
   │  (Scheduler/Cron)   │    │   (Health Checker)  │    │  (Persistence)     │
   └──────────┬──────────┘    └──────────┬──────────┘    └──────────┬──────────┘
              │                           │                           │
              │  publish                  │  consume/publish          │  consume
              ▼                           ▼                           ▼
   ┌──────────────────────────────────────────────────────────────────────────┐
   │                          Redis 7 Streams                                 │
   │                process_queue  ◄──►  store_queue                          │
   └──────────────────────────────────────────────────────────────────────────┘

Data Flow

1. Producer queries PostgreSQL for all registered websites (cursor-paginated, batches of 50) and publishes check events to the Redis process_queue every 3 minutes.
2. Worker consumes events from the process_queue, makes HTTP requests to each website, records response time and status (Up/Down), then publishes results to the store_queue.
3. Site Writer consumes results from the store_queue and bulk-inserts them into the website_ticks table in PostgreSQL, then acknowledges the stream entries.

---

🧱 Project Structure

This is a Cargo workspace with 8 crates, each with a clear responsibility:

better-uptime-rust/
├── api/                # REST API server (Poem framework)
│   └── src/
│       ├── modules/
│       │   ├── auth/       # Signup, signin, JWT auth
│       │   └── website/    # Website CRUD & monitoring data
│       ├── server.rs       # Server setup & request logging middleware
│       ├── router.rs       # Route mounting
│       ├── config.rs       # Environment config
│       └── state.rs        # Shared application state
│
├── producer/           # Scheduled job — publishes website check events
│   └── src/
│       └── producer.rs     # Cursor-paginated website fetcher → Redis publisher
│
├── worker/             # Health checker — pings websites, records results
│   └── src/
│       └── worker.rs       # HTTP health checks with response time tracking
│
├── site-writer/        # Persistence layer — writes check results to DB
│   └── src/
│       └── writer.rs       # Stream consumer → bulk database inserts
│
├── store/              # Database layer (Diesel ORM + PostgreSQL)
│   ├── migrations/         # 7 Diesel migrations
│   └── src/
│       ├── model/          # Diesel models (User, Website, WebsiteTick, Region)
│       ├── module/         # Repository pattern (UserRepository, WebsiteRepository)
│       └── schema.rs       # Auto-generated Diesel schema
│
├── stream/             # Redis Streams abstraction layer
│   └── src/
│       ├── stream.rs       # Redis connection + client setup
│       ├── process.rs      # process_queue consumer/publisher
│       ├── store.rs        # store_queue consumer/publisher
│       └── seed.rs         # Stream initialization
│
├── common/             # Shared utilities
│   └── src/
│       └── logging.rs      # Structured JSON logging setup (tracing)
│
├── migrator/           # Database migration runner
├── seed/               # Database seeder
│
├── Cargo.toml          # Workspace manifest
├── Dockerfile          # Multi-stage build (builder → per-service targets)
├── docker-compose.yml  # Full stack orchestration
└── README.md

---

🛠️ Tech Stack

Layer	Technology
Language	Rust 1.90 (Edition 2024)
API Framework	Poem
Database	PostgreSQL 17
ORM	Diesel (with r2d2 connection pool)
Message Broker	Redis 7 (Streams)
Auth	Argon2 password hashing + JWT (jsonwebtoken)
HTTP Client	reqwest
Logging	tracing + tracing-subscriber (JSON format)
Containerization	Docker multi-stage builds + Docker Compose
Frontend	🚧 Coming soon

---

🚀 Getting Started

Prerequisites

• Docker & Docker Compose
• (Optional) Rust 1.90+ — only needed for local development

Run with Docker Compose

# Clone the repo
git clone https://github.com/your-username/better-uptime-rust.git
cd better-uptime-rust

# Start the entire stack
docker compose up --build

This will spin up:

Service	Description	Port
postgres	PostgreSQL 17 database	5432
redis	Redis 7 message broker	6379
migrate	Runs Diesel migrations, then exits	—
seed	Seeds initial data, then exits	—
api	REST API server	8080
producer	Website check scheduler	—
worker	HTTP health checker	—
site-writer	Results persistence writer	—

Local Development

# Start infrastructure
docker compose up postgres redis -d

# Run migrations
cargo run -p migrator

# Seed the database
cargo run -p seed

# Start individual services (in separate terminals)
cargo run -p api
cargo run -p producer
cargo run -p worker
cargo run -p site-writer

Note: Each service reads its config from a .env file in its own crate directory. See the individual .env files for required environment variables.

---

📡 API Reference

Base URL: http://localhost:8080/api

Authentication

Method	Endpoint	Description
POST	/auth/signup	Create a new account
POST	/auth/signin	Sign in and receive JWT

Websites

Method	Endpoint	Description
POST	/website/website	Add a website to monitor
GET	/website/website/:website_id	Get website details & uptime data

---

📊 Database Schema

users           (id UUID PK, username TEXT, password TEXT, created_at TIMESTAMPTZ)
websites        (id UUID PK, url TEXT, user_id UUID FK→users, created_at TIMESTAMPTZ)
website_ticks   (id UUID PK, websites_id UUID FK→websites, response_time_ms INT,
                 region_name TEXT FK→regions, status status_type, created_at TIMESTAMPTZ)
regions         (name TEXT PK)

The status_type is a PostgreSQL custom enum: up | down | unknown.

---

🗺️ Roadmap

• Frontend — Dashboard UI (considering Yew/Rust-based SPA or Next.js)
• Additional API endpoints (list websites, delete website, uptime history)
• Alerting & notifications (email, Slack, webhooks)
• Status pages (public-facing uptime dashboards)
• Multi-region worker deployment
• Incident timeline & reporting
• Rate limiting & API key authentication

---

📄 License

This project is open source and available under the MIT License.

---

Built with 🦀 Rust — fast, safe, and reliable.