MessageNotConsumedException on long running mediator request

[vyruz1986]

Following a short discussion on SO, I'm creating a discussion here as requested.

The issue I want to clarify and resolve, is as follows: It seems that long running operations inside a consumer, triggered by a Mediator request, will throw a MessageNotConsumedException if the operation takes >= 30s.
If I wire up the same consumer via IBus, the exception is not thrown.
I also tried explicitly configuring the consumer with a timeout of 40s, but it changes nothing.

I have the following code, which can be pasted into the Program.cs of a .NET 6 dotnet new console generated application:

using Consumers;
using MassTransit;
using MassTransit.Mediator;
using Microsoft.Extensions.DependencyInjection;

var services = new ServiceCollection();

services.AddMediator(cfg =>
{
    // Even explicitly configuring a timeout of 40s (longer than the 35s delay in the consumer) does not fix the problem
    cfg.AddConsumer<OrderStatusConsumer>(o => o.UseTimeout(t => t.Timeout = TimeSpan.FromSeconds(40)));
});

var provider = services.BuildServiceProvider();

var mediator = provider.GetRequiredService<IMediator>();

Guid orderId = NewId.NextGuid();

var client = mediator.CreateRequestClient<GetOrderStatus>();

var response = await client.GetResponse<OrderStatus>(new(orderId));

Console.WriteLine("Order Status: {0}", response.Message.Status);

namespace Consumers
{
    public record GetOrderStatus(Guid OrderId);

    public record OrderStatus(Guid OrderId, string Status);

    class OrderStatusConsumer : IConsumer<GetOrderStatus>
    {
        public async Task Consume(ConsumeContext<GetOrderStatus> context)
        {
            await Task.Delay(30000); // Removing this makes the application work fine. Setting it 29000 or lower also works fine

            await context.RespondAsync<OrderStatus>(new(context.Message.OrderId, "Pending"));
        }
    }
}

[phatboyg]

If you are using the request client (which has a default timeout of 30 seconds) and you need a longer timeout, you should increase the request timeout either when creating it or when calling GetResponse.

[vyruz1986]

Thanks, this clarifies why this is happening!

It would be nice if you could elaborate on the decision to use a different timeout than the one defined in the AddConsumer<T>(o => o.UseTimeout()) call when using Mediator.CreateRequestClient<T>().GetResponse<T>() vs Mediator.CreateRequest<T>().GetResponse<T>()

[phatboyg]

UseTimeout is a middleware filter on the consume pipeline that simply adds a timeout after which the CancellationToken on ConsumeContext will be canceled. That's it, all it does. It is entirely configured on the consume side of MassTransit.

The request client timeout is a producer-side component that sends requests and waits for responses. It has its own timeout, which is configured or specified by the producer.

There is zero coupling between the producer and the consumer side as far as configuration is concerned. So the answer as to why they are "different" is because they are two completely different things.

[vyruz1986]

Crystal clear, thanks!