Stratara.Outbox.RabbitMQ
4.6.1
Prefix Reserved
See the version list below for details.
dotnet add package Stratara.Outbox.RabbitMQ --version 4.6.1
NuGet\Install-Package Stratara.Outbox.RabbitMQ -Version 4.6.1
<PackageReference Include="Stratara.Outbox.RabbitMQ" Version="4.6.1" />
<PackageVersion Include="Stratara.Outbox.RabbitMQ" Version="4.6.1" />
<PackageReference Include="Stratara.Outbox.RabbitMQ" />
paket add Stratara.Outbox.RabbitMQ --version 4.6.1
#r "nuget: Stratara.Outbox.RabbitMQ, 4.6.1"
#:package Stratara.Outbox.RabbitMQ@4.6.1
#addin nuget:?package=Stratara.Outbox.RabbitMQ&version=4.6.1
#tool nuget:?package=Stratara.Outbox.RabbitMQ&version=4.6.1
Stratara.Outbox.RabbitMQ
Derived. The behaviour described here is specified under
openspec/specs/. Those specifications are the source; this page explains and illustrates them.
License: MIT.
Outbox-pattern command + event dispatch for the Stratara event-sourced stack with a RabbitMQ message-bus implementation. Contains the write-side dispatchers, the outbox-retry worker, the read-side mediator command worker, the RabbitMQ bus, and the ProjectionReplayState that coordinates dispatch skip during projection replay — shared over Redis where a connection is registered, held in process otherwise. Azure Service Bus ships separately as Stratara.Outbox.AzureServiceBus.
What's in the box
| Folder | Contents |
|---|---|
Outbox/ |
OutboxOptions, CommandOutboxDispatcher (write-side ICommand fan-out via IMessageBus, falls back to outbox table on bus failure), EventBundleOutboxDispatcher (same for EventBundle), OutboxWorker (hosted service that retries unpublished outbox rows on a polling interval), NullOutboxLock + RedisOutboxLock (IOutboxLock implementations — default no-op for single-instance deployments, Redis-leased distributed lock for multi-replica setups) |
Messaging/ |
RabbitMqBus — IMessageBus over RabbitMQ. A worker subscription is a quorum queue <subscription>.v2 with <subscription>.dead-letter beside it; a message a handler cannot take is redelivered under MessageRetryOptions and then dead-lettered. A subscription holds at most Messaging:PrefetchCount messages (default 16), and the host waits for a stopping subscription's running handler to settle before it counts as stopped — within the host's shutdown timeout; twenty seconds for a subscription stopped on its own. Azure Service Bus ships as the sibling Stratara.Outbox.AzureServiceBus package. |
Mediator/ |
MediatorCommandWorker (hosted service that subscribes to the command topic and dispatches into the in-process IMediator) |
Projections/ |
ProjectionReplayState (concrete IProjectionReplayState, Redis-backed where a connection is registered, in process otherwise; dispatchers skip publishing while replay is active), ProjectionReplayOptions (how long the replay marking survives without renewal) |
DependencyInjection/ |
AddOutboxDispatcher(), AddOutboxWorker(IConfiguration), AddRedisOutboxLock() (opt-in distributed lock), AddProjectionReplayState(), AddMediatorWorker(), AddMessaging() |
Diagnostics/Extensions/ |
LoggerOutboxExtensions, LoggerMessagingExtensions (source-generated logger surfaces) |
Quick start
// In your API host:
builder.AddMessaging(); // IMessageBus + MessagingOptions binding
builder.Services
.AddOutboxDispatcher() // CommandOutboxDispatcher + EventBundleOutboxDispatcher + ProjectionReplayState
.AddOutboxWorker(builder.Configuration); // OutboxWorker hosted service (only if this host owns retries)
// In your command worker:
builder.Services
.AddMediatorWorker(); // MediatorCommandWorker hosted service
The dispatchers consult IProjectionReplayState.IsReplayActive before each publish and skip dispatch (writing to the outbox table only) while a replay is in progress. They also record the outbox.published counter for what the broker accepted — the worker counts nothing, because only the dispatcher knows what went out.
The replay marking and its progress counters are held on the lease configured by ProjectionReplayOptions.LeaseSeconds (default 300), which the replay renews every time it reports progress. A replay whose host is killed stops renewing it and the marking lapses on its own, instead of suppressing publication indefinitely. AddProjectionReplayState() reads the options from the ProjectionReplay section of the host's configuration; services.Configure<ProjectionReplayOptions>(...) after that call takes precedence. A lease of zero or less fails the host at start. Set it longer than the slowest stretch between two progress reports — too short lets the marking lapse while the replay is still running.
A drain cycle takes one batch of each kind and ends. Rows the broker would not accept stay in the table for the next interval; a cycle never re-reads what it just failed to publish, so an unreachable broker or a suppressed drain cannot turn a cycle into a loop over the same rows.
Multi-instance outbox workers
AddOutboxWorker registers NullOutboxLock as the default IOutboxLock — a no-op that preserves the single-instance assumption. For multi-replica deployments call AddRedisOutboxLock() afterwards; it replaces the no-op with a Redis-leased lock (SET stratara:outbox:lock NX EX) so only one replica drains at a time:
builder.AddCaching(); // registers IConnectionMultiplexer
builder.Services
.AddOutboxDispatcher()
.AddOutboxWorker(builder.Configuration)
.AddRedisOutboxLock(); // multi-replica safe
The lease defaults to 60 s (OutboxOptions.LockLeaseSeconds). Tune it so it exceeds the worst-case drain duration; otherwise the lock can expire mid-cycle and a peer may start a concurrent drain. Outbox semantics are still at-least-once, so a duplicate publish is recoverable provided handlers stay idempotent.
Dependencies
Stratara.Abstractions— forICommand,IEvent,IMessageBus,ICommandOutboxDispatcher,IEventBundleOutboxDispatcher,IProjectionReplayState,IMessagingIdentifier,IWriteUnitOfWork(used at runtime via the outbox repository).Stratara.Contracts— forEventBundle+CommandEnvelopemessages.Stratara.Mediator—MediatorCommandWorkerdispatches into the in-processIMediator.Stratara.Sessions— dispatcher hydratesCommandEnvelopefrom the current session context.Stratara.Shared— for messaging primitives, resilience pipeline names, mapping helpers, and the diagnostics base.RabbitMQ.Client,StackExchange.Redis(only used when a connection is registered: shared replay state, optional outbox lock).Microsoft.Extensions.Hosting.Abstractions+Microsoft.Extensions.Options.ConfigurationExtensions— for hosted services + options binding.
The outbox dispatcher persists rows through
IWriteUnitOfWork.CreateOutboxRepository— that interface lives inStratara.Abstractions, but the concrete implementation comes fromStratara.EventSourcing.EntityFrameworkCore. Reference that package alongside this one to get a working stack.
| Product | Versions Compatible and additional computed target framework versions. |
|---|---|
| .NET | net10.0 is compatible. net10.0-android was computed. net10.0-browser was computed. net10.0-ios was computed. net10.0-maccatalyst was computed. net10.0-macos was computed. net10.0-tvos was computed. net10.0-windows was computed. |
-
net10.0
- Microsoft.Extensions.Configuration.Abstractions (>= 10.0.13)
- Microsoft.Extensions.DependencyInjection (>= 10.0.13)
- Microsoft.Extensions.Hosting.Abstractions (>= 10.0.13)
- Microsoft.Extensions.Logging.Abstractions (>= 10.0.13)
- Microsoft.Extensions.Options.ConfigurationExtensions (>= 10.0.13)
- RabbitMQ.Client (>= 7.2.2)
- StackExchange.Redis (>= 3.4.5)
- Stratara.Abstractions (>= 4.6.1)
- Stratara.Contracts (>= 4.6.1)
- Stratara.Mediator (>= 4.6.1)
- Stratara.Sessions (>= 4.6.1)
- Stratara.Shared (>= 4.6.1)
NuGet packages (2)
Showing the top 2 NuGet packages that depend on Stratara.Outbox.RabbitMQ:
| Package | Downloads |
|---|---|
|
Stratara.Infrastructure
Infrastructure glue for the Stratara framework — authorization decorators, configuration providers, and DI composition helpers that wire Mediator, Outbox, Identity, and EF Core into a hosted app. |
|
|
Stratara.EventSourcing.WorkerDefaults
Worker-host wiring composites for the Stratara event-sourced stack. IHostApplicationBuilder extensions (AddBackendServices, AddCommandWorkerServices, AddHeavyCommandWorkerServices, AddEventProjectionWorkerServices, AddEventStreamHashWorkerServices, AddSagaWorkerServices, AddOutboxWorkerServices, and AddCommandServices, AddEventProjectionServices and AddSagaServices without the bus-fed workers) bundle the per-concern DI calls so each worker host opts in with one line. |
GitHub repositories
This package is not used by any popular GitHub repositories.
| Version | Downloads | Last Updated |
|---|---|---|
| 4.8.0 | 188 | 11/6/2026 |
| 4.7.1 | 169 | 11/5/2026 |
| 4.7.0 | 469 | 10/30/2026 |
| 4.6.1 | 142 | 10/29/2026 |
| 4.6.0 | 199 | 10/28/2026 |
| 4.5.0 | 303 | 10/28/2026 |
| 4.4.10 | 246 | 10/26/2026 |
| 4.4.9 | 144 | 10/26/2026 |
| 4.4.8 | 293 | 10/24/2026 |
| 4.4.7 | 152 | 10/23/2026 |
| 4.4.6 | 252 | 10/22/2026 |
| 4.4.5 | 341 | 10/14/2026 |
| 4.4.4 | 332 | 10/10/2026 |
| 4.4.3 | 156 | 10/10/2026 |
| 4.4.2 | 429 | 10/2/2026 |
| 4.4.1 | 402 | 9/29/2026 |
| 4.4.0 | 172 | 9/27/2026 |
| 4.3.1 | 165 | 9/25/2026 |
| 4.3.0 | 330 | 9/23/2026 |
| 4.2.0 | 200 | 9/18/2026 |
A release about two costs of the Orleans execution model that grew with the deployment rather than with the work.
A commit woke every projection and saga reader of each partition it touched, whatever it had committed. Every one of
them read the new entries and wrote its checkpoint, also when it applied nothing, and every reader polled the store on
its own: every single-event command cost a checkpoint write per projection and saga, and an idle silo with many
consumers kept the store busy with hundreds of reads a second. A commit now costs work only for the readers it
concerns, and an idle silo asks the store a few questions per partition and poll interval.
A recorded command whose handler met a concurrency conflict waited for its hand-over to lapse, 30 seconds by default,
before the drain ran it again; on the bus a conflicting message is redelivered at once. It now runs again within
moments.
### Added
- **`ProjectionGrainOptions.IdleCheckpointInterval`** (default 30 seconds) bounds how long a projection's reader may
hold its checkpoint back past entries it applied nothing for. `TimeSpan.Zero` writes the checkpoint after every
batch, as before.
- **`ICommandIntentStore.CountConflictAsync`** counts a conflict and records it without giving the attempt back, and
answers how many conflicts the command has met. The default records through `RecordConflictAsync` and answers
`null`, so an intent store of your own compiles and behaves as before; the framework's store implements it.
### Changed
- **A commit wakes only the readers whose projection or saga applies one of its event types.** This holds for the
wake-up on a silo with a store-reading role and for `AddStrataraStoreWakeUps()`. Woken by every commit as before:
a stateful saga process, which decides from the event itself, and every reader when the commit holds an event type
the silo cannot resolve or whose upcaster refuses an empty payload, or when the host's upcaster pipeline is its own.
A multi-stream commit wakes, in each partition, the readers of the events it wrote there. In a test host with six
projections of which one applied the commit, ten commits cost 59 store reads before and only the applying
projection's reads now, and a commit nobody applies costs no read when it is made. A reader whose partition moved
past it still reads once at its next poll, and then waits again.
- **A projection's reader writes its checkpoint past entries it applied nothing for later**: with the next batch that
applies something, once `IdleCheckpointInterval` has passed, or when it deactivates. It answers waits for its
projection from the position it holds. A reader whose silo dies before the write reads those entries again and
applies nothing for them. A rebuild or a replay discards a position held back. A saga's reader writes its checkpoint
after every batch as before, because a saga added to a running deployment starts where the host's sagas have
written they read.
- **A poll reads the store only when its partition holds something past the reader's position.** Each silo asks the
store for a partition's head at most once per half poll interval, for all its readers. In the test host, 96 idle
readers polling every 500 ms read the store about 960 times in five seconds before and not at all now. A lost
wake-up is applied within about one and a half poll intervals rather than one. A committed position reader that
does not override `ICommittedPositionReader.HeadAsync` keeps polling as before.
- **A conflicting recorded command runs again at once.** The silo that ran it runs it again in a unit of work of its
own while it still holds the hand-over, pausing as the `ResilienceNames.ConcurrencyConflict` pipeline does (five
retries from 50 ms), on the aggregate activation's scheduler. A heavy command keeps its permit. Every conflict is
still recorded and counted, and the command runs again only while its conflicts stay within
`MessageRetryOptions.MaxConflictRequeues`, so a command that conflicts on every attempt runs as often as before and
is kept. The hand-over's attempt is given back once when the command leaves on a conflict, however often it ran.
After the pipeline's retries the drain resumes it as before.
- **`ExecutionModelTestHost.WaitForReadersAsync` waits for the readers' positions**, not their stored checkpoints,
so it returns once every reader has read to the head, whether or not it has written its checkpoint there yet.
**Upgrading:** nothing to do. Hosts and silos of 4.6.0 and of this release mix in a rolling deployment: the cluster
wake-up keeps its form, an earlier host's wake-up wakes every reader, and an earlier silo wakes every reader of a newer
host's wake-up. Checkpoints keep their form. An intent store of your own keeps the old timing after a conflict until
it implements `CountConflictAsync`.