Building a Generic Resilience Pipeline with Polly v8 and RestSharp

In the world of API calls, resilience is key. You never know when a service might be down, or a network issues might arise. That’s where Polly v8 and RestSharp come in – two powerful libraries that can help you build a robust and reliable pipeline for making HTTP requests. In this article, we’ll explore how to create a generic resilience pipeline that accounts for response header retry-after, exceptions, and logging using Polly v8 and RestSharp.

What is Polly v8?

Polly v8 is a .NET resilience and transient-fault-handling library that allows you to express policies such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback in a fluent and thread-safe manner. It’s a popular choice among .NET developers for building resilient applications.

What is RestSharp?

RestSharp is a popular .NET library for making HTTP requests. It provides a simple and intuitive API for sending HTTP requests and parsing responses. With RestSharp, you can make GET, POST, PUT, DELETE, and other types of requests with ease.

Building the Resilience Pipeline

To build a generic resilience pipeline using Polly v8 and RestSharp, we’ll create a custom class called `ResilientHttpClient`. This class will wrap the `RestSharp.RestClient` class and provide a layer of resilience on top of it.

using Polly;
using RestSharp;

public class ResilientHttpClient
{
    private readonly RestClient _client;
    private readonly AsyncPolicy<HttpResponse> _policy;

    public ResilientHttpClient(string baseUrl, int retryCount, int timeoutInSeconds)
    {
        _client = new RestClient(baseUrl);
        _policy = Policy.Handle<Exception>()
            .WaitAndRetryAsync(retryCount, retryAttempt => TimeSpan.FromSeconds(retryAttempt));
    }

    public async Task<HttpResponse> ExecuteAsync(Func<RestRequest> requestFactory)
    {
        return await _policy.ExecuteAsync(ct => _client.ExecuteAsync(requestFactory()));
    }
}

In the above code, we’re creating an instance of the `ResilientHttpClient` class, which takes in the base URL, retry count, and timeout in seconds as parameters. We’re also defining a policy that will handle exceptions and retry the request up to the specified retry count.

Handling Response Header Retry-After

In some cases, the API you’re calling might return a response header with a retry-after value, indicating that the request should be retried after a certain amount of time. To handle this, we can modify our policy to take into account the retry-after header.

_policy = Policy.Handle<Exception>()
    .OrResult<HttpResponse>(r => r.StatusCode == HttpStatusCode.TooManyRequests)
    .WaitAndRetryAsync(retryCount, (exception, retryCount) =>
    {
        var retryAfterHeaderValue = exception as HttpResponseException?
            .Response
            .Headers
            .Get("Retry-After")
            .FirstOrDefault();

        if (retryAfterHeaderValue != null)
        {
            var retryAfter = int.Parse(retryAfterHeaderValue.Value);
            return TimeSpan.FromSeconds(retryAfter);
        }

        return TimeSpan.FromSeconds(retryCount);
    });

In the above code, we’re modifying our policy to handle the `HttpResponseException` and extract the retry-after header value. If the header is present, we’ll use its value to determine the retry delay.

Handling Exceptions

In addition to handling the retry-after header, we should also handle exceptions that might occur during the request. We can do this by adding a `.Catch` block to our policy.

_policy = Policy.Handle<Exception>()
    .OrResult<HttpResponse>(r => r.StatusCode == HttpStatusCode.TooManyRequests)
    .WaitAndRetryAsync(retryCount, (exception, retryCount) =>
    {
        // ...
    })
    .Catch<Exception>(exception =>
    {
        // Log the exception
        Console.WriteLine($"Error occurred: {exception.Message}");
        throw;
    });

In the above code, we’re adding a `.Catch` block that will catch any exceptions that occur during the request. We’re logging the exception and then re-throwing it.

Logging

Logging is an essential part of any resilient pipeline. We want to log not only exceptions but also successful requests. We can do this by adding a `.OnFallback` block to our policy.

_policy = Policy.Handle<Exception>()
    .OrResult<HttpResponse>(r => r.StatusCode == HttpStatusCode.TooManyRequests)
    .WaitAndRetryAsync(retryCount, (exception, retryCount) =>
    {
        // ...
    })
    .Catch<Exception>(exception =>
    {
        // Log the exception
        Console.WriteLine($"Error occurred: {exception.Message}");
        throw;
    })
    .OnFallback((response, context) =>
    {
        // Log the successful response
        Console.WriteLine($"Request successful: {response.StatusCode}");
    });

In the above code, we’re adding an `.OnFallback` block that will log the successful response.

Using the ResilientHttpClient

Now that we have our `ResilientHttpClient` class, let’s see how to use it to make a request.

var client = new ResilientHttpClient("https://api.example.com", 3, 10);

var request = new RestRequest("users", Method.GET);

var response = await client.ExecuteAsync(() => request);

if (response.IsSuccessful)
{
    Console.WriteLine($"Response: {response.Content}");
}
else
{
    Console.WriteLine($"Error: {response.StatusDescription}");
}

In the above code, we’re creating an instance of the `ResilientHttpClient` class and making a GET request to the API. We’re then checking if the response was successful and logging the response content or error message accordingly.

Conclusion

In this article, we’ve seen how to build a generic resilience pipeline using Polly v8 and RestSharp. We’ve covered how to handle response header retry-after, exceptions, and logging. By using this pipeline, you can ensure that your application is resilient to API failures and retries requests accordingly.

Remember to adjust the retry count, timeout, and logging settings according to your application’s needs. Happy coding!

Retry Count	Timeout (seconds)	Description
3	10	Default settings for a basic resilience pipeline
5	30	More aggressive retry policy for critical requests
1	5	Less aggressive retry policy for non-critical requests

In the above table, we’ve provided some examples of retry count and timeout settings for different scenarios. You can adjust these settings based on your application’s requirements.

Frequently Asked Questions

Get the lowdown on building a Generic ResiliencePipeline with Polly v8 and RestSharp to handle response headers, exceptions, and logging like a pro!