How do I add middleware to the Rebus message processing pipeline, before and after sending a message, and before and after handling a message? - rebus

Question

I need this to simplify the implementation of the following typical, routine operations:
I would like to capture the user's context before sending the message and restores the user context before the message is handling, similar to how it was done in the following legacy example: https://github.com/rebus-org/RebusSamples/tree/master/old/UserContextHeaders
I would like to validate and deduplicating messages before handling them and log results after the message is handling.

Answer 1

As the question author correctly figured out, the Rebus.Events package provides readable and accessible ways of hooking into before/after messages are sent/received.
If that is sufficient, I would definitely go with that.
However, if e.g. you want to WRAP the entire processing of a single message inside a try/finally (which I recommend you when you restore the sending user's identity to process a message), you probably want to look at the native extension mechanism, which is based on decorators.
You can read the wiki page about extensibility about how to extend Rebus by decorating its pipelines.
For example, to do something with the current claims principal before and after handling a message, you can implement an "incoming pipeline step" like this:
[StepDocumentation("Write a nice descriptoion here")]
class MyIncomingStep : IIncomingStep
{
public async Task Process(IncomingStepContext context, Func<Task> next)
{
var originalPrincipal = ClaimsPrincipal.Current;
try
{
// establish user identity here
ClaimsPrincipal.Current = ...
// handle message
await next();
}
finally
{
ClaimsPrincipal.Current = originalPrincipal;
}
}
}
and then you can decorate Rebus' IPipeline with a "step injector", declaratively stating where in the pipeline you want the step to be inserted:
.Options(o => {
o.Decorate<IPipeline>(c =>
{
var pipeline = c.Get<IPipeline>();
var stepToInject = new MyIncomingStep();
return new PipelineStepInjector(pipeline)
.OnReceive(stepToInject, PipelineRelativePosition.Before, typeof(DispatchIncomingMessageStep));
});
})
and then – to makes things pretty – you can wrap the code above inside an extension method for OptionsConfigurer, making for a much prettier configuration syntax:
.Options(o => {
o.RestoreClaimsPrincipalWhenHandlingMessages();
})
or whatever you think it should be called :)
Everything works in an analogous fashion when sending messages, you just want to
//....
return new PipelineStepInjector(pipeline)
.OnSend(stepToInject, PipelineRelativePosition.Before, typeof(SerializeOutgoingMessageStep));
instead.