Authorized feed → internal automated trading systems

Market-data
event bus.

goblin-slurp is the software event bus between your authorized Massive.com WebSocket feed and your internal automated trading systems. It connects to Goblin Core over a native shared-memory ringbuffer for low-latency ingest, then routes each event onto a Redis-compatible Pub/Sub channel inside your infrastructure.

Build from source Wire the stream

Internal routing only Goblin Core ringbuffer Apache-2.0 C++23

A black-and-white Silkie chicken, the goblin-slurp mascot

goblin-core://ringbuffer routing

T:IBM{"ev":"T","sym":"IBM"…}MSG
Q:AMD{"ev":"Q","sym":"AMD"…}MSG
XT:BTC-USD{"ev":"XT","pair":"BTC-USD"…}MSG
V:I:SPX{"ev":"V","T":"I:SPX"…}MSG

The data path

One focused event bus from the feed to your internal consumers.

Keep the feed connection draining, split each WebSocket frame into its individual events, and hand internal fan-out to Goblin Core.

01 / INGEST

Read Massive

Boost.Beast and OpenSSL consume one real-time or delayed asset-class feed and timestamp each arriving frame.

02 / SPLIT

Separate events

simdjson walks the array. Each object keeps its own bytes, receives ingest coordinates, and advances immediately.

03 / ROUTE

Fan out through Goblin Core

The native shared-memory ringbuffer carries one event at a time into Goblin Core, where internal consumers use familiar Redis Pub/Sub channels.

Internal message model

The WebSocket frame is transport. The event is the message.

The rule that keeps consumers simple

One object in.
One message out.

Route by instrument

A subscriber asks for T:IBM, Q:IBM, or a pattern such as XT:*. It never unpacks unrelated symbols.

Route before parsing ahead

An event does not wait for the rest of its WebSocket frame. The routing path advances object by object.

Preserve arrival context

JSON carries received, _n, and _i; SBE carries the frame ingest time in a typed field.

Two payloads, same channels

Readable by default. Binary when the path demands it.

Changing payload format never changes subscriptions. Consumers keep the same Redis channel names while the body moves between lossless JSON and fixed-layout SBE.

JSON

default

The individual Massive object, passed through byte for byte, with compact ingest metadata appended.

Choose for: Everyday Redis clients and full feed fidelity
Decode: Nothing custom
Enable: No flag needed

SBE

opt in

A compact, fixed-size market-data block nested inside the Goblin Core command envelope for constant-offset decoding.

Choose for: Latency-sensitive native consumers
Decode: Reference Python codec included
Enable: --sbe-out

First internal message

Start Goblin Core. Point the slurper. Subscribe.

The goblin-slurp event bus uses Goblin Core's shared-memory ringbuffer for low-latency ingest and its Redis-compatible Pub/Sub interface for consumers inside your automated trading systems.

~/goblin-slurp

# terminal 1 — give Goblin Core an ingest ringbuffer
$ goblin-core --port 6379 \
    --ring /tmp/goblin-slurp 8mb \
    --unsolicited-output-buffer-bytes 4mb

# terminal 2 — bridge a Massive feed
$ export MASSIVE_API_KEY=...
$ ./build/goblin-slurp \
    --type stocks IBM AMD SPY

# terminal 3 — consume normal Redis Pub/Sub
$ redis-cli PSUBSCRIBE 'T:*' 'Q:*'

Operator's desk

Two short paths from checkout to live channels.

01 / BUILD

Install goblin-slurp

Dependencies, CMake options, a verified release build, and installation.

02 / RUN

Set up the stream

Credentials, goblin-core, subscriptions, payloads, consumers, and production checks.