ThreeDotsLabs/watermill
Watermill
Watermill is a Go library for building event-driven applications. It provides a framework for implementing event-driven architectures through a consistent interface for message publishing and subscribing, featuring a pub/sub message router and event stream processing pipelines.
The library uses interface-based abstractions to decouple message producers and consumers from the underlying message broker. This allows different messaging technologies to be swapped via plugin-based broker integration. It employs a router-driven dispatch system and middleware-based pipelines to manage cross-cutting concerns and business logic.
The framework provides tools for coordinating distributed event processing and complex application patterns. This includes support for event sourcing to track application state as a sequence of events and the saga pattern for coordinating distributed transactions across multiple services.
Features
- Broker Abstractions - Provides a common set of Go interfaces to decouple producers and consumers regardless of the underlying message broker.
- Streaming Processors - Ships a pipeline for processing message streams with configurable middlewares for business logic and resiliency.
- Message Queue Integrations - Connects Go services to various message brokers using a consistent interface for publishing and subscribing.
- Message Routing - Implements a system for orchestrating and directing messages between decoupled publishers and subscribers.
- Message Stream Handlers - Provides utilities for managing asynchronous message streams with configurable middleware for business logic and resiliency.
- Pub-Sub Messaging - Implements a routing system that decouples components by moving data between different publishers and subscribers.
- Asynchronous Messaging - Handles high-volume event streams by decoupling message reception from execution using non-blocking Go channels.
- Event-Driven Architectures - Provides a framework for building reactive Go applications that communicate through asynchronous events.
- Event-Driven Frameworks - Provides a comprehensive Go library for building event-driven applications with consistent publishing and subscribing interfaces.
- Event Driven Messaging - Directs messages from specific topics to designated handlers based on a centralized routing configuration.
- Composable Middleware Pipelines - Wraps message handlers in composable middleware chains to manage cross-cutting concerns like logging and retries.
- Distributed Event Routers - Handles streams of data across multiple services with built-in support for routing and resiliency patterns.
- Broker Adapters - Allows different messaging technologies to be swapped via a standard publisher and subscriber adapter system.
- Saga Coordinators - Manages complex distributed transactions across multiple services by coordinating local events and compensations.
- Event Sourcing - Implements patterns to track application state as an immutable sequence of events for complete history maintenance.
- Distributed Coordination Patterns - Provides an interface for managing complex patterns such as event sourcing and sagas to coordinate requests.
- Data Processing and Streams - Message-driven application library.
- Messaging Systems - Toolkit for building event-driven applications and streams.
- Implementation Patterns - Event-driven application building with Pub/Sub and CQRS middleware.
- Messaging - Listed in the “Messaging” section of the Awesome Go awesome list.
Star history
How this analysis was created: This summary and feature list were written by an AI model that read the project's README and public documentation pages. Each feature links to the documentation it came from; stars, license and language come straight from the GitHub API. The model does not read the source code, and the analysis is refreshed when the project is re-analysed. Learn more on our About page.
