Static Status; Vigil; cState

In today’s Drop we have a roundup of three monitoring solutions that can help you keep tabs on your infrastructure and services. From a lightweight Bash script to a full-featured Rust-based system to a static site generator approach, these tools offer different ways to implement status pages and monitoring based on your specific needs and complexity requirements.

TL;DR

(This is an AI-generated summary of today’s Drop using Ollama + llama 3.2 and a custom prompt.)

• Simple Bash script Static Status generates HTML/JSON/SVG status pages to monitor infrastructure with support for custom checks and multiple notification methods (https://github.com/Cyclenerd/static_status)
• Vigil provides microservice monitoring through direct polling, Reporter libraries, and local daemon checks with flexible notifications via Slack, Telegram, email and SMS (https://github.com/valeriansaliou/vigil)
• cState offers a static Hugo-based status page system with incident management, maintenance windows and Netlify CMS integration (https://cstate.mnts.lt/)

Static Status

Static Status (GH) is a handy Bash script that generates dynamic status pages for monitoring infrastructure components. The script provides comprehensive monitoring capabilities for websites, services, and network connectivity through a simple yet powerful interface.

Don’t let the “Bash” part fool you. This tool can keep an eye multiple types of services including HTTP endpoints, database services, and network connectivity through ping and traceroute. It supports custom text display for monitored endpoints and can detect complex conditions like specific text presence on webpages.

It haw support for multiple output types inluding:

• A static HTML status page for web viewing
• JSON output for programmatic consumption
• SVG status icon for quick visual indication
• Email, SMS, or Pushover notifications for downtime alerts

and relies on some of our usual CLI suspects: coreutils, curl, grep, nc, ping, sed, traceroute (etc.).

Configuration is managed through two primary files:

• status_hostname_list.txt — Define monitoring targets
• config — Script behavior configuration

The script supports custom monitoring through shell scripts with three possible states:

• Available (return code 0)
• Degraded (return code 80)
• Failed (other return codes)

The script can be configured to run automatically using cron:

*/1 * * * * bash "/path/to/status.sh" silent >> /dev/null

but, Drop readers will likely want to use a more robust systemd setup:

~/.config/systemd/user/status.service:

[Unit]
Description=Status Check Service

[Service]
Type=oneshot
ExecStart=/bin/bash /path/to/status.sh silent

[Install]
WantedBy=default.target

~/.config/systemd/user/status.timer:

[Unit]
Description=Run status check every minute

[Timer]
OnCalendar=*:*:00
Persistent=true

[Install]
WantedBy=timers.target

$ systemctl --user daemon-reload
$ systemctl --user enable --now status.timer

The monitoring system supports:

• Custom display names for endpoints
• Flexible service checking intervals
• Multiple notification methods
• Route path verification for backup connection monitoring

Super simple, yet super handy.

Vigil

Vigil (GH) is a monitoring tool for microservices built in Rust. The system uses three mechanisms: direct polling of services (HTTP/TCP/ICMP), “Reporter” libraries in applications, and local service checks via a daemon. This covers issues across web services, background workers, and system resources.

Vigil’s strong point is its notification system, sending alerts through Slack, Telegram, email, SMS, or custom webhooks. This flexibility allows integration into existing workflows without disrupting team communication.

The status classifications are straightforward: healthy, sick, or dead. This helps quickly assess infrastructure state without complexity.

Setting up requires hosting Vigil on a separate server to avoid it going down with services (kind of important for anything in this class of utilities).

Integration options include Reporter libraries for Node.js, Python, Golang, Rust, Dart, C#, and configuration uses TOML and environment variables.

The Vigil Manager handles admin tasks and maintenance announcements, while the HTTP API allows programmatic control.

It’s a bit more complex than “Static Status” from section one, but it’s a fine choice if you’re looking to start keeping track of your creations.

cState

cState (GH) is a static status page system built on Hugo that delivers fast-loading pages while maintaining broad browser compatibility. Its Golang foundation efficiently processes large volumes of incidents (you should likely re-think your professional choices if you have large volumes of incidents, tho), making it ideal for complex enterprise environments.

The system embraces a modular approach, letting folks choose their monitoring tools rather than forcing a built-in solution. Deployment options include Cloudflare Pages, Netlify, or self-hosted configurations, with content management handled through Netlify CMS or Git workflows.

cState’s sophisticated incident management includes granular severity levels and scheduled maintenance windows, while features like multi-language support and automatic dark mode ensure it meets modern web standards.

This has a nice balance between the bare bones offering section one and the more advanced configurations of the middle section.

FIN

Remember, you can follow and interact with the full text of The Daily Drop’s free posts on:

• 🐘 Mastodon via @dailydrop.hrbrmstr.dev@dailydrop.hrbrmstr.dev
• 🦋 Bluesky via https://bsky.app/profile/dailydrop.hrbrmstr.dev.web.brid.gy

Also, refer to:

• this post, and
• this post

to see how to access a regularly updated database of all the Drops with extracted links, and full-text search capability. ☮️