调整代码以使用内置比率策略

Question

我想实现与下面的策略相同的行为，并以内置的比塔级策略，即记录器消息并读取重试标头并等待需要等待但使用内置比率策略的确切秒数。

尝试

// TODO: No logger message and not sure if it waits the time taken from the Retry-After header.
public static AsyncRateLimitPolicy Limit<T>(ILogger<T> logger)
{
    return Policy.RateLimitAsync(RateLimitRetryCount, TimeSpan.FromSeconds(5));
}

工作

public static AsyncRetryPolicy<RestResponse> AsyncRateLimit<T>(ILogger<T> logger)
{
    return Policy.HandleResult<RestResponse>(response => response.StatusCode == HttpStatusCode.TooManyRequests)
        .WaitAndRetryAsync(RateLimitRetryCount,
            (attemptCount, restResponse, _) =>
            {
                var retryAfterHeader = restResponse?.Result?.Headers?.SingleOrDefault(h => h.Name == "Retry-After");
                double secondsInterval = 0;

                if (retryAfterHeader != null)
                {
                    var value = retryAfterHeader.Value?.ToString();
                    if (!double.TryParse(value, out secondsInterval))
                    {
                        secondsInterval = Math.Pow(2, attemptCount);
                    }
                }

                return TimeSpan.FromSeconds(secondsInterval);
            },
            (response, timeSpan, retryCount, _) =>
            {
                logger.LogTrace(
                    "The API request has been rate limited. HttpStatusCode={StatusCode}. Waiting {Seconds} seconds before retry. Number attempt {RetryCount}. Uri={Url}; RequestResponse={Content}",
                    response.Result.StatusCode, timeSpan.TotalSeconds, retryCount, response.Result.ResponseUri, response.Result.Content);

                return Task.CompletedTask;
            });
}

Answer 1

有多个问题，所以让我回答所有问题。

1）如何将记录仪注入策略？

您需要使用 polly的上下文。

上下文是在策略之外创建的。它被用作存储任何任意信息的容器

var context = new Context().WithLogger(logger);

，然后通过execute/executeasync调用

await policy.ExecuteAsync(ctx => FooAsync(), context);

最终您可以在任何用户委托中使用上下文（例如> >） onretry/onretryAsync）要检索传递的对象

(exception, timeSpan, retryCount, context) =>
{
  var logger = context.GetLogger();
  logger?.LogWarning(...);
  ...
}

withlogger and getlogger扩展方法

public static class ContextExtensions
{
    private static readonly string LoggerKey = "LoggerKey";

    public static Context WithLogger(this Context context, ILogger logger)
    {
        context[LoggerKey] = logger;
        return context;
    }

    public static ILogger GetLogger(this Context context)
    {
        if (context.TryGetValue(LoggerKey, out object logger))
        {
            return logger as ILogger;
        }
        return null;
    }
}

2）在上述费率限制器工作中与重试的方式相同吗？

否。费率限制器是A 主动策略，可用于防止资源滥用。这意味着如果超过预定义的限制，它将抛出ratelimitRejectedException。

每当我们谈论弹性策略时，我们都会提到双方之间的预定义协议，以克服瞬态失败。因此，速率限制器是此故事的服务器端，而重试（反应性策略）是客户端。

如果要在速率限制器中设置retryafter标题，那么您可以这样做，

IAsyncPolicy<HttpResponseMessage> limit = Policy
    .RateLimitAsync(RateLimitRetryCount, TimeSpan.FromSeconds(5), RateLimitRetryCount,
        (retryAfter, context) => {
            var response = new HttpResponseMessage(System.Net.HttpStatusCode.TooManyRequests);
            response.Headers.Add("Retry-After", retryAfter.TotalSeconds.ToString());
            return response;
        });

然后在重试的sleepdurationProvider委派中的客户端上，您可以像如果响应是delegateresult＆lt; httpresponsemessage＆gt;

response.Result.Headers.RetryAfter.Delta ?? TimeSpan.FromSeconds(0)