Polly VS Redis

Polly

This is probably one of the most useful "cloud" patterns out there and it is fairly easy to implement. There are great articles and implementations, like Polly, already on the internet about this pattern so why another one?

Polly Documentation: Polly Official Site Circuit Breaker Design Pattern: Microsoft Learn Microservices Best Practices: Microservices on .NET

Custom HTTP handlers are well known as a mechanism to manage cross-cutting concerns around HTTP requests. The calling application has control over the HTTP handler pipeline, so it can be reconfigured, reordered, or even rebuilt from scratch. Decorating a client with a Token Management Handler or a custom Polly policy is easy... assuming the client accepts an HttpClient parameter in its constructor, and you haven't messed with the natural order of things by obstructing the client customization in some way (I really don't want to show how).

In our applications, we should wrap all requests to remote services in code that implements a retry policy that follows one of the strategies I listed earlier. If you are a .NET developer like myself, you may be familiar with the Polly library. Golang has a library called Retry, and there are numerous third-party libraries for Python and Java.

Another question that rises is, would it be better to use some HttpClient package to handle the requests, like Refit in combination with Polly. But then again, it seems Refit also uses the HttpClient factory, which was a bad thing according to the previous?

D'Oh! Sorry, not PolySharp. I meant Polly. Too many similarly-named libraries!

Everywhere I've worked with AGs, we've worked with the application team to add retry logic to help make things a bit more seamless to end users. There are libraries out there that can make this pretty easy - Polly is one that I've used a few times, but there are others.

Fallacy 1: The network is reliable. If system 2 works perfectly well, but is not accessible for service 1 due to network issues, service 2 is still unavailable. This is why timeouts, service breakers and retry policies exist. A great tool for .NET to handle common network issues is Polly, but even when using a tool like this, the network is still not completely reliable.

I see. Then I don't have any better idea right now, but I do want to suggest that if your script is mostly API calls and you want to be able to deal with failures then take a look at the polly library: https://github.com/App-vNext/Polly

Redis as caching layer

This guide walks you through a complete implementation of distributed caching for payment lookups. Using Redis and real-world examples with Flutterwave integration, you'll gain the knowledge to handle peak transaction loads without breaking a sweat.

Redis - In-memory data structure store

Redis GitHub repo

git clone https://github.com/redis/redis.git cd redis -------------------------------------------------------- open src/Makefile _ We have to modify Makefile _ Change the following lines for debugging_ # OPTIMIZATION?=-O2 OPTIMIZATION?=-O0 # REDIS_LD=$(QUIET_LINK)$(CC) $(FINAL_LDFLAGS) REDIS_LD=$(QUIET_LINK)$(CC) $(FINAL_LDFLAGS) $(OPTIMIZATION) -------------------------------------------------------- make distclean (clean any intermittent files if any). make -j 8 (use multi core if possible).

You are saying that like it is a bad thing. As far as I'm concerned, Valkey is a very healthy open source project with a wide range of companies and people contributing code to it and sponsoring development. None of these companies wield exclusive control over the project. And we all benefit from their work. And if I want, I can take their work and create a commercial product and try to sell it or make money of it. What's not to like there?

I don't get the anti-capitalist stance here. If you want to contribute to redis, Redis Inc. will require you to sign a contributor license agreement: https://github.com/redis/redis/blob/unstable/CONTRIBUTING.md

They'll be happy to take your work but the right to exploit it commercially is exclusive to them. That agreement (should you choose to sign it) gives them the right to take your contributions and re-license them under a proprietary license, or any license of their choosing. There's also no commitment that the code base will stay AGPL. That agreement gives them the right to do whatever. Agreements like that are very common with AGPL because it doesn't make much commercial sense to use that license without one.

> Put in anti-hyperscaler clauses into your licenses to preserve your ability to make money and be sustainable.

.. and permanently alienate the rest of the open source community from providing contributions to your project. That raises the question why you are open sourcing at all? Why would you cripple a community like that? Permissive licenses are successful because, well, they are permissive. It's why there are a lot of decades old OSS projects where the original developers and companies have long moved on, or in some cases, passed away. It doesn't matter. Because they have diverse communities that survive such things.

Alternatives to: Redis (Queue, Pub/Sub), ZeroMQ, RabbitMQ, Apache Kafka, Amazon Simple Queue Service, Google Cloud Pub/Sub

Redis

Picture this: you've just built a snappy web app, and you're feeling pretty good about it. You've added Redis to cache frequently accessed data, and your app is flying—pages load in milliseconds, users are happy, and you're a rockstar. But then, a user updates their profile, and… oops. The app still shows their old info. Or worse, a new blog post doesn't appear on the homepage. What's going on? Welcome to the sneaky world of cache invalidation, a concept that can improve your app's performance and reliability.

Redis GitHub Repository (for comparison)