Stratara.Outbox.RabbitMQ 3.1.1

.NET 10.0

dotnet add package Stratara.Outbox.RabbitMQ --version 3.1.1

NuGet\Install-Package Stratara.Outbox.RabbitMQ -Version 3.1.1

This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.

<PackageReference Include="Stratara.Outbox.RabbitMQ" Version="3.1.1" />

For projects that support PackageReference, copy this XML node into the project file to reference the package.

<PackageVersion Include="Stratara.Outbox.RabbitMQ" Version="3.1.1" />
                    

                            Directory.Packages.props

<PackageReference Include="Stratara.Outbox.RabbitMQ" />
                    

                            Project file

For projects that support Central Package Management (CPM), copy this XML node into the solution Directory.Packages.props file to version the package.

paket add Stratara.Outbox.RabbitMQ --version 3.1.1

The NuGet Team does not provide support for this client. Please contact its maintainers for support.

#r "nuget: Stratara.Outbox.RabbitMQ, 3.1.1"

#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.

#:package Stratara.Outbox.RabbitMQ@3.1.1

#:package directive can be used in C# file-based apps starting in .NET 10 preview 4. Copy this into a .cs file before any lines of code to reference the package.

#addin nuget:?package=Stratara.Outbox.RabbitMQ&version=3.1.1
                    

                            Install as a Cake Addin

#tool nuget:?package=Stratara.Outbox.RabbitMQ&version=3.1.1
                    

                            Install as a Cake Tool

The NuGet Team does not provide support for this client. Please contact its maintainers for support.

Stratara.Outbox.RabbitMQ

License: FSL-1.1-MIT (Functional Source License — source-available; converts to MIT after 2 years). Not OSI-approved OSS.

Outbox-pattern command + event dispatch for the Stratara event-sourced stack with a RabbitMQ / Azure Service Bus message-bus implementation. Contains the write-side dispatchers, the outbox-retry worker, the read-side mediator command worker, the message-bus implementations, and the Redis-backed ProjectionReplayState that coordinates dispatch skip during projection replay.

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. 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` (Redis-backed concrete `IProjectionReplayState`; dispatchers skip publishing while replay is active)
`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.

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 — for ICommand, IEvent, IMessageBus, ICommandOutboxDispatcher, IEventBundleOutboxDispatcher, IProjectionReplayState, IMessagingIdentifier, IWriteUnitOfWork (used at runtime via the outbox repository).
Stratara.Contracts — for EventBundle + CommandEnvelope messages.
Stratara.Mediator — MediatorCommandWorker dispatches into the in-process IMediator.
Stratara.Sessions — dispatcher hydrates CommandEnvelope from the current session context.
Stratara.Shared — for messaging primitives, resilience pipeline names, mapping helpers, and the diagnostics base.
RabbitMQ.Client, StackExchange.Redis (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 in Stratara.Abstractions, but the concrete implementation comes from Stratara.EventSourcing.EntityFrameworkCore. Reference that package alongside this one to get a working stack.

Product	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.

Compatible target framework(s)

Included target framework(s) (in package)

Learn more about Target Frameworks and .NET Standard.

net10.0
- Microsoft.Extensions.Configuration.Abstractions (>= 10.0.8)
- Microsoft.Extensions.DependencyInjection (>= 10.0.8)
- Microsoft.Extensions.Hosting.Abstractions (>= 10.0.8)
- Microsoft.Extensions.Logging.Abstractions (>= 10.0.8)
- Microsoft.Extensions.Options.ConfigurationExtensions (>= 10.0.8)
- RabbitMQ.Client (>= 7.2.1)
- StackExchange.Redis (>= 2.13.10)
- Stratara.Abstractions (>= 3.1.1)
- Stratara.Contracts (>= 3.1.1)
- Stratara.Mediator (>= 3.1.1)
- Stratara.Sessions (>= 3.1.1)
- Stratara.Shared (>= 3.1.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.	131
Stratara.EventSourcing.WorkerDefaults Worker-host wiring composites for the Stratara event-sourced stack. IHostApplicationBuilder extensions (AddBackendServices, AddCommandWorkerServices, AddEventProjectionWorkerServices, AddSagaWorkerServices, AddOutboxWorkerServices) bundle the per-concern DI calls so each worker host opts in with one line.	128

GitHub repositories

This package is not used by any popular GitHub repositories.

Version	Downloads	Last Updated
3.1.1	57	6/1/2026
3.1.0	74	5/30/2026
3.0.23	66	5/28/2026

### Fixed

- **`FileMasterKeyProvider` now rejects a master KEK that is not exactly 32 bytes at startup.**
The KEK is used directly as an AES-256-GCM key, which accepts only 16/24/32-byte keys. The
provider previously required merely *at least* 32 bytes, so a longer KEK (for example the
48-byte output of `openssl rand -base64 48`, a common HKDF master-key recipe) passed both
construction and the eager `FileKeyStoreStartupProbe`, then threw
`CryptographicException: Specified key is not a valid size for this algorithm` on the **first**
key creation at runtime — defeating the purpose of the boot-time probe. The provider now
validates the decoded length is exactly 32 bytes and fails fast at boot with an actionable
message (`Generate one with: openssl rand -base64 32`). A 32-byte KEK is unaffected.
- **`EnvelopeFileKeyStore` is now safe for multiple processes sharing one store file** (for
example several containers bind-mounting the same host directory). Previously a process only
read the store once at construction, so a data-encryption key created by another process after
startup was invisible (`GetDataEncryptionKeyAsync` returned `null`, breaking decryption), and
two processes creating keys concurrently could overwrite each other's keys or mint colliding
versions for the same scope. Reads now reload from disk on a cache miss (guarded by the file's
last-write time to avoid reload storms), and every mutation serializes through an exclusive
cross-process lock file and re-reads the latest on-disk state before writing. A networked file
system (NFS/SMB) remains unsupported — it guarantees neither atomic rename nor reliable advisory
locks.

### Added

- **`LogEvents.KeyManagement.KeyStoreReloaded` (112_006)** — debug-level event emitted when the
file key store reloads its state from disk to pick up keys written by another process.