Bdtjtk

I have the following policies:

var sharedBulkhead = Policy.BulkheadAsync(

            maxParallelization: maxParallelizations, 

            maxQueuingActions: maxQueuingActions,

            onBulkheadRejectedAsync: (context) =>

            {

                Log.Info($"Bulk head rejected => Policy Wrap: {context.PolicyWrapKey}, Policy: {context.PolicyKey}, Endpoint: {context.OperationKey}");

                return TaskHelper.EmptyTask;

            }

        );



var retryPolicy = Policy.Handle<HttpRequestException>()

.Or<BrokenCircuitException>().WaitAndRetryAsync(

            retryCount: maxRetryCount,

            sleepDurationProvider: attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)),

            onRetryAsync: (exception, calculatedWaitDuration, retryCount, context) =>

            {

                Log.Error($"Retry => Count: {retryCount}, Wait duration: {calculatedWaitDuration}, Policy Wrap: {context.PolicyWrapKey}, Policy: {context.PolicyKey}, Endpoint: {context.OperationKey}, Exception: {exception}.");

                return TaskHelper.EmptyTask;

            });



            var circuitBreaker = Policy.Handle<Exception>(e => (e is HttpRequestException)).CircuitBreakerAsync(

            exceptionsAllowedBeforeBreaking: maxExceptionsBeforeBreaking, 

            durationOfBreak: TimeSpan.FromSeconds(circuitBreakDurationSeconds), 

            onBreak: (exception, timespan, context) =>

            {

                Log.Error($"Circuit broken => Policy Wrap: {context.PolicyWrapKey}, Policy: {context.PolicyKey}, Endpoint: {context.OperationKey}, Exception: {exception}");

            },

            onReset: (context) =>

            {

                Log.Info($"Circuit reset => Policy Wrap: {context.PolicyWrapKey}, Policy: {context.PolicyKey}, Endpoint: {context.OperationKey}");

            }

        );



var fallbackForCircuitBreaker = Policy<bool>

         .Handle<BrokenCircuitException>()

         .FallbackAsync(

             fallbackValue: false,

             onFallbackAsync: (b, context) =>

             {

                 Log.Error($"Operation attempted on broken circuit => Policy Wrap: {context.PolicyWrapKey}, Policy: {context.PolicyKey}, Endpoint: {context.OperationKey}");

                 return TaskHelper.EmptyTask;

             }

         );



var fallbackForAnyException = Policy<bool>

            .Handle<Exception>()

            .FallbackAsync(

                fallbackAction: (ct, context) => { return Task.FromResult(false); },

                onFallbackAsync: (e, context) =>

                {

                    Log.Error($"An unexpected error occured => Policy Wrap: {context.PolicyWrapKey}, Policy: {context.PolicyKey}, Endpoint: {context.OperationKey}");

                    return TaskHelper.EmptyTask;

                }

            );





var resilienceStrategy = Policy.WrapAsync(retryPolicy, circuitBreaker, sharedBulkhead);

        var policyWrap = fallbackForAnyException.WrapAsync(fallbackForCircuitBreaker.WrapAsync(resilienceStrategy));

Now, fallbackForCircuitBreaker is only invoked if all retries fail, and if the last retry fails with BrokenCircuitException. What changes should be made in order for fallbackForCircuitBreaker to be invoked every time a retry is made on a broken circuit?

Also, I am using a sharedBulkHead which is an instance field in the service and is initialized in the constructor. Is that a good practise? What is to be done ideally on onBulkheadRejectedAsync? Can I modify the retry policy to handle bulk head rejection as well?