Apizr

Refit based web api client management, but resilient (retry, connectivity, cache, auth, log, priority, etc...)

What

The Apizr project was motivated by this 2015 famous blog post about resilient networking.

Its main focus was to address at least everything explained into this article, meanning:

• Easy access to restful services
• Work offline with cache management
• Handle errors with retry pattern and global catching
• Handle request priority
• Check connectivity
• Fast development time
• Easy maintenance
• Reuse existing libraries

But also, some more core features like:

• Trace http traffic
• Handle authentication

And more integration/extension independent optional features like:

• Choose cache, log and connectivity providers
• Register it as an MS DI extension
• Map model with DTO
• Use Mediator pattern
• Manage file transfers

The list is not exhaustive, there’s more, but what we wanted was playing with all of it with as less code as we could, not worrying about plumbing things and being sure everything is wired and handled by design or almost.

Inspired by Refit.Insane.PowerPack, we wanted to make it simple to use, mixing attribute decorations and fluent configuration.

How

An api definition with some attributes:

// (Polly) Define a resilience pipeline key
// OR use Microsoft Resilience instead
[assembly:ResiliencePipeline("TransientHttpError")]
namespace Apizr.Sample
{
    // (Apizr) Define your web api base url and ask for cache and logs
    [BaseAddress("https://reqres.in/"), 
    Cache(CacheMode.FetchOrGet, "01:00:00"), 
    Log(HttpMessageParts.AllButBodies)]
    public interface IReqResService
    {
        // (Refit) Define your web api interface methods
        [Get("/api/users")]
        Task<UserList> GetUsersAsync([RequestOptions] IApizrRequestOptions options);

        [Get("/api/users/{userId}")]
        Task<UserDetails> GetUserAsync([CacheKey] int userId, [RequestOptions] IApizrRequestOptions options);

        [Post("/api/users")]
        Task<User> CreateUser(User user, [RequestOptions] IApizrRequestOptions options);
    }
}

Some resilience strategies:

// (Polly) Create a resilience pipeline (if not using Microsoft Resilience)
var resiliencePipelineBuilder = new ResiliencePipelineBuilder<HttpResponseMessage>()
    .AddRetry(
        new RetryStrategyOptions<HttpResponseMessage>
        {
            ShouldHandle = new PredicateBuilder<HttpResponseMessage>()
                .Handle<HttpRequestException>()
                .HandleResult(response =>
                    response.StatusCode is >= HttpStatusCode.InternalServerError
                        or HttpStatusCode.RequestTimeout),
            Delay = TimeSpan.FromSeconds(1),
            MaxRetryAttempts = 3,
            UseJitter = true,
            BackoffType = DelayBackoffType.Exponential
        });

An instance of this managed api:

Extended

Relies on IServiceCollection extension methods approach.

// (Logger) Configure logging the way you want, like
services.AddLogging(loggingBuilder => loggingBuilder.AddDebug());

// (Apizr) Add an Apizr manager for the defined api to your container
services.AddApizrManagerFor<IReqResService>(
    options => options
        // With a cache handler
        .WithAkavacheCacheHandler()
        // If using Microsoft Resilience
        .ConfigureHttpClientBuilder(builder => builder
            .AddStandardResilienceHandler()));

// (Polly) Add the resilience pipeline (if not using Microsoft Resilience)
services.AddResiliencePipeline<string, HttpResponseMessage>("TransientHttpError",
    builder => builder.AddPipeline(resiliencePipelineBuilder.Build()));
...

// (Apizr) Get your manager instance the way you want, like
var reqResManager = serviceProvider.GetRequiredService<IApizrManager<IReqResService>>();

Static

Relies on static builder instantiation approach.

// (Polly) Add the resilience pipeline with its key to a registry
var resiliencePipelineRegistry = new ResiliencePipelineRegistry<string>();
resiliencePipelineRegistry.TryAddBuilder<HttpResponseMessage>("TransientHttpError", 
    (builder, _) => builder.AddPipeline(resiliencePipelineBuilder.Build()));

// (Apizr) Get your manager instance
var reqResManager = ApizrBuilder.Current.CreateManagerFor<IReqResService>(
    options => options
        // With a logger
        .WithLoggerFactory(LoggerFactory.Create(loggingBuilder =>
            loggingBuilder.Debug()))
        // With the defined resilience pipeline registry
        .WithResiliencePipelineRegistry(resiliencePipelineRegistry)
        // And with a cache handler
        .WithAkavacheCacheHandler());

---

And then you're good to go:

var userList = await reqResManager.ExecuteAsync((api, opt) => api.GetUsersAsync(opt));

This request will be managed with the defined resilience strategies, data cached and all logged.

Apizr has a lot more to offer, just read the doc!

• Please read the Change Log to get a picture of what's in.
• Please read the Breaking changes to get a picture of what's changed.
• Please watch the Getting Started video:

Where

Managing (Core)

|Project|Current|Upcoming| |-------|-----|-----| |Apizr||| |Apizr.Extensions.Microsoft.DependencyInjection|||

Caching

|Project|Current|Upcoming| |-------|-----|-----| |Apizr.Extensions.Microsoft.Caching||| |Apizr.Integrations.Akavache||| |Apizr.Integrations.MonkeyCache|||

Handling

|Project|Current|Upcoming| |-------|-----|-----| |Apizr.Integrations.Fusillade||| |Apizr.Integrations.MediatR|||

Mapping

|Project|Current|Upcoming| |-------|-----|-----| |Apizr.Integrations.AutoMapper||| |Apizr.Integrations.Mapster|||

Transferring

|Project|Current|Upcoming| |-------|-----|-----| |Apizr.Integrations.FileTransfer||| |Apizr.Extensions.Microsoft.FileTransfer||| |Apizr.Integrations.FileTransfer.MediatR|[](https://www.nuget.org/packages/Apizr.Inte