Stratara.Outbox.RabbitMQ 3.1.3

.NET 10.0

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

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

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

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

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

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

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

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

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

                            Install as a Cake Addin

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

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

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.	594
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.	561

GitHub repositories

This package is not used by any popular GitHub repositories.

Version	Downloads	Last Updated
3.1.3	98	6/10/2026
3.1.2	141	6/5/2026
3.1.1	203	6/1/2026
3.1.0	127	5/30/2026
3.0.23	116	5/28/2026

### Added

- **Mediator tenant-isolation behavior** (`Stratara.Mediator`) — `AddStrataraTenantIsolation()`
registers a pipeline behavior that enforces tenant isolation at the mediator entrance, before the
handler runs, for any request that opts in via the new `ITenantScopedRequest` marker
(`Stratara.Abstractions.Multitenancy`). The behavior compares the request's `TenantId` (data owner)
against the ambient session's data-owner tenant and rejects a mismatch with the new
`TenantAccessDeniedException` (translated to HTTP 403 on ASP.NET hosts). `TenantIsolationMode.Default`
enforces only the subject match (privileged cross-tenant operations pass when the endpoint promoted
the session subject to the target); `TenantIsolationMode.Strict` additionally routes every
cross-tenant operation through the new `ICrossTenantAuthorizer`, whose shipped default denies all
cross-tenant access until a consumer registers its own authorizer. Complements the existing
database-side `ApplyGlobalTenantQueryFilters` with a command-/query-entrance guard. New log-event
IDs `114_101`/`114_102`/`114_003` in `Stratara.Diagnostics`.
- **`Stratara.Abstractions.Persistence.ConcurrencyConflictException`** — provider-agnostic
wrapper for an optimistic-concurrency conflict detected during commit. Allows framework-level
code in `Stratara.Projections` (and any consumer outside the `EntityFrameworkCore` package) to
react to concurrency without taking an EF Core dependency. EF Core's `DbUpdateConcurrencyException`
(and provider equivalents) flow through this type.

### Changed

- **`EfTransaction.SaveChangesAsync`** (in `Stratara.EventSourcing.EntityFrameworkCore`) now
wraps `DbUpdateConcurrencyException` thrown by EF Core in the new
`ConcurrencyConflictException`. PostgreSQL unique-violation paths remain on `DbUpdateException`
(different semantics — duplicate-key on insert vs. stale-row on update/delete).
- **`EventSource.SaveChangesAsync`** (write-side append flow) extends its concurrency-handling
catch to the new exception type so the existing append-conflict recovery path keeps working
after the wrap. Behaviour for both EF concurrency conflicts and PostgreSQL unique violations
is unchanged.

### Fixed

- **`TenantProjection` no longer aborts the event bundle on a parallel delete race.** The two
delete handlers (`TenantDeleted`, `CustomerTenantsDeleted`) now swallow
`ConcurrencyConflictException` silently — a missing row is the desired end-state of a delete.
Before this fix, a consumer-side customer-delete cascade saga that emits both
`CustomerTenantsDeleted` and a follow-up `TenantDeleted` for the same tenants would race the
two parallel projection bundles on the same `TenantView` row; the loser threw
`DbUpdateConcurrencyException` out of `SaveChangesAsync`, which propagated through
`ProjectionWorker` and caused `RabbitMqBus` to roll back the entire bundle — including
sibling projections that had already committed. Update handlers (rename / activate /
deactivate / locale / customer-assigned) keep their current behaviour: a concurrency failure
there is a real race that propagates.