Skip to content

Reactor · part of brewlytics

Reactor

Skip the schedule. React to your data.

Every feed, sensor and system streams in. The moment something matters, the right brewlytics model runs.

Sensor feeds, imagery, vessel tracks, the publish API, message buses and brewlytics models stream into one glowing Reactor core. When the message that matters arrives, the core flares and a model run starts, stamped with the current time.

The everyday problem

Data never stops arriving. A schedule only checks in now and then.

The reading that matters hides in the noise. A sensor that goes silent looks like a quiet day. By the next scheduled check, the moment has passed.

A wall of message tiles flickers nonstop while a scheduled check sweeps across every few seconds. Between sweeps, the tile that matters flares and fades before the next check, and a sensor that went silent just looks like a quiet day.

Clock or stream

Tasks follow the clock. Reactor follows your data.

Over a day, every 'wait until the next run' adds up. With Reactor there's nothing to add up.

illustrative · example day
An example workday plays out. Time spent waiting on the schedule climbs to six or seven hours, while time spent waiting with Reactor stays at zero minutes.

From anywhere

One HTTP call. You're streaming.

Any system that can make a web request can publish to a topic. Reactor checks the message against the topic's schema, and your flows react in the same breath.

Prefer not to write code? brewlytics connectors bring in the feeds you already run, and people and models post too. Every source lands on a topic.

curl -X POST \
  "$BREWLYTICS/api/reactor/topics/vessel-tracks" \
  -H "Authorization: Bearer $TOKEN" \
  -d '{"vessel": "Corran Star",
       "lat": 36.84, "lon": -75.97,
       "speed_kn": 14.2}'
$ ready
A terminal publishes a message to a topic with one web request, cycling through curl, Python and JavaScript. The message joins a topic already streaming from other sources, passes the schema check, is caught by a Match flow and starts a model run.

How it works

Topic. Flow. Model. That's the whole idea.

Messages land on a topic. A flow decides which ones matter. Your brewlytics model runs for each one, with the message as its input.

1TopicSatellite imagery
Messages land on a topic
2FlowFilter · cloud cover under 20%
20%
A flow decides which ones matter
3ModelAnalyst queue
Load
Detect
Queue
Your model runs, once per message
Imagery messages land on a topic. A Filter flow checks each one's cloud cover against a 20% line: the clear ones pass and the rest are dropped. Each message that passes runs the model, step by step, and the run is logged.

You build a flow by dragging boxes onto a canvas and joining them.

Flows in action

Four ways to react. Pick the one that fits.

A flow is the rule that decides when your model runs.

Filter

Only what matters reaches your model.

New imagery pours in. Only the clear frames reach the analyst queue; the rest go to the archive, out of the way. One message can follow several paths, each to its own model.

New imagery pours in as a wall of messages. Only the clear frames are routed to the analyst queue; the rest slide off to the archive.

Match

Pair events from two places, the instant they meet.

A vessel track crosses into the area of interest, and the analysis is already running. Run once each time they meet, on every update while close, or now and then — your choice.

A vessel track crosses into the area of interest on a map. The moment the two meet, the crossing flashes and the track analysis starts.

Batch

500 scans. One run.

Warehouse scanners fire all shift long. A Batch flow collects them and runs your shift summary once per 500, not 500 times. You choose when a batch closes — after 500 messages or 60 seconds, whichever comes first — and your model receives the whole batch as one list.

example
Eight warehouse scanners send scans into a glass container that fills toward 500. At 500 the batch condenses into one shift summary run, while a tally compares scans in with runs out.

Gone quiet

Silence is a signal. Reactor hears it.

Pump 7 checks in every couple of minutes, until it doesn't. A Gone quiet flow notices and opens a maintenance ticket after 10 minutes — one alert per silence, no repeat alarms. Choose any wait from 1 minute to 24 hours, and add an all-clear when it reports again.

timers sped up
Six pumps report in as heartbeat lines. Pump 7 goes silent; after ten minutes a maintenance ticket opens, and an all-clear follows when it reports again.

A flow, end to end

One satellite pass. Three sources. Zero waiting.

A satellite's footprint sweeps the area. Its imagery lands, gets checked for cloud cover, and is matched against vessel broadcasts and RF detections. A ship that stopped broadcasting gets flagged, the model posts to the Watch floor, and that post starts the next flow.

A satellite pass images area of interest North. The imagery passes a cloud-cover filter at 8% and is matched against vessel broadcasts and RF detections. A ship that stopped broadcasting is flagged by the dark-vessel model, which posts to the Watch floor and starts a follow-up pass request.

Live topics

Every message, and what it set off.

A topic is a live channel for one kind of update. Its chat room shows each update the moment it lands, who sent it, and every run it started. Models post their results right back into the conversation. Something went wrong? Run it again from the same spot.

The New imagery chat room shows each message as it lands. A line runs from the message through its flow to the analyst queue or the archive and the result comes back as a chip. The change model posts its finding into the chat, and a failed archive run is run again and completes.

Safe and dependable

Built to be trusted with real work.

One message, one run.

Built so a message never starts the same run twice by accident.

A duplicate copy of a message bounces off and is ignored, so its run happens only once.

Calm under heavy traffic.

When thousands of messages arrive at once, they wait their turn instead of swamping your models.

A rush of messages waits in a queue that drains at a steady pace as the model works through it.

Picks up where it left off.

If a server stops, another takes over from the last message that was finished.

Server A stops and server B takes over, resuming from message 130.

Problems stay contained.

If one path of a flow has trouble, only that path stops. Restart just that one.

One path of a flow turns red and stops while the other paths keep flowing, then just that path is restarted.

Your access, respected.

A flow uses only what the person who switched it on is allowed to use.

A flow reaches the topics its owner can use and is turned away from Payroll with no access.

Everything on the record.

Each message shows who sent it, what ran, and how it went, with a link to the run.

A log fills with rows showing who sent each message, what ran and how it went.

Schemas, as strict as you like.

Off, Warn or Reject. A message that doesn't fit gets a one-line reason.

Who sees, who sends, who sets the rules.

Can see only · Can send and see · Owners.

A flow runs as the person who switched it on.

If they lose access to the topic, the flow stops.

Scale

Built for heavy traffic.

Many servers share the work. A rush waits its turn. Paths never block each other.

1,000+

messages gathered into a single run by one Batch

100 by default

A cloud of dots gathers into one amber orb: many messages collected into a single run.

64+

runs of one flow going at the same time

4 by default

Sixty-four lanes run side by side, each with a moving blip: runs of one flow going at once.

100,000+

devices one Gone quiet path can watch at once

10,000 by default

A field of dots, each standing for many devices, twinkles while one goes dark and is ringed in amber.

Starting points, not ceilings. Each is a setting an administrator raises to fit the job. Not speed-test results.

Each flow goes to the least busy server, and another takes over if one stops.

Messages wait in line — kept 7 days by default, up to 90 — and each flow works through them at its own pace.

Each path of a flow has its own queue, so a busy path never holds up the rest.

Get started

Up and running in three steps.

  1. Create a topic.

    Give it a name, choose structured fields or plain text, and add a schema if you like.

  2. Build a flow.

    Drag in your topic, add a Filter, Match, Batch or Gone quiet, and pick the model to run.

  3. Switch it on.

    Watch results arrive in the chat room, and share the topic with your team.

Already on brewlytics? Ask your administrator to turn Reactor on for your team.