Abstract
jaque runs the semantics your team already speaks -- soft and hard states, acknowledgements, downtimes, dependencies, escalations -- on an event-sourced core, shipped as one static Go binary. The plugins run unmodified, the config compiles with a report, the Livestatus integrations do not notice the change. You do not migrate to jaque; jaque moves into your house.
Status of This Document
This document describes pre-alpha software. There is no public release and no public repository; today jaque is built from source, and it is not yet ready to carry production monitoring. The status page states what is built, what is unverified, and what does not exist yet. Read it before believing anything below.
Table of Contents
1. Introduction
2. An Incident, Replayed
3. Nothing to Abandon
3.1. Plugins Run Unmodified
3.2. The Config Compiles
3.3. Livestatus Is an Open Protocol
4. One Binary
5. When It Alerts, You Can Compute Why
6. Status
7. What jaque Is Not
8. Where It Is Going
9. Send Your Config
1. Introduction
jaque monitors the estate the real world still runs on: routers and switches over SNMP -- first-class, because network gear will never run an agent -- machines over the plugins you already have, cloud workloads over native checks. It is written for the operator personally responsible for a Nagios-class estate, who thinks in hosts, services and states, not metrics and query languages.
Every exit from that estate asks you to abandon your world: the config, the plugins, the integrations, the mental model. jaque inherits that world whole. The only thing that changes is the engine underneath it.
2. An Incident, Replayed
This is the engine's own vocabulary. A database goes down, the retry tightens, the page goes out once, the dependent service is suppressed, an acknowledgement holds, recovery closes it.
14:02:11 db-1/postgres CRITICAL soft 1/3 connection refused retrying in 30s, not 5m -- soft states shrink the retry 14:02:41 db-1/postgres CRITICAL soft 2/3 connection refused 14:03:11 db-1/postgres CRITICAL hard 3/3 connection refused 14:03:11 -> oncall (webhook) first notification: hard transitions only 14:03:11 shop-api/health UNREACHABLE depends on db-1/postgres notification suppressed, not sent-and-ignored 14:06:02 db-1/postgres ACKNOWLEDGED by ana sticky ack 14:11:11 db-1/postgres OK hard recovery notified; ack cleared 14:11:11 shop-api/health OK reachability recomputed from the graph
Figure 1: an incident -- scripted, not a recording
3. Nothing to Abandon
3.1. Plugins Run Unmodified
The Nagios plugin exec protocol -- exit code, stdout, perfdata -- is frozen in jaque and supported forever. Your 2011 scripts run as-is, and so do the exchange's thousands: the sector's largest check ecosystem, already working on day one.
3.2. The Config Compiles
jaque import parses your Nagios object files and emits native CUE plus a report of what mapped, what was approximated, and what was not supported. There is no legacy-config runtime mode: the output is a native config you own from then on.
hosts: gw: {
address: "192.168.1.1"
check: {type: "icmp", host: address}
}
Figure 2: a complete, loadable configuration
The schema fills every default and rejects what it cannot type-check. The importer has never been run against a real third-party config: the project has no corpus. Section 9 is about that.
3.3. Livestatus Is an Open Protocol
jaque speaks Livestatus: LQL over nine tables, pinned against a replay of real client traffic. Anything that speaks Livestatus -- and an entire ecosystem of dashboards, consoles and glue scripts does -- works against jaque from day one. Livestatus, the plugin protocol and CUE are open interfaces; only the engine is ours. Config, plugins and integrations leave with you.
4. One Binary
One file. The event log, state machine, scheduler, API and dashboard are compiled into it: no database to operate, no broker to keep alive, the log itself is embedded. Pure Go, no C toolchain. The install story:
$ scp jaque mon-01:/usr/local/bin/jaque $ ssh mon-01 jaque -config /etc/jaque
Figure 3: illustrative -- there is no public release yet; today you build it from source
When one machine stops being enough, run the same binary with a different -target. The config does not change.
5. When It Alerts, You Can Compute Why
Every state transition is a pure function folded over an event log. Replay the log, get the same states. kill -9 the process mid-check and replay rebuilds the identical projection. No heuristics decide whether to page you: thresholds you wrote, evaluated the way you wrote them.
CRITICAL
checks ---> scheduler ---> state machine ---> event log
(memory | pebble | nats)
|
+-----------------+-----------------+
| | |
v v v
notifier sinks dashboard
Figure 4: every transition appends; everything downstream reads the log
The log is not an architecture detail; it is forward potential. Computable alerts today. Provable audit evidence, shadow-running beside an existing Nagios with an alert diff, and perfdata flowing wherever it should, tomorrow. The log is what makes all of it reachable.
6. Status
+-------------------------------------------------------+--------------+ | capability | state | +-------------------------------------------------------+--------------+ | soft/hard states, flap detection, acks, downtimes, | shipped | | dependencies, escalations | | | event-log replay survives kill -9 | shipped | | Livestatus: LQL parser and nine tables | shipped | | Nagios importer | implemented, | | | unverified | | -target roles (all/engine/worker/ui/notifier/sink) | shipped | | remote agent | unbuilt | +-------------------------------------------------------+--------------+
7. What jaque Is Not
Not a TSDB, and it does not aspire to be one: perfdata flows out to ClickHouse, remote_write or OTLP. No anomaly detection, no AIOps, no model in the loop. When jaque pages you, you can replay the log and see the exact events that decided it.
8. Where It Is Going
- flexible and triggered downtimes - an Icinga 2 importer - a remote agent (outbound gRPC streaming, mTLS) - live dashboard updates
9. Send Your Config
The importer needs a corpus, and there is exactly one way to get one. If you run Nagios and want to point jaque import at your object files, reporting what broke is the most useful thing you could send. There is no public channel yet -- the project is source-closed during the pre-alpha -- so the status page explains where things stand and how to reach the project.
Start with the docs. Believe the status page over anything on this one.