Use a behavior to identify how a message is sent

,
1

Hey,

I’m wondering whether there is a simple way to determine if a message is sent without any transactional guarantees (via IMessageSession) or within an NServiceBus-controlled transaction (via IMessageHandlerContext or ITransactionalSession) when using the outbox feature?

Our idea was to add a behavior that issues a warning when a message is not routed via the outbox feature. For this, we tried retrieving the IOutboxTransaction from the behavior’s message context, but it seems like we cannot fully rely on it when sending messages outside a message handler context.
As an alternative, checking the underlying ISqlStorageSession for an open connection and transaction is also not possible as the outgoing behavior’s context exposes only the root builder when running outside a message handler. Are there any other options we could look into?

Maybe some context what we are trying to achieve: In a larger code base with multiple endpoints (some with, some without outbox enabled) it would be somewhat nice to notice a (newly introduced) usage of IMessageSession when it shouldn’t be used as either ITransactionalSession or IMessageHandlerContext would be around.

2

It sounds like what you’re trying to achieve is prevention of IMessageSession usage. But a received message doesn’t know, and arguably shouldn’t know, how it was sent. It’s too late at that point. Instead, I would focus on the detection and prevention of using IMessageSession before any message is sent at all with a Roslyn analyzer if your entire codebase is utilizing the outbox feature, . The benefit of this approach would be not just preventing the use of an API that’s discouraged but would also yield a meaningful error with an instruction for developers to lean on, or an automated fix for the error.

1 Like
3

So there is also no way to detect it on the sending side? I was especially looking for an outgoing message behavior.

4

There isn’t a deterministic, consistent way in the pipeline to detect that. The issue is that there is no way to distinguish between a dispatch operation using the IMessageSession and one done using the context inside a message handler and an immediate dispatch send option.

You could try to use more than one behavior to detect if you are in the context of an incoming message. I’m doing something similar in my DispatchRetries extension, but that’s for a different purpose and I’m not sure there is a way to achieve what you want.

I think a Roslyn analyzer would be a better approach for your use case.