Protocol-Lattice/GoEventBus
68.2
Adequate · 8 November 2026
5k
lines of production code
Go
primary language
7
measurements over time
What this system is
GoEventBus is a Go library that provides an event bus system for publishing, routing, and dispatching events to handlers. It supports asynchronous processing with configurable buffer overrun policies, dead-letter queues, and middleware hooks. The system integrates with external brokers like Redis and RabbitMQ for persistent storage and cross-process delivery, and includes experimental support for intelligent, AI-assisted event routing.
How it got here
2024–2025 — Event bus core features and examples
9 changes.
The project established its foundational Go 1.23 dependencies and introduced core event bus capabilities, including batch dispatch, dead-letter queues, and external broker providers. This period also focused on comprehensive documentation through a suite of example applications demonstrating typed projections, middleware, timeout handling, and integration with fasthttp.
2026 — Intelligent routing examples and website launch
6 changes.
This period focused on expanding the GoEventBus library's documentation and demonstration capabilities by launching a comprehensive website with interactive demos. It also introduced a suite of new example applications illustrating intelligent event routing, caching strategies, and transactional workflows using the JEV selector with various message brokers like Redis and RabbitMQ.
Features
Add JEV transaction example
Added a new Go example demonstrating how to use the JEV (Justify Event Validation) selector within a transactional workflow. The example shows configuring a RuleCacheSelector with a JevSelector fallback, registering event handlers for 'order.created' and 'invoice.created', and executing a DecideAndPublish operation that buffers a decision before committing the transaction.
_examples/transaction\jev · high confidence
Add RabbitMQ-backed EventStore example for event routing
The examples/rabbitmq directory now includes a Go application that demonstrates using the RabbitMQ provider for the EventStore. This example configures a connection to a RabbitMQ broker (defaulting to localhost) to publish and consume events, specifically showing how to route an 'order.created' event through RabbitMQ and handle the resulting decision choice.
examples/rabbitmq · high confidence
Add Redis-backed event store example
A new Go example in the examples/redis directory demonstrates how to configure the event bus with a Redis-based event store. The code shows how to connect to a Redis instance, set up a stream consumer group, and use the DecideAndSubscribe method to route decisions through Redis, allowing users to see how to integrate Redis as a persistence and distribution layer for event-driven workflows.
examples/redis · high confidence
Added GoEventBus hello world example
A new example demonstrating how to use the GoEventBus library has been added to the examples/hello\_world directory. The code shows how to create a dispatcher with a handler for a 'say\_hello' projection, initialize an EventStore with an 8K buffer and a DropOldest policy, and publish an event containing a name argument.
_examples/hello\world · high confidence
Added JEV scheduling example
A new Go example demonstrating how to use the JEV (Just-Enough-Verification) selector for event scheduling. The example shows configuring a RuleCacheSelector with a JevSelector fallback, defining event candidates, and using DecideAndScheduleAfter to determine and schedule an event based on an LLM decision.
_examples/schedule\jev · high confidence
Added examples for event store overrun policies
New example programs have been added to demonstrate the behavior of the event store's overrun policies. The \drop\_oldest\ example shows how the system silently discards events when the buffer is full, while the \return\_error\ example illustrates the fail-fast behavior where subscribing additional handlers returns an error once the capacity is reached.
_examples/drop\oldest · high confidence
Added fasthttp example demonstrating event enqueueing and scheduled publishing
A new example application using fasthttp has been added to the examples/fasthttp directory. This example demonstrates how to integrate the GoEventBus library by setting up a dispatcher with handlers for 'sayHello' and 'computeSum' projections, creating an EventStore, and exposing an HTTP endpoint at /enqueue that accepts events via query parameters. The application runs a background loop that publishes enqueued events every 5 seconds, illustrating a pattern where HTTP requests enqueue events for asynchronous processing rather than immediate dispatch.
examples/fasthttp · high confidence
Added goroutine-based event subscription and publisher example
A new example file (examples/goroutines-subscribe-publisher/main.go) demonstrates how to use the GoEventBus library with asynchronous event handling. The example shows setting up a dispatcher with a 'user\_created' handler, creating an async event store, and running separate goroutines for event subscription (enqueueing) and publishing, along with graceful shutdown handling via context cancellation and signal listening.
examples/goroutines-subscribe-publisher · high confidence
Added intelligent event routing examples
New example applications demonstrate intelligent event routing scenarios using the GoEventBus library. The routing\_rules example shows how to use explicit rules to match event candidates, routing\_cache illustrates caching decision logic to optimize performance, and routing\_jev combines rule-based matching with a JevSelector fallback for AI-assisted routing.
_examples/routing\_cache, examples/routing\_jev, examples/routing\rules · high confidence
Added middleware and hooks example for the GoEventBus EventStore
A new example file demonstrates how to integrate middleware and lifecycle hooks into the GoEventBus EventStore. It shows how to register a logging middleware to track handler execution time, as well as before, after, and error hooks to observe event processing, and includes a complete run-through of publishing events and retrieving metrics.
examples/middleware · high confidence
Added publisher example demonstrating typed event projections
A new example file (examples/publisher/main.go) has been added to demonstrate how to use the GoEventBus library with typed event projections. The example shows defining a struct (HouseWasSold) as a projection key alongside string-based keys (user\_created), publishing events with specific arguments, and handling them in a dispatcher. It also illustrates asynchronous publishing, graceful shutdown via signal handling, and retrieving metrics after draining the event store.
examples/publisher · high confidence
Added timeout handling examples for event handlers and publishers
New example programs demonstrate how the event bus handles timeouts: handler\_timeout shows a handler being cancelled when it exceeds a context deadline, and publisher\_timeout illustrates back-pressure behavior when the event store buffer is full and a publish operation times out.
_examples/handler\timeout · high confidence
GoEventBus website launch with documentation and interactive demos
The GoEventBus website is now live, providing a landing page that explains the event bus architecture and an interactive routing pipeline demo. A comprehensive documentation site is included, featuring guides on installation, event handling, and 12 official broker providers (Redis, RabbitMQ, NATS, Kafka, etc.), along with an API reference and benchmark results. The site also includes a client-side search feature and code examples for both direct dispatch and intelligent routing with Jev.
website · high confidence
Introduce batch event dispatch, dead-letter queue, and external broker providers
The event bus now supports batch handlers via \RegisterBatch\, which collect events for a projection and deliver them as slices to reduce per-event overhead for bulk operations. A new Dead Letter Queue (DLQ) captures events that fail or panic during dispatch, allowing inspection and replay. Additionally, the library adds a \Provider\ interface with a \JSONCodec\ for serializing events to external brokers like Redis Streams and RabbitMQ, enabling cross-process event delivery.
(repo-wide) · high confidence
Dependencies
Initial project setup with Go 1.23 and core dependencies
The project is initialized with Go 1.23.0 (toolchain 1.23.7) and establishes its primary dependencies: \github.com/fasthttp/router\ (v1.5.4), \github.com/rabbitmq/amqp091-go\ (v1.14.0), \github.com/redis/go-redis/v9\ (v9.18.0), and \github.com/valyala/fasthttp\ (v1.61.0). The \go.mod\ also includes \testcontainers-go\ (v0.34.0) for testing infrastructure. Example modules (\hello\_world\, \publisher\, \goroutines-subscribe-publisher\) are added, depending on \github.com/Protocol-Lattice/GoEventBus\ versions v0.1.44 and v0.1.45.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 65 → 68 (+3.3)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 93 → 93 (+0.0)
- Architecture 100 → 99 (-1.0)
- Maturity 56 → 61 (+5.5)
- Readiness 67 → 67 (+0.0)
- Security 72 → 71 (-1.0)
- Performance 73 → 85 (+12.0)
New (1)
- Medium CVE: GO-2026-6888 (go.mod)
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
Protocol-Lattice/GoEventBus was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 8 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 35575c2482234c644a832861f19927db2f6192de — the exact code this score is about.
- Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-45ab2cab63de.