Stratara.Outbox.RabbitMQ 3.1.0

There is a newer version of this package available.
See the version list below for details.

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

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

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.0" />

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.0" />
                    

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

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

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

#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.0

#: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.0
                    

                            Install as a Cake Addin

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

                            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.0)
- Stratara.Contracts (>= 3.1.0)
- Stratara.Mediator (>= 3.1.0)
- Stratara.Sessions (>= 3.1.0)
- Stratara.Shared (>= 3.1.0)

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.	290
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.	168

GitHub repositories

This package is not used by any popular GitHub repositories.

Version	Downloads	Last Updated
3.1.1	81	6/1/2026
3.1.0	95	5/30/2026
3.0.23	85	5/28/2026

**Breaking release.** The `IKeyStore` and `ISecureBlobEncryptor` contracts changed shape, a new
dependency-light `Stratara.Security` package now owns the production key store and envelope
encryption, and a new vendor-neutral `Stratara.Validation` package adds request validation as a
`Stratara.Mediator` pipeline behavior. Consumers must recompile and adapt call sites; data
encrypted under the previous HKDF-style key model is **not** binary-compatible and needs a
re-encrypt pass on its own schedule.

### Added

- **`Stratara.Validation` — vendor-neutral request validation.** A new package providing a
mediator pipeline behavior that runs `IValidator<T>` implementations before the handler and
throws an aggregated `StrataraValidationException` on failure. Register with
`AddStrataraValidation()` (outermost behavior) and `AddValidatorsFromAssemblyContaining<T>()`.
Only `ValidationSeverity.Error` blocks the request; `Warning`/`Info` failures pass through and
are logged. The package has no FluentValidation dependency — the contract is intentionally
FluentValidation-shape-compatible so an optional adapter can be added later.
- **Validation contracts in `Stratara.Abstractions`** (namespace `Stratara.Abstractions.Validation`):
`IValidator<T>`, `ValidationResult`, `ValidationFailure`, `ValidationSeverity`, and
`StrataraValidationException`. Declaring the exception in `Stratara.Abstractions` lets a
consumer's global exception handler map validation failures to its own error model (e.g.
RFC-7807 ProblemDetails) without referencing the behavior package.
- **`Stratara.Security` — production key store + envelope encryption (dependency-light).** Adds
`EnvelopeFileKeyStore`, a file-backed `IKeyStore` storing **KEK-wrapped, versioned per-scope
data-encryption keys** (rotation, single-version revoke, and whole-scope crypto-shred), plus a
`FileMasterKeyProvider` (`IMasterKeyProvider`, the KEK custody seam), an AES-GCM
`ISecureBlobEncryptor`, and the Development-only `DummyKeyStore`. Register with
`AddStrataraFileKeyStore(configuration)`. The package references only `Stratara.Abstractions` +
BCL crypto + `Microsoft.Extensions.*` abstractions — no EF Core, RabbitMQ, Redis, or cloud SDKs —
so lean consumers can encrypt without pulling in `Stratara.Infrastructure`.
- **New security contracts in `Stratara.Abstractions.Security`:** `KeyScope`, `KeyMaterial`, and
`IMasterKeyProvider`.

### Changed

- **BREAKING — `IKeyStore`.** Replaced `EnsureKeyAsync(level, Guid? tenantId, Guid? userId)` with
`GetOrCreateCurrentKeyAsync(KeyScope)` returning `KeyMaterial` (key id + bytes in one call), and
added `RotateAsync(KeyScope)` and `EraseScopeAsync(KeyScope)`. `RevokeAsync(string keyId)` now
performs a real crypto-shred (the production store no longer treats it as a no-op). Scope
identifiers are `string?` (carrying both slugs and `Guid.ToString()` values) rather than `Guid?`.
- **BREAKING — `ISecureBlobEncryptor`.** `EncryptAsync`/`DecryptAsync` now take a `KeyScope` and a
`purpose` instead of a bare `Guid tenantId`. The encrypted stream gains a leading version byte
(v2) and a `purpose` field; legacy streams without the version byte remain readable (configurable
via `Stratara.Security` options).
- The AES-GCM encryption factory, blob encryptor, and dev key store moved out of
`Stratara.Infrastructure` into `Stratara.Security`; `AddSecurity()` now delegates to it. The
field/JSON `[EncryptData]` path (`ISecureJsonSerializer`) stays in `Stratara.Infrastructure`.

This brings the lockstep family to **22 packable packages**.