How to access DI services declared as Scoped within AddResiliencePipeline

[sroofakuvo]

Hello everyone.
In the doc Dependency injection, it is noted that you can access context from within AddResiliencePipeline like so

// You can also access IServiceProvider by using the alternate overload
services.AddResiliencePipeline("my-key", (builder, context) =>
{
    // Resolve any service from DI
    var loggerFactory = context.ServiceProvider.GetRequiredService<ILoggerFactory>();

    // Add strategies to your pipeline here
    builder.AddTimeout(TimeSpan.FromSeconds(10));
});

In the project in which I'm working, a specific logger instance is configured and registered as a scoped service. I need access to that instance from within the ResiliencePipeline, so that I can log retries. But when the time comes to execute the pipeline, the context passed in to the builder doesn't seem to have the same scope as the executing scope, because when I GetRequiredService for my logger, it's not the correct instance.

Do you have any guidance on how I can get the correct, scoped instance of my logger? Thank you for your time and consideration.

My service collection extension:

        public static IServiceCollection AddMyRetry(this IServiceCollection services)
        {
            services.AddResiliencePipeline<string, RestResponse?>(MY_RETRY, (builder, context) =>
            {
                ITracerService tracerService = context.ServiceProvider.GetRequiredService<ITracerService>();

                builder.AddRetry(new()
                {
                    ShouldHandle = new PredicateBuilder<RestResponse?>()
                        .Handle<InvalidOperationException>()
                        .HandleResult(response => response?.StatusCode == 0),
                    MaxRetryAttempts = 3,
                    BackoffType = DelayBackoffType.Exponential,
                    OnRetry = args =>
                    {
                        string message = $"""
                                        Retrying request.
                                        AttemptNumber: {args.AttemptNumber}
                                        Duration: {args.Duration}
                                        RetryDelay: {args.RetryDelay}
                                        HTTPStatusCode: {args.Outcome.Result?.StatusCode}
                                        Exception: {args.Outcome.Exception?.Message}
                                        """;

                        tracerService.TraceAndSaveImmediate(message);
                        return default;
                    }
                });
            });
            return services;
        }

and during execution (note that the logger instance is correct here)

_resiliencePipeline = pipelineProvider.GetPipeline<RestResponse?>(ServiceCollectionExtensions.MY_RETRY);
...etc
RestResponse rawResponse = await _resiliencePipeline.ExecuteAsync(async token => await restClient.ExecutePostAsync(request, token), CancellationToken.None);

[peter-csala]

Could you please share with us how the logger is registered?

BTW you can create a new scope anytime via the IServiceProvider:

using var scope = context.ServiceProvider.CreateScope();
var logger = scope.ServiceProvider.GetRequiredService<ILogger>();

[sroofakuvo]

@peter-csala Thanks for your response. Creating a scope via the IServiceProvider will not help me in this case, because I want to access the same scope in which my logger is set up already, not create a new scope with a new logger.

Here is how the logger is registered. The logger is an ITracerService.
This is an Azure function app. Program.cs calls its various Service Collection Extensions, one of which registers the ITracerService as Scoped.

    public static class ServiceCollectionExtensions
    {
        public static IServiceCollection AddConnectorFramework(this IServiceCollection services)
        {
            ...etc
            services.AddScoped(typeof(ITracerService), typeof(TracerService));
            ...etc
            return services;
        }
    }

Then there is middleware that runs and sets up an instance of TracerService in this particular Scope. The most important thing is that this middleware sets the TraceId, ConnectorCode, and ConnectorFunctionCode on the tracer in this scope.

Adding of the middleware (Program.cs):

IHost host = new HostBuilder()
    .ConfigureFunctionsWebApplication(workerApplication =>
    {
        workerApplication.UseMiddleware<ClientMiddleware>();
        workerApplication.UseMiddleware<TracingMiddleware>();  //<-----------------
    })
    .ConfigureServices(services =>
    {
    ...etc

Middleware itself:

namespace ConnectorRequest.Middleware
{
    public class TracingMiddleware : IFunctionsWorkerMiddleware
    {
        public async Task Invoke(FunctionContext context, FunctionExecutionDelegate next)
        {
            try
            {
                ExecuteLogic(context);
            }
            catch { }
            await next(context);
        }

        public static void ExecuteLogic(FunctionContext context)
        {
            ITracerService tracerService = context.InstanceServices.GetRequiredService<ITracerService>();

            // trace id
            if (context.BindingContext.BindingData.TryGetValue("TraceId", out object? traceId))
            {
                if (traceId is string traceIdStr)
                {
                    if (!string.IsNullOrEmpty(traceIdStr))
                    {
                        tracerService.SetTraceId(traceIdStr);
                    }
                }
            }

            // connector code
            if (context.BindingContext.BindingData.TryGetValue("ConnectorCode", out object? connectorCode))
            {
                if (connectorCode is string connectorCodeStr)
                {
                    if (!string.IsNullOrEmpty(connectorCodeStr))
                    {
                        tracerService.SetConnectorCode(connectorCodeStr);
                    }
                }
            }

            // connector function code
            if (context.BindingContext.BindingData.TryGetValue("ConnectorFunctionCode", out object? connectorFunctionCode))
            {
                if (connectorFunctionCode is string connectorFunctionCodeStr)
                {
                    if (!string.IsNullOrEmpty(connectorFunctionCodeStr))
                    {
                        tracerService.SetConnectorFunctionCode(connectorFunctionCodeStr);
                    }
                }
            }

            string invocationTypeCode = "HTTP";
            string? queueMessageId = null;
            int queueDequeueCount = int.MinValue;
            DateTime queueInsertionTime = DateTime.MinValue;

            if (context.IsQueueTrigger())
            {
                invocationTypeCode = "QUEUE";
                queueMessageId = context.GetBindingData("Id");
                int.TryParse(context.GetBindingData("DequeueCount"), out queueDequeueCount);
                string? dateValue = context.GetBindingData("InsertionTime");
                if (dateValue != null)
                {
                    DateTime.TryParse(dateValue.Replace("\"", ""), out queueInsertionTime);
                }
            }

            FunctionContextInfo functionContextInfo = new(
                invocationTypeCode,
                context.InvocationId,
                context.FunctionDefinition.Name,
                queueDequeueCount == int.MinValue ? null : queueDequeueCount,
                queueInsertionTime == DateTime.MinValue ? null : queueInsertionTime,
                queueMessageId);

            tracerService.SetFunctionContextInfo(functionContextInfo);
        }
    }
}

So when my onRetry runs when the Polly Pipeline is triggered later in this same request execution, the execution of onRetry needs to be in the same Scope as the rest of the execution, so that I can access this particular ITracerService which was set up by the middleware. When I walk the debugger into onRetry, the ServiceProvider has IsScope=false and IsRootScope=true

[peter-csala]

Thanks for sharing all these details.

Have you considered the usage of keyed services?

services.AddKeyedScoped<ITracerService>("trace_service", (sp, key) => new TracerService());
...
context.ServiceProvider.GetKeyedService<ITracerService>("trace_service");

I'm not sure whether it solves the scope problem, but it is worth giving a try IMHO.