"No Async outbox defined" when using PostgreSqlOutbox

[CharlieDigital]

When using the Postgres outbox, I'm getting the following error:

 Unhandled exception. System.InvalidOperationException: No Async outbox defined.
at Paramore.Brighter.OutboxProducerMediator`2.ClearOutstandingFromOutboxAsync(Int32 amountToClear, TimeSpan minimumAge, Boolean useBulk, RequestContext requestContext, Dictionary`2 args, CancellationToken cancellationToken) in /_/src/Paramore.Brighter/OutboxProducerMediator.cs:line 419
at Paramore.Brighter.OutboxSweeper.SweepAsync() in /_/src/Paramore.Brighter/OutboxSweeper.cs:line 79
at Paramore.Brighter.Outbox.Hosting.TimedOutboxSweeper.Sweep(Object state) in /_/src/Paramore.Brighter.Outbox.Hosting/TimedOutboxSweeper.cs:line 124
at Paramore.Brighter.Outbox.Hosting.TimedOutboxSweeper.Sweep(Object state) in /_/src/Paramore.Brighter.Outbox.Hosting/TimedOutboxSweeper.cs:line 131
at System.Threading.Tasks.Task.<>c.<ThrowAsync>b__128_1(Object state)
at System.Threading.ThreadPoolWorkQueue.Dispatch()
at System.Threading.PortableThreadPool.WorkerThread.WorkerThreadStart()
                                at System.Threading.Thread.StartCallback()

Code sample is following a combination of branches from here: https://github.com/lillo42/brighter-sample/blob/v10-outbox-postgres/Program.cs to combine Kafka with outbox.

I looked through the codebase and PostgreSqlOutbox inherits RelationDatabaseOutbox which implements IAmAnOutboxSync<Message, DbTransaction>, IAmAnOutboxAsync<Message, DbTransaction> and a singleton instance is registered.

// Snip usings....

public static class SetupBrighterKafkaExtensions
{
    private static string connectionString =>
        Environment.GetEnvironmentVariable("ConnectionStrings__webapipg") ?? "";

    public static IServiceCollection AddBrighterWithKafka(
        this IServiceCollection services
    )
    {
        var kafka = new KafkaProducerRegistryFactory(
            new KafkaMessagingGatewayConfiguration
            {
                Name = "brighter-kafka",
                BootStrapServers =
                [
                    Environment.GetEnvironmentVariable("ConnectionStrings__kafka")
                        ?? ""
                ],
                SecurityProtocol = SecurityProtocol.Plaintext
            },
            [
                // TODO: Create one for each publish topic.
                new KafkaPublication
                {
                    MakeChannels = OnMissingChannel.Create,
                    Source = new Uri("aspire-kafka", UriKind.RelativeOrAbsolute),
                    Topic = new RoutingKey("email.topic")
                }
            ]
        ).Create();

        var db = new RelationalDatabaseConfiguration(
            connectionString,
            "brightertests"
        );

        var outbox = new PostgreSqlOutbox(db);
        var inbox = new PostgreSqlInbox(db);

        services
            .AddHostedService<ServiceActivatorHostedService>()
            .AddSingleton<IAmARelationalDatabaseConfiguration>(db)
            .AddSingleton<IAmAnOutbox>(outbox)
            .AddConsumers(options =>
            {
                options.InboxConfiguration = new InboxConfiguration(inbox);

                options.Subscriptions =
                [
                    // TODO: Auto generate one for each consumer
                    new KafkaSubscription<EmailReceivedModel>(
                        new SubscriptionName("email.topic.sub"),
                        new ChannelName("email"),
                        new RoutingKey("email.topic"),
                        groupId: "email-consumer",
                        makeChannels: OnMissingChannel.Create,
                        messagePumpType: MessagePumpType.Reactor
                    )
                ];
            })
            .AutoFromAssemblies([Assembly.GetExecutingAssembly()])
            .AddProducers(options =>
            {
                options.Outbox = outbox;
                options.ProducerRegistry = kafka;
            })
            .UseOutboxSweeper(options =>
            {
                options.BatchSize = 10;
            })
            .UseOutboxArchiver<DbTransaction>(
                new NullOutboxArchiveProvider(),
                opt => opt.MinimumAge = TimeSpan.FromMinutes(1)
            );

        return services;
    }
}

(Side note: from those examples, I also cannot find the PostgreSqlUnitOfWork classes (which I assume have been removed).

Wondering if I've missed something. Is there a better source for up-to-date examples on how it should work?

[lillo42]

The PostgreSqlUnitOfWork was rename to PostgreSqlTransactionProvider see #3754

[lillo42]

Try to set the ConnectionProvider and TransactionProvider on AddProducers

Just to confirm, are you using Brighter V10 preview 9?

[lillo42]

Are you getting any errors? Try to use the typed publish like new KafkaPublication<MyType> { ... }

[CharlieDigital]

There is one error at startup, but it was also present when the inbox/outbox were not attached

I went back and checked and it turns out that it was sending to Kafka; my mistake was reading the table and still seeing the messages in there after some time, but I can also see the corresponding messages in Kafka; it's actually the other way around: the consumer isn't being set up in Kafka.

Kapture.2025-09-21.at.07.22.24.mp4

• Messages are sent
• Messages appear in outbox
• Messages are forwarded and visible in Kafka
• Consumer is not being created

            .AddConsumers(options =>
            {
                // options.InboxConfiguration = new InboxConfiguration(inbox);

                options.Subscriptions =
                [
                    // TODO: Auto generate one for each consumer
                    new KafkaSubscription<EmailReceivedModel>(
                        new SubscriptionName("email.topic.sub"),
                        new ChannelName("email"),
                        new RoutingKey("email.topic"),
                        groupId: "email-consumer",
                        makeChannels: OnMissingChannel.Create,
                        messagePumpType: MessagePumpType.Reactor
                    )
                ];
            })
            .AutoFromAssemblies([Assembly.GetExecutingAssembly()])

The full (small) codebase is here: https://github.com/CharlieDigital/aspire-wolverine-kafka/tree/brighter/webapi-brighter/Email

It's fully standalone with Aspire + Kafka + Kafka UI + Posgres and will come up with dotnet run --project dn-aspire.AppHost -lp http

[lillo42]

@CharlieDigital After looking to your issue, it's missing the DefaultChannelFactory in AddConsumers and your messagePumpType must be MessagePumpType.Proactor

.AddConsumers(options =>
{
    // options.InboxConfiguration = new InboxConfiguration(inbox);
    options.Subscriptions =
    [
        // TODO: Auto generate one for each consumer
        new KafkaSubscription<EmailReceivedModel>(
            new SubscriptionName("email.topic.sub"),
            new ChannelName("email"),
            new RoutingKey("email.topic"),
            groupId: "email-consumer",
            makeChannels: OnMissingChannel.Create,
            messagePumpType: MessagePumpType.Proactor) // <- Since your handler is async, you should use Proactor
    ];

    // You are missing this one
    options.DefaultChannelFactory = new ChannelFactory(new KafkaMessageConsumerFactory(connection));
})

By the way, your controller isn't the outbox property; you should use Deposit over Post because with Post you are sending right now, with Deposit the Sweep will do it

Another thing, a performance tip, with Kafka, you should use Post over PostAsync, with this you can get over 100x of performance (due to how Kafka client implements produce)

[CharlieDigital]

Appreciate the detailed inputs here!

[CharlieDigital]

Confirming that adding the DefaultChannelFactory and setting to Proactor wired everything up. Appreciate the input on this and will continue to try out some scenarios.

[lillo42]

Off-Topic question, I saw in your repo that you have set up Brighter and Wolverine. How difficult have you found it to set up/use Brighter?

[CharlieDigital]

Haha, well, here are my thoughts:

Wolverine:

• Very easy to set up if you are "within the rails"
• I had a heck of a time getting it to work correctly with Kafka and even when it's working, it was hard to understand the impact of every line in the setup because there are so many variations
• There are a lot of docs, but they are scattered and incomplete so there were not very good docs for setting up inbox+outbox+Kafka
• Some of the docs seem contradictory and there are a lot of "undocumented" configurations. Meaning that some transports support separated handlers, some do not, some support feature X, some do not; it is not well documented and has to be discovered through experimentation.
• Wolverine wasn't designed in the modular monolith era and is more microservices oriented. A side effect, for example, is that the Kafka implementation by default "bundles" handlers so when a message is routed to consuming node, all of the handlers are invoked together. But I also noticed that when this happens, the behavior of the DbContext that I pass in is not transactional (I would have assumed the execution of the two handlers would be bounded by a transaction if I applied the [Transactional] attribute).
• Very good tooling, though. For example, printing out all of the routes at the command line to troubleshoot, I was able to figure out that the Pg transport also does not support separated handlers.
• Use of Discord for collab is a curse in disguise because it's hard to find info and info that gets created doesn't all get documented and indexed in search (hope some future traveler finds these issues useful)

Brighter

• Somewhat harder to initially get started because of the state of docs; couldn't find the classes
• Your earlier blog posts just this year were also out-dated and examples were broken :D so it was very hard to get into it
• Stumbled on your samples repo and that took me pretty far, but once again, some bits were outdated so it was hard to get everything working
• I haven't tested as many scenarios in Brighter so I can't tell for sure how everything behaves (e.g. bundled handlers vs separated handlers? transactional boundary around the DbContext if bundled? etc.). Basically, the docs would be stellar if they documented examples with expected behavior in common messaging patterns
• I do think that the overall setup is cleaner, more structured, and makes more sense to me versus Wolverine
• Some things feel like they could be even more streamlined like the setup of Postgres inbox/outbox if I'm using for all messages. If I'm using Pg for Inbox or Outbox and I am probably going to use it for the other (it wouldn't make much sense to use Pg for Inbox and MSSQL for outbox!). So it might be nice to have like .AddPostgresMailboxes(config => config.Directionality = MailboxDirectionality.Both). Understanding that there's a lot of flexibility built in for fine-grained control as well, but simple/naive scenarios should be simple with a clear pathway to more complex an fine-grained configuration

We are currently going ahead with Wolverine as the Preview releases are still unstable and not clear when the target for stability is, but I think long term, Brighter might be the better option and may revisit and will keep an eye on this project and may yet still swap it out.

A recommendation is to look at what the Semantic Kernel team does with their docs. When it first shipped, it was in a very, very unstable state and the only way any of it was usable was to look at their samples in the docs like this sub folder: https://github.com/microsoft/semantic-kernel/blob/main/dotnet/samples/Concepts/Memory/VectorStore_VectorSearch_Simple.cs

Because the samples were:

1. Complete and encapsulated
2. Well documented
3. Well organized
4. Part of source (thus would break on breaking changes)

It was possible to understand what worked and what didn't. The unit tests in Wolverine are a bit too dense to understand and use this way to my chagrin as I had to pull the source and really read through some of it to figure out what I was doing wrong.