Skip to content

Dory

Dory turns live sensor feeds into a stream of meaningful events your applications can subscribe to — and runs the processing that produces them reliably, at scale, with no infrastructure for you to manage.

A camera sees a street. Dory turns what it sees into events — a person here, a vehicle there, an accident at this corner — and delivers the ones an application asks for: the event types it names, from the sensors watching the area it cares about.

The big picture

flowchart LR
    S["Sensors<br/>cameras &amp; devices,<br/>each watching an area"]
    P["Processors<br/>one per sensor × template<br/>(built with the Processor SDK)"]
    E(["Event stream"])
    Q[("Delivery queue<br/>one per subscription")]
    A["Your application<br/>(Application SDK)"]
    SUB["Subscription<br/>what · where · how"]
    O["Orchestrator"]
    M["Web Portal · REST API"]

    S -->|"raw data"| P
    P -->|"typed, located events"| E
    E -->|"the requested event types,<br/>from the matched sensors"| Q
    Q -->|"events + control messages<br/>(ready · updated · error)"| A
    A -->|"subscribe — via the REST API"| SUB
    SUB -->|"matches the sensors watching the regions,<br/>starts or reuses their processors"| P
    O -. "runs &amp; recovers" .-> P
    M -. "register sensors, define lenses,<br/>manage access" .-> S
    M -. "list &amp; cancel" .-> SUB

Three things happen on Dory:

  1. Sensors — cameras and other devices, each at a known location and each watching an area — stream raw data. A sensor can be kept private to your organization or published for other organizations to subscribe through.
  2. Processors turn that raw data into events: typed, located observations like person, vehicle, or accident. One processor runs per sensor and processing template; the platform starts it when a subscription first needs that pair and shares it between every subscription that does. You build the templates with the Processor SDK; the Orchestrator runs the processors and keeps them running.
  3. Applications subscribe to the events they care about — what (event types), where (regions, which select the sensors watching them) and how (a lens) — through the REST API or the Application SDK. The request is accepted at once; the platform provisions it in the background, tells the application when it is ready and which event types it covers, and streams the events into the subscription's own delivery queue.

Everything belongs to your organization (your tenant boundary) and stays private to it unless you choose to publish a sensor, a processor template or a lens for other organizations to use; you set it all up in the Web Portal or through the REST API.

The two sides of Dory

Side What it does Built with
Producing events Sensors → processors → an event stream. The platform places, scales, and recovers processors automatically, starts them on demand and shares them between subscriptions. Processor SDK + Orchestrator (the core of Dory)
Consuming events Subscribe to event types over geographic regions and receive those event types from the sensors watching those regions. Application SDK
Managing it all Organizations, members, access, sensors, and lenses — secured per organization — and each credential's subscriptions, which the Portal lists and can cancel. Web Portal + REST API

Find your path

You want to… Start here
Get your first event — the quickstart Subscriber Guide
Consume events in an app Application SDK
Integrate programmatically REST API
Manage your organization (members, access, sensors, lenses; view and cancel subscriptions) Web Portal
Build and publish a processor template Template Developer Guide
Build a processor that produces events Processor SDK
Run or operate the platform Orchestrator
Understand how a subscription becomes a stream Subscriptions & Events
Understand how it all fits System overview & glossary

Key ideas in one minute

  • Subscription — a standing request for events, defined by three things: what (event types), where (geographic regions), and how (a lens). Create one and it is accepted at once; the platform provisions it in the background, tells you when it is ready and which of your event types it currently covers, keeps it up to date as sensors and lenses change, and streams events to you until you cancel it — at which point delivery stops immediately, and any processor nobody else needs is released shortly after. A request that can't be accepted is refused straight away with a code saying why; a subscription the platform later can't set up is marked error, with a short code and a plain explanation, and the remedy is to delete it and subscribe again.
  • Delivery queue — the queue that belongs to one subscription. It exists from the moment your request is accepted and carries the events plus the platform's control messages — ready, updated, error — which the Application SDK handles for you, so your event handler only ever sees events.
  • Coverage report — what the platform tells you when a subscription is ready, and again whenever its coverage changes: per event type, whether it is currently covered and, if not, why; plus how many sensors were matched, how many of them are serving it, and how many processors were started or reused. It never lists individual sensors. Nothing covered yet is not an error — the subscription is live, and fills in as sensors and lenses change.
  • Lens — a named selection of processing, chosen by a short alias: one of your organization's own, or one another organization has made public. The lens decides how raw sensor data becomes the events you receive — two lenses over the same sensors can produce different event streams.
  • Event type — a category of observation (person, vehicle, …), drawn from the tag vocabulary — the platform lists the valid event types for you.
  • Geographic region — a short code for a map area, one to nine characters long; shorter codes cover more ground, longer codes zoom in to a city block and beyond. A region selects the sensors whose area of view overlaps it — not where the sensor stands — and * means everywhere you can see. It selects sensors, not individual events: every event of your types from those sensors is delivered.
  • Organization — your tenant: it owns your members, credentials, sensors, lenses, and subscriptions, and keeps them private — a sensor, template or lens reaches other organizations only when you publish it. Even then, other organizations can see a published sensor and which organization owns it, but never its connection details or metadata.
  • Re-check — once an hour the platform checks every active subscription against the world — sensors installed, published, unpublished or decommissioned; lenses and templates changed; processors that failed — and tells you with an updated message when your coverage changes. The full life of a subscription, from accepted to released, is drawn in Subscriptions & Events.

New to the platform? Read the System overview for the full picture, the glossary for the shared vocabulary, and Subscriptions & Events for how a subscription becomes a stream.