Stop Losing Events.
Start Trusting Your Pipeline.
EventEngine is a schema-first event pipeline for Rails. Define events with a Ruby DSL, persist via the transactional outbox pattern, and deliver through Kafka or any transport. Never lose an event again.
# One line. Full pipeline.
EventEngine.order_placed(order: @order)
# What happens under the hood:
# 1. Schema validated
# 2. Persisted to outbox (same transaction)
# 3. Published to Kafka
# 4. Dead-letter on failureEvent Systems That Break in Production
Lost events
Fire-and-forget publishing means when Kafka is down, events vanish.
Schema chaos
No contract between producers and consumers. Breaking changes ship silently.
Debugging nightmares
When something goes wrong, there’s no audit trail. No retry. No visibility.
EventEngine Makes Events Reliable
Outbox pattern
Events persist to your database first. Publishing happens after. Nothing is lost.
Schema-first
A compiled schema file is your contract. Drift detection catches breaking changes in CI.
Full observability
Every event is in the outbox. Retries, dead letters, and a dashboard — built in.
How It Works
Five steps from definition to delivery. No boilerplate. No glue code.
Define
Write event definitions using a clean Ruby DSL.
class OrderPlaced < EventEngine::EventDefinition
input :order
event_name :order_placed
event_type :domain
required_payload :total, from: :order, attr: :total
required_payload :customer_id, from: :order, attr: :customer_id
endCompile
Run a rake task to compile definitions into a canonical schema file.
bin/rails event_engine:schema:dump
# => Wrote db/event_schema.rb (2 events, 3 versions)Boot
At Rails boot, the schema file loads into the registry and installs helper methods.
# Automatic — no setup code needed
EventEngine.order_placed # method exists at boot
EventEngine.user_signed_up # method exists at bootEmit
Call the helper method. The event is validated, built, and persisted to the outbox.
EventEngine.order_placed(order: @order)
# Validates inputs, builds payload, writes to outboxPublish
The outbox publisher sends events to your transport. Failures retry automatically.
# Publishes to Kafka, retries on failure,
# dead-letters after max_attemptsEverything You Need for Reliable Events
Built for Rails. Battle-tested patterns. Zero boilerplate.
Ruby DSL
Define events with a clean, declarative Ruby DSL. Inputs, payloads, types — all in one class.
Outbox Pattern
Events are persisted to your database before publishing. If your transport is down, events are safe.
Schema Versioning
SHA256 fingerprinting detects payload changes and auto-increments versions. Old consumers keep working.
Drift Detection
CI rake tasks compare your DSL definitions against the committed schema file. Breaking changes are caught before deploy.
Dead Letter Handling
Failed events retry up to max_attempts then move to a dead-letter queue. Inspect and replay from the dashboard.
Pluggable Transports
Ship with InMemory (dev), Kafka (production), or write your own. One interface: publish(event).
See It Working. Right Now.
No signup. No install. Emit real events, watch them flow through the pipeline, and inspect the outbox — all in your browser.
Launch the Demo →Clean, Expressive Code
EventEngine fits naturally into your Rails app. No XML. No YAML. Just Ruby.
class OrderPlaced < EventEngine::EventDefinition
input :order
optional_input :coupon
event_name :order_placed
event_type :domain
required_payload :order_id, from: :order, attr: :id
required_payload :total, from: :order, attr: :total
required_payload :currency, from: :order, attr: :currency
optional_payload :coupon_code, from: :coupon, attr: :code
end# In your controller, service, or model callback
order = Order.create!(params)
EventEngine.order_placed(
order: order,
coupon: applied_coupon,
metadata: { request_id: request.request_id }
)# config/initializers/event_engine.rb
EventEngine.configure do |config|
config.delivery_adapter = :active_job
config.transport = EventEngine::Transports::Kafka.new(
producer: EventEngine::KafkaProducer.new(client: kafka)
)
config.batch_size = 100
config.max_attempts = 5
config.retention_period = 30.days
endMonitor Your Pipeline
A hosted dashboard for your EventEngine deployment. Track every event, catch schema drift, and manage dead letters—without building it yourself.
Real-time Event Dashboard
Live stream of every event flowing through your pipeline with filtering and search.
Schema Catalog & Drift Detection
Browse every event schema. Get alerted when definitions change across deploys.
Dead Letter Management
Inspect failed events, view error details, and retry with one click.
Alert Rules
Set thresholds on failure rates, throughput drops, or schema violations. Get notified instantly.
Multi-app Monitoring
Connect multiple Rails apps to one dashboard. Compare event health across services.
Environment Comparison
Diff schemas between staging and production. Catch mismatches before they ship.
Simple, Transparent Pricing
Start free. Scale when you’re ready.
Open Source
- ✓ EventEngine gem (MIT)
- ✓ Full DSL, outbox pattern, transports
- ✓ GitHub Issues support
- ✓ Community documentation
Platform
- ✓ Everything in Open Source
- ✓ Real-time event monitoring dashboard
- ✓ Schema catalog & drift detection
- ✓ Dead letter management & retry
- ✓ Alert rules & notifications
- ✓ Multi-app support
Enterprise
- ✓ Everything in Platform
- ✓ Implementation consulting
- ✓ Dedicated Slack channel
- ✓ Event schema reviews on PRs
- ✓ Performance monitoring & tuning
- ✓ Priority support & architecture advisory
Frequently Asked Questions
Everything you need to know about EventEngine.
EventEngine v0.1.0 is stable and tested. It implements the outbox pattern which is a proven reliability strategy used by companies like Shopify and Stripe.
No. EventEngine ships with InMemory (for dev/test) and Kafka transports, but you can write a custom transport in ~10 lines of Ruby. Any system that can receive messages works.
When you change a payload field, EventEngine detects the change via SHA256 fingerprinting and assigns a new version number. Old versions are preserved, so existing consumers continue working.
The event stays in the outbox. The publisher retries on the next run. After max_attempts failures, the event is dead-lettered. You can inspect and replay dead-lettered events from the dashboard or via rake tasks.
Yes. EventEngine uses ActiveJob, so it works with any ActiveJob backend.
Rails 7.1+ is required.
Ready to Make Your Events Reliable?
Get started with the gem or monitor your pipeline with the hosted platform.