Logging in OnRetry

[mickvikt]

Hello,
What is the idiomatic way of passing an ILogger to the OnRetry delegate? Samples conveniently show using Console.WriteLine, which is, of course, not feasible in production.

Thank you

[peter-csala]

Well, it depends. Are you the one who is calling the Execute{Async} or is it called on your behalf? In the former case are the pipeline declaration and execution at the same place? ...

If you can provide an example how do you plan to define and use the retry strategy then I can provide some suggestions.

[mickvikt]

I'm defining the pipeline like this:

    private readonly ResiliencePipeline resiliencePipeline =
        new ResiliencePipelineBuilder()
            .AddRetry(new RetryStrategyOptions
            {
                MaxRetryAttempts = MaxRetryCount,
                Delay = TimeSpan.FromMinutes(DelayIntervalInMinutes),
                OnRetry = retryArguments =>
                {
                    if(retryArguments.Context.Properties.TryGetValue(ResilienceContextKeys.Inputs, out var inputs))
                    {
                        var exception = retryArguments.Outcome.Exception;
                        var attemptNumber = retryArguments.AttemptNumber;
                        var statusIds = string.Join(", ", inputs.Select(d => d.Id));
                       //logger.LogError("Exception returned: {Exception} when processing new Status ids {StatusIds}. Attempt {RetryCount} out of {MaxRetryCount}", exception!.Message, statusIds, attemptNumber + 1, MaxRetryCount + 1);
                    }

                    return ValueTask.CompletedTask;
                },
            })
            .Build();

And starting the execution like this:

        var resilienceContext = ResilienceContextPool.Shared.Get(functionContext.CancellationToken);
        resilienceContext.Properties.Set(ResilienceContextKeys.Inputs, inputs);

        await this.resiliencePipeline.ExecuteAsync(
            async token =>
            {
                await this.ProcessStatuses(inputs, functionContext.InvocationId);
            },
            functionContext.CancellationToken);

        ResilienceContextPool.Shared.Return(resilienceContext);

By the way, I'm not really sure whether it is better to use the ResilienceContext for passing parameter to ExecuteAsync or just use a closure.

[peter-csala]

In this particular scenario, you can use the following two options:

• Access directly an ILogger inside the OnRetry delegate
• Use the context to "attach" an ILogger to the strategy execution

Option 1

Your current code declares the resiliencePipeline as readonly and defines its value at the same time. If you could define its value inside a constructor then you can refer the ILogger without the need to use closure:

class XYZ
{
   private readonly ILogger<XYZ> logger;
   private readonly ResiliencePipeline resiliencePipeline;
   
   public XYZ(ILogger<XYZ> logger)
   {
      this.logger = logger;
      this.resiliencePipeline = new ResiliencePipelineBuilder()
        .AddRetry(new RetryStrategyOptions
        {
            ...
            OnRetry = args =>
            {
                ...
                this.logger....

                return default;
            },
        })
        .Build();
   }

   ...
}

Option 2

You can pass the logger to the strategy execution in the exact same way as you did with the inputs:

resilienceContext.Properties.Set(ResilienceContextKeys.Logger, logger);
...

if(args.Context.Properties.TryGetValue(ResilienceContextKeys.Logger, out var logger))

Side notes

• If you are in doubt whether you should use state or context to pass some information then check this section of the documentation:

As a rule of thumb:

• Use the state object to pass a parameter to your decorated method;
• Use the context object to exchange information between delegates of an instance of XYZOptions or between invocation attempts (in the case of retry or hedging strategies).

• If you would register your resilience pipeline into your DI container then there are AddResiliencePipeline's overloads which allow you to access the IServiceProvider:

services.AddResiliencePipeline("my-key", (builder, context) =>
{
    var loggerFactory = context.ServiceProvider.GetRequiredService<ILoggerFactory>();

    builder.AddRetry(...);
});

[mickvikt]

Thanks, @peter-csala, I'll probably try Option 1 or just use the DI.
Just one last question: when you talk about context vs state and you mention the decorated method, do you mean the method passed to ExecuteAsync when you say 'decorated method'?

[peter-csala]

Yes, exactly. We refer to the Execute{Async}'s callback parameter as either decorated method or user provided callback. in the documentation. On the diagrams (like these) we used the DecoratedUserCallback term.