Niklas Ye
bc285799d1
An incident opened, got assigned to whoever held today's schedule entry,
and then sat there silently until somebody thought to look. The schedule
and the incident model were both built; nothing reached the person
holding the pager.
Notifications go out through ntfy, over plain HTTP with no new
dependencies. Delivery is an outbox rather than an inline call: the pool
is limited to a single connection, so a POST made while holding the
webhook's transaction would stall every other request behind it. The
webhook inserts a row and a notifier goroutine sends it within a tick,
retrying with exponential backoff.
Only opening an incident has to resolve a topic from scratch. Reminders
and all-clears reuse whatever that first notification chose, which keeps
configuration out of resolveIfSettled and gives the right rule for free:
you only hear that something resolved if you were told it started.
Each push carries an Acknowledge button, because the useful thing to do
at 3am is stop the pager without unlocking anything. It POSTs to an
unauthenticated /api/notify/ack/{token} — a notification body lives on
the ntfy server and in the device cache, so a real API key must never
appear in one. The token is minted per delivery, scoped to one incident
and one action, and expires in a day.
Reminders repeat until the incident stops being untouched. The stop
conditions are the states that already mean somebody has it: acknowledged,
snoozed, resolved, archived. Snooze is the mute button, so there is no
separate reminder cap.
Notifications sent to the fallback topic carry no Acknowledge button. The
topic is shared, and a button on it would let any subscriber acknowledge
as somebody else.
72 lines
2.0 KiB
Go
72 lines
2.0 KiB
Go
package config
|
|
|
|
import (
|
|
"os"
|
|
"time"
|
|
)
|
|
|
|
type Config struct {
|
|
Addr string
|
|
DBPath string
|
|
ArchiveAfter time.Duration
|
|
|
|
// StaleAfter is how long a firing alert may go without a refreshing webhook
|
|
// before the sweeper treats it as resolved. It must exceed Alertmanager's
|
|
// repeat_interval (default 4h), which is what refreshes the alert.
|
|
StaleAfter time.Duration
|
|
|
|
// NtfyURL is the ntfy server push notifications are published to. Empty
|
|
// disables notifications entirely.
|
|
NtfyURL string
|
|
|
|
// NtfyToken is an optional bearer token for an access-controlled ntfy.
|
|
NtfyToken string
|
|
|
|
// NtfyFallbackTopic receives incidents that open with nobody on call.
|
|
NtfyFallbackTopic string
|
|
|
|
// PublicURL is the base URL a phone uses to reach this server, used for the
|
|
// link and the Acknowledge button inside a notification. Without it
|
|
// notifications carry neither.
|
|
PublicURL string
|
|
|
|
// NotifyRepeat is how long an incident may sit unacknowledged before it is
|
|
// notified again. Zero disables reminders.
|
|
NotifyRepeat time.Duration
|
|
}
|
|
|
|
func Load() Config {
|
|
addr := os.Getenv("TERDUT_ADDR")
|
|
if addr == "" {
|
|
addr = ":8080"
|
|
}
|
|
dbPath := os.Getenv("TERDUT_DB_PATH")
|
|
if dbPath == "" {
|
|
dbPath = "terdut.db"
|
|
}
|
|
return Config{
|
|
Addr: addr,
|
|
DBPath: dbPath,
|
|
ArchiveAfter: duration("TERDUT_ARCHIVE_AFTER", 7*24*time.Hour),
|
|
StaleAfter: duration("TERDUT_STALE_AFTER", 6*time.Hour),
|
|
|
|
NtfyURL: os.Getenv("TERDUT_NTFY_URL"),
|
|
NtfyToken: os.Getenv("TERDUT_NTFY_TOKEN"),
|
|
NtfyFallbackTopic: os.Getenv("TERDUT_NTFY_FALLBACK_TOPIC"),
|
|
PublicURL: os.Getenv("TERDUT_PUBLIC_URL"),
|
|
NotifyRepeat: duration("TERDUT_NOTIFY_REPEAT", 15*time.Minute),
|
|
}
|
|
}
|
|
|
|
// duration reads a time.ParseDuration-formatted env var. An unset or
|
|
// unparseable value falls back to def rather than failing startup: a typo in one
|
|
// tuning knob should not take the server down.
|
|
func duration(env string, def time.Duration) time.Duration {
|
|
if s := os.Getenv(env); s != "" {
|
|
if d, err := time.ParseDuration(s); err == nil {
|
|
return d
|
|
}
|
|
}
|
|
return def
|
|
}
|