Observi

Observi is an uptime monitor you host yourself. It checks HTTP, keyword and TCP port monitors, shows them on a live dashboard, and sends alerts to Telegram, email and webhooks.

I wrote it as one Rust binary with the dashboard built in, so it needs no database server and about 20 MB of memory. It has user accounts with roles, monitor groups, and an English and Turkish interface, and it can import monitors from Uptime Kuma.

Built with Rust, React, and SQLite.

What it does

• HTTP(s), keyword and TCP port monitors, with retries and a pending state before a monitor is declared down.
• Several accounts. A superadmin manages everything; other users only see the monitors, or groups of monitors, you grant them.
• A live dashboard with response-time charts and 24 hour, 7 day and 30 day uptime.
• Alerts through Telegram, SMTP email and webhooks (generic JSON, Discord, Slack).
• Your own product name and logo in Settings, an English and Turkish interface, and a configurable language for alerts.
• SQLite in WAL mode with batched heartbeat writes, which is gentle on an SD card.

Install

It runs on Linux servers (x86_64) and on a Raspberry Pi with a 64-bit OS (Pi 3, 4, 5 and Zero 2 W). Anything with systemd will do.

curl -fsSL https://raw.githubusercontent.com/mdenizay/observi/main/install.sh | sudo bash

The script downloads the release binary for your machine and checks its checksum. It creates an observi system user, installs and starts a systemd service, and creates the first superadmin. The user is admin, and the generated password is printed once, so write it down.

Options go after -s --. --listen is where it listens (the default is 127.0.0.1:3001, localhost only) and --lang is the language of alerts, en or tr.

curl -fsSL https://raw.githubusercontent.com/mdenizay/observi/main/install.sh | sudo bash -s -- \
  --listen 0.0.0.0:3001 --lang tr --admin-user me --admin-password 'a-long-password'

Running the script again upgrades an existing install and keeps your data. install.sh --uninstall removes the service, and --purge deletes the data too.

The binary is in /usr/local/bin/observi, the data in /var/lib/observi, and the settings in /etc/observi/observi.env.

Put it on a domain

Observi listens on localhost by default, so put a reverse proxy or a tunnel in front of it. With Caddy:

status.example.com {
    reverse_proxy 127.0.0.1:3001
}

With nginx, turn buffering off, because the dashboard updates over server-sent events:

location / {
    proxy_pass http://127.0.0.1:3001;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header X-Forwarded-For $remote_addr;
    proxy_buffering off;
}

A Cloudflare Tunnel pointed at http://localhost:3001 works too. That is how I run it on a Raspberry Pi at home. Whichever you use, make sure it sends X-Forwarded-Proto, so session cookies get the Secure flag, and the client address (CF-Connecting-IP or X-Forwarded-For), so login throttling sees real IPs.

Configuration

Set these in /etc/observi/observi.env, then run sudo systemctl restart observi.

• OBSERVI_DB: the SQLite file. Default ./observi.db.
• OBSERVI_LISTEN: the listen address. Default 127.0.0.1:3001.
• OBSERVI_RETENTION: how many days of heartbeats to keep. Default 90.
• OBSERVI_LANG: the language of alerts, en or tr. Default en.
• RUST_LOG: the log level. Default info.

Command line

observi serve                                  start the server (default)
observi user-add <username> <name> [superadmin|user]
observi passwd <username>                      reset a password
observi import-kuma <kuma.db>                  import monitors from Uptime Kuma
observi --version

user-add and passwd take the password from OBSERVI_PASSWORD, or generate one and print it. On a machine installed with the script, run them as the service user:

sudo -u observi env OBSERVI_DB=/var/lib/observi/observi.db observi passwd admin

Moving from Uptime Kuma

Copy kuma.db, with its -wal and -shm files if there are any, to a place the service user can read, then run observi import-kuma kuma.db. HTTP, keyword and TCP port monitors come across. Notification settings do not.

Build from source

You need Rust (stable), Node 20 or newer and pnpm. The web interface is embedded in the binary at compile time, so build it first.

git clone https://github.com/mdenizay/observi.git
cd observi
cd web && pnpm install --frozen-lockfile && pnpm build && cd ..
cargo build --release

The binary ends up in target/release/observi. For the static binary the releases use, add the musl target (rustup target add x86_64-unknown-linux-musl, plus musl-tools) and build with --target.

For development, run the interface with pnpm dev in web (port 5173, proxying /api to 3001), create a user with OBSERVI_PASSWORD=changeme123 cargo run -- user-add admin Admin superadmin, then start the API with cargo run.