Status · methodology

How we measure

Plain definitions for every number on the status page, what we cannot measure, and how to check us.

Timestamps and what they mean

Every timed figure on the status page is the difference between two of three timestamps attached to an alert.

  • Happened — the event time recorded by the game's own servers for that event. It is the only reference we use; we never estimate it.
  • Caught — the time our service recognised the event, taken from our own clock, which is kept in sync with public time servers and checked every minute.
  • Delivered — the time the resulting message existed in the customer's Discord channel, taken from Discord's message timestamp.

Catch time = caught − happened. Delivery time = delivered − happened. When an alert is sent by more than one product, the delivery time shown in the ticker and in the catch tables is the earliest delivery; the delivery tables count every delivery separately.

Rounding and counting rules

  • Under 1 second. The game stores many event times in whole seconds, so differences below one second, including zero or slightly negative values, are shown as "under 1 s" and enter medians and percentiles as 0.5 s.
  • No reference time, no timing. An alert whose event has no usable game-side time is counted but contributes nothing to any time figure.
  • Count-only types. Attack cancelled, node alerts and realm transfers are counted only, by design.
  • Warm-up window. The first 60 seconds after any of our services restarts are not recorded, because figures from that window would misstate both catch and delivery times.
  • Typical is the median; slowest 5% is the 95th percentile (nearest rank). Every figure states the number of alerts it is based on; figures with no timed alerts are shown as "—".
  • Warden is an activity ledger: it reports how many clan actions it took, and a time only where a game-side reference exists (members accepted, attack warnings, landed-hit reports, chat triggers, shield-expired alerts).

Uptime

Every 60 seconds the service checks each product's components: whether the product is running, whether it has recently reported itself alive, and a health check where one exists. A failing core component marks the product down for that minute; a failing secondary component marks it degraded, which still counts as available. Uptime is available minutes divided by checked minutes over the window shown, and each percentage carries the number of checks behind it. Days are rolled up at midnight UTC and kept indefinitely.

Incidents

An incident opens automatically after a few consecutive down minutes and resolves automatically after a few consecutive available minutes; the duration is the time between those two points. Incidents can also be opened, updated and resolved by the operator. Updates are time-stamped and never edited; the incident list shows the last 30 days.

Publication delay

Incidents are published with a delay to protect customers. A public, real-time "degraded" or "down" would tell other players exactly when our customers are without alerts, and a real-time list of caught alerts would let a player test whether they are being watched. Therefore:

  • An incident, and any product state other than operational, appears on this site once it has lasted at least 60 minutes or once it has ended. Until then the product is shown with its last operational state. Updates to an open incident appear with the same delay.
  • Alert counts, catch and delivery times and the recent-alerts list are computed from records at least 60 minutes old. The recent-alerts list shows coarse times only ("about 2 h ago") and is not in order of occurrence. Warden figures are aggregates only.
  • Uptime percentages include every outage — nothing is removed from the record — but are computed from checks at least 60 minutes old, so a percentage never moves before the delay has passed.
  • The daily archive is written once the delay has passed after midnight UTC.
  • Customers are informed in real time in their private channels.

Retention and archive

  • Raw alert records: 30 days.
  • Hourly roll-ups per alert type: 13 months.
  • Uptime checks: 90 days at one-minute resolution; daily totals indefinitely.
  • Incidents, known issues and release notes: indefinitely.

Daily archive. Shortly after midnight UTC the completed day is written to /status/archive/ as one JSON file: counts, medians and 95th percentiles per alert type and product, delivery figures, uptime per product and the day's incidents. Archive files are never edited or rewritten. Each file contains the SHA-256 hash of the previous day's file and its own hash, forming a chain published at chain.json.

Limitations, stated plainly

  • The service measures its own products. There is no third-party audit; the archive and hash chain exist so that anyone can hold us to the published figures.
  • Restarts for deployments are excluded from timing by the 60-second warm-up rule above, so they do not appear as catch or delivery spikes; they remain visible in uptime whenever a restart lasts longer than one check. Slow-downs that happen outside that window are kept and show up in the slowest-5% figures.
  • The page is deliberately not real-time (see publication delay).
  • Small samples are noisy. A type with a handful of alerts in 24 hours can show a typical time that moves a lot; the 30-day figures are steadier. Sample sizes are always shown.
  • Catch time depends on the game making an event visible; events the game exposes late are measured as late.
  • Uptime is sampled once a minute, so an outage shorter than a minute may not be recorded, and a product is only as "up" as the checks we run against it.

How to verify us yourself

  1. Fetch /status.json (or /detections.json) as often as you like and compare it with the page: both are rendered from the same records.
  2. Download a day from /status/archive/. Remove the sha256 field, serialise the rest as canonical JSON (keys sorted, no whitespace, UTF-8) and hash it with SHA-256; it must equal the file's sha256 and the entry in chain.json, and sha256_prev must equal the previous day's sha256.
  3. Keep your own copies. If a later download of the same day differs from yours, the chain is broken and we were wrong.
  4. Subscribe to the Atom feed for incidents, releases and known issues with their original timestamps.

Questions

What does "caught in 1.8 s" mean?

1.8 seconds passed between the moment the game's own server recorded the event ("happened") and the moment the Sinister Bots service recognised it ("caught"). Delivery time is measured the same way, ending at the Discord message timestamp.

Why do some alerts say "under 1 s"?

The game records many event times in whole seconds. A difference below one second, including zero or a slightly negative value caused by that rounding, is shown as "under 1 s" and counted as 0.5 seconds in medians and percentiles. We never show a fractional time we cannot support.

Which alerts have no time shown?

Alerts without a usable reference time from the game, and types that only record that something took place (attack cancelled, node alerts, realm transfers), are counted but never timed.

How is uptime measured?

Every 60 seconds the service checks each product's components. A failing core component marks the product down for that minute; a failing secondary component marks it degraded, which still counts as available. Uptime is available minutes divided by checked minutes, and every figure shows how many checks it is based on.

Why is the page not real-time?

To protect customers. A public, real-time "degraded" or "down" would tell other players exactly when our customers are without alerts, and a real-time list of caught alerts would let a player test whether they are being watched. Incidents, any state other than operational, alert counts and timings are therefore published with a delay of about 60 minutes, or once the incident has ended. Customers are informed in real time in their private channels. Nothing is hidden from the record: uptime figures include every outage.

Can the numbers be edited after the fact?

Live figures are recomputed from the raw records and change only as new records arrive. The daily archive is written once per day and never rewritten; each file includes the SHA-256 hash of the previous day's file, so any later change to any day would break the chain published at /status/archive/chain.json.

How can I check the figures myself?

Fetch https://sinisterbots.com/status.json at any time and compare it with the page; download a day from /status/archive/, recompute its sha256 field over the canonical JSON and compare it with chain.json; and keep your own copies — if a later copy of the same day differs from yours, the chain is broken.

Who measures this, and can I republish the data?

The Sinister Bots status service measures its own products; there is no third-party audit. The data is published under CC BY 4.0: you may republish it with attribution to Sinister Bots and a link to the status page.

Data measured by the Sinister Bots status service itself and published under CC BY 4.0 — republish with attribution and a link to sinisterbots.com/status. Times are UTC.