enRose

async Task<HttpResponseMessage> callAPI()
{
    Logger.LogThreadInfo($"Calling API for message " +
        $"{consumeResult.Message.Key}");

    var json = new StringContent(
            consumeResult.Message.Value, Encoding.UTF8,
            "application/json");

    var client = _httpClientFactory.CreateClient();

enRose

public class Worker : BackgroundService
{
    public IServiceProvider Services { get; }

    private readonly ILogger<Worker> _logger;

    public Worker(
        IServiceProvider services,
        ILogger<Worker> logger)
    {

enRose

/* Custody of Microsoft - DO NOT USE */

//ConfigureServices()  - Startup.cs
services.AddHttpClient<IBasketService, BasketService>()
 //Set lifetime to five minutes
 .SetHandlerLifetime(TimeSpan.FromMinutes(5))  
 .AddPolicyHandler(GetRetryPolicy());

// 2 ^ 1 = 2 seconds then
// 2 ^ 2 = 4 seconds then

enRose

public void Produce<T>(
    string msgKey, T msgVal, string topic = "retry-transient-error")
{
    Logger.LogThreadInfo("Produce() method");

    using var producer = new ProducerBuilder<string, string>(config).Build();

    var val = JsonConvert.SerializeObject(msgVal);

    Logger.LogInfo($"Producing record: {val}");

enRose

// API Controller
[HttpPost]
public async Task<bool> AgreeToRetry(
  [FromBody] IEnumerable<GitHubBranch> gitHubBranches)
{
    Logger.LogThreadInfo("Controller AgreeToRetry()");

    return await yoyo.AgreeToRetry(gitHubBranches);
}

enRose

var delay = Backoff.DecorrelatedJitterBackoffV2(
    medianFirstRetryDelay: TimeSpan.FromSeconds(1),
    retryCount: 5);

var retry = Policy
    .HandleResult<HttpResponseMessage>(r =>
        r.StatusCode == HttpStatusCode.InternalServerError)
    .WaitAndRetryAsync(
        delay,
        (exception, timeSpan, retryCount, context) =>

enRose

public async Task<IList<RuleResult>> ParallelAll(
    List<Func<T, Task<RuleResult>>> parallelAsyncRules, T ruleCtx)
{
    if (parallelAsyncRules?.Count < 1)
    {
        return null;
    }

    var tasks = parallelAsyncRules.Select(r => r(ruleCtx));

enRose

public async Task<RuleResult> FirstFails(
    IList<Func<T, Task<RuleResult>>> sequentialAsyncRules, T ruleCtx)
{
    if (sequentialAsyncRules?.Count < 1)
    {
        return null;
    }

    RuleResult firstFailed = null;

enRose

public IEnumerable<RuleResult> All(
    IList<Func<T, RuleResult>> sequentialRules, T ruleCtx)
    => sequentialRules?.Select(r => r(ruleCtx));

enRose

public TSideEffect Pick<TSideEffect>() where TSideEffect: class
{
    if (SideEffect.Count == 0) 
    {
        return null;
    }

    if (SideEffect.TryGetValue(typeof(TSideEffect), out object value))
    {
        return (TSideEffect)value;