nothing goes wrong
without you knowing.

one night, reconstructed

told in clocks. the gaps between them are the part that costs money.

what you get

the whole night,
not just the exception.

the stack trace is the easy part. who it hit, how many, what they were doing, whether it is still going, and who to wake: that is the night.

elsewhere that is four subscriptions: error tracking, product analytics, uptime, and a pager. three of them bill per person, so knowing what broke costs more every time you hire.

here it is one product, priced per organisation. twenty-five people on Team is $19, not $19 each.

the same night, from their side

nobody files a ticket.
they just leave.

03:12 has a second half: the people who were partway through paying when it broke. errors count exceptions. journeys count the ones who quietly gave up, and name the step they gave up on.

that is the whole instrumentation. three calls, batched in the background, dropped on the floor if cyclopes is unreachable. the map, the completion rate and the replay are all built from them:

cyclopes.identify({"id": user.id})
cyclopes.screen("Checkout")
cyclopes.track("card_submitted", {"amount": 4471})

matching is unordered, on purpose. real people wander off, come back through search, apply a coupon and then pay. insisting on a fixed sequence would mark most genuine completions as failures. what counts is that everything meaning done happened, inside the window you set.

when it has to wake someone

a ladder, not a firehose

one incident per issue, carrying an ack link short enough to survive an sms. unanswered, it climbs.

what can page you

• new issue
• a resolved issue coming back
• level at or above
• event threshold
• rate spike
• affected users
• monitor down
• monitor recovered
• cron heartbeat missed
• tls certificate expiring

on any of

• email
• sms
• whatsapp
• push
• hmac-signed webhook
• in-app

and it fits in your pocket

the same eye, on your desk and on your phone

pair the app with an activation code and the stream follows you: a live feed on the phone, a desktop panel that dilates with the event rate and turns red before anyone files a ticket.

it runs a receiver of its own too, so an sdk can point straight at it with no server at all.

the wire

grab the dsn from your project's settings and point an sdk at it. every sdk reports uncaught errors on its own, and none of them will break or block your app when cyclopes is unreachable. signing up to a first error takes about two minutes: make a project, copy the dsn, restart, throw something.

$ pip install cyclopes

import cyclopes
cyclopes.init(dsn="https://key@cyclopes.dev/ingest/1", environment="production")

# unhandled exceptions now report themselves
cyclopes.logger.info("charge.settled", order=4471)

$ npm install @cyclopes/sdk

import * as cyclopes from "@cyclopes/sdk";
cyclopes.init({ dsn: "https://key@cyclopes.dev/ingest/1", environment: "production" });

// window.onerror and unhandledRejection are wired for you
cyclopes.logger.info("charge.settled", { order: 4471 });

$ dart pub add cyclopes

import 'package:cyclopes/cyclopes.dart';
await Cyclopes.init(dsn: 'https://key@cyclopes.dev/ingest/1');

// flutter errors and zone errors are caught for you
Cyclopes.logger.info('charge.settled', attrs: {'order': 4471});

before you decide

the four questions we get by email

what it costs

every plan watches everything.
paying decides who gets woken.

issues, logs, the terminal, monitors and journeys are on every tier, free included. what you pay for is who gets woken, how loudly, and how far back the history stays open. never per person: twenty-five people on Team is $19, not $19 each.

out of alerts before the month is? buy alerts, not a bigger plan: top-ups need no plan and never expire. every tier is prepaid, so nothing auto-charges and a period that lapses drops you to free rather than into arrears.