How to force refresh?

[angularsen]

Could not find any best practices on this, so what is a good way to attempt a force refresh of the cache?

A few ideas:

1. Remove() then GetOrSet() will remove from both memory and distributed cache, but I only want to update value if successful not remove anything
2. Expire() then GetOrSet() will remove from distributed cache even if not expired, same reason (docs say In the distributed cache (if any), the entry will be effectively removed.)
3. Expire() with SkipDistributedCache=true, then GetOrSet(), may work if it indeed skips updating distributed cache
4. GetOrSet() with SkipMemoryCache=true and SkipDistributedCache=true, I assume this will not update cache with fresh new value?

[jodydonetti]

Hi @angularsen

what is a good way to attempt a force refresh of the cache?

I'm not sure I'm understanding this, can you be more explicit?

Anyway, in general:

• a refresh will happen when a GetOrSet() call is made on a cache entry that is either not there at all, or is expired
• simply calling Expire() or Remove() will do that
• the next GetOrSet() request will trigger the refresh

Keep in mind that, if you enabled fail-safe and/or soft/hard timeouts, in case of problems the stale data may be used, but that's the whole purpose of those features, and you have to opt-in to them.

[angularsen]

I want to force getting a fresh new value, even if cache is not yet stale.
Only if successful, I want to update memory and distributed cache so we don't lose any cached data.

I guess the question is more about if FusionCache offers this functionality out of the box, since we could basically just:

• Explicitly call the factory method ourselves
• If successful, call SetAsync() afterwards.

However, then we lose out on cache stampede, which might be useful if user performs multiple actions that want to refresh cache, so I was thinking I maybe using GetOrSet() was better.

The use case is an app with long-lived persisted cache, wher on user action we want to force refreshing data. If it succeeds, we get a fresh value and update the UI. If it fails, no data is lost.

[jodydonetti]

I want to force getting a fresh new value, even if cache is not yet stale. Only if successful, I want to update memory and distributed cache so we don't lose any cached data.

Ok, got it!

I guess the question is more about if FusionCache offers this functionality out of the box, since we could basically just:

• Explicitly call the factory method ourselves
• If successful, call SetAsync() afterwards.

Exactly, I was about to say that. But... (see below)

However, then we lose out on cache stampede, which is why I was thinking I could accomplish this with GetOrSet().

Yep, but - and I know this feels counterintuitive at first - the problem would be the same even with a GetOrSet() + a supposedly "force" param. This is because what you are thinking about (and I know because I've done the same 😅) is a GetOrSet() where you can say "ignore the cached value and force refresh, but with stampede protection", but by "ignoring the cached value" we would be basically queuing factory calls, one after the other.

Imagine this flow:

• a call GetOrSet() + new param arrives
• a lock is acquired
• another call GetOrSet() + new param arrives
• lock is already taken, 2nd call will wait
• 1st call finish
• cache is updated
• lock is released
• 2nd call get the lock
• call the factory
• etc...

See where I'm going?

The solution is simply to think about it the other way around, and add fail-safe into the mix: you Remove()/Expire() and let it do its thing.
If the factory executes successfully, the data in the cache will be updated, otherwise, fail-safe will kick in and temporarily re-use the stale data, as you mentioned above.

Also, you can even add soft/hard timeout to the mix to guarantee the use of stale value not only when the factory fails, but even when it is slow to answer.

The use case is that we generally want to have long-lived cache in an app, and sometimes on user action we want to force refreshing data. If it succeeds, we get a fresh value. If it fails, we still have the existing cache, stale or not.

With the approach above, this is exactly what will happen with a normal Remove()/Expire() + fail-safe.

Hope this helps, let me know if it's clear!

[angularsen]

I see, I thought 2nd call would basically await the same Task as produced by 1st request?

1. 1st GetOrSet, it grabs the lock, a Task is created and temporarily cached while request is in flight
2. 2nd GetOrSet, lock is occupied, awaits cached Task
3. Both return when Task completes (or fails)

This would be more complicated if we wanted 2nd GetOrSet to retry factory method in case of error, but I think both getting the same result or error actually is more intuitive.

Could this maybe be a feature?
Cache stampede that reuses the result of the first call, but only in case of concurrency? So if first request succeeds before a second concurrent request comes in, no Task is cached and reused.

add fail-safe into the mix [...] If the factory executes successfully, the data in the cache will be updated, otherwise, fail-safe will kick in and temporarily re-use the stale data, as you mentioned above.

Right, we do use fail-safe. But, let's say the duration is 5 minutes with a fail safe of 24 hours. The problem is that when the user makes a change to data, we can't have up to 5 minutes of stale data in the UI, we need to see the updated data, which must be fetched from API.
So on user action, we need to attempt to get a fresh value from API, but if this for some reason fails, show feedback to user and don't evict cache.
We can't change duration to 1ms either, as this would spam the API. We just need to force refresh in some cases.

[angularsen]

After looking through the source code and better understanding how this works, I believe the simplest solution is option 3

3. Expire() with SkipDistributedCache=true, then GetOrSet(), may work if it indeed skips updating distributed cache

A quick experiment confirms that we can logically expire in-memory without evicting neither distributed nor memory cache, to "force" GetOrSet() to attempt getting a fresh value and still fall back on fail-safe behavior if it fails and not lose any data.

[08:28:48 INF] Set key foo to value 'bar'
[08:28:48 INF] Expired key foo in memory only
[08:28:48 INF] Distributed value with fail-safe: bar
[08:28:48 INF] Memory value with fail-safe: N/A memory fail-safe
[08:28:48 INF] Distributed value without fail-safe: bar
[08:28:48 INF] Memory value without fail-safe: N/A memory
[08:28:48 INF] Raw distributed value: {"Value":"bar","Metadata":{"LogicalExpiration":"2024-09-04T06:58:48.186158+00:00","IsFromFailSafe":false},"Timestamp":638610281281790050}

            const string key = "foo";

            await _fusionCache.SetAsync(key, "bar", new FusionCacheEntryOptions
            {
                IsFailSafeEnabled = true,
                Duration = TimeSpan.FromMinutes(30),
                FailSafeMaxDuration = TimeSpan.FromMinutes(60),
            }, stoppingToken);
            Log.Information("Set key {Key} to value 'bar'", key);

            if (! _fusionCache.HasDistributedCache) throw new InvalidOperationException("FusionCache is not using a distributed cache");

            await _fusionCache.ExpireAsync(key, new FusionCacheEntryOptions
            {
                SkipMemoryCache = false,     // Do update in-memory, expire will logically expire in-memory, but not remove it.
                SkipDistributedCache = true, // Don't update distributed cache, it would remove the entry instead of logically expire it. Also, for multiple nodes they won't try to concurrently update the same key.
            }, stoppingToken);

            Log.Information("Expired key {Key} in memory only", key);

            string distributedValueWithFailSafe = await _fusionCache.GetOrDefaultAsync(key, defaultValue: "N/A distributed fail-safe", new FusionCacheEntryOptions
            {
                IsFailSafeEnabled = true,
                SkipMemoryCache = true,
            }, stoppingToken);
            Log.Information("Distributed value with fail-safe: {Value}", distributedValueWithFailSafe);

            string memoryValueWithFailSafe = await _fusionCache.GetOrDefaultAsync(key, defaultValue: "N/A memory fail-safe", new FusionCacheEntryOptions
            {
                IsFailSafeEnabled = true,
                SkipDistributedCache = true,
            }, stoppingToken);
            Log.Information("Memory value with fail-safe: {Value}", memoryValueWithFailSafe);

            string distributedValueWithoutFailSafe = await _fusionCache.GetOrDefaultAsync(key, defaultValue: "N/A distributed", new FusionCacheEntryOptions
            {
                IsFailSafeEnabled = false,
                SkipMemoryCache = true,
            }, stoppingToken);
            Log.Information("Distributed value without fail-safe: {Value}", distributedValueWithoutFailSafe);

            string memoryValueWithoutFailSafe = await _fusionCache.GetOrDefaultAsync(key, defaultValue: "N/A memory", new FusionCacheEntryOptions
            {
                IsFailSafeEnabled = false,
                SkipDistributedCache = true,
            }, stoppingToken);
            Log.Information("Memory value without fail-safe: {Value}", memoryValueWithoutFailSafe);

            string rawDistributedValue = await _distributedCache.GetAsync("v0:" + key, stoppingToken) is { } bytes
                ? Encoding.UTF8.GetString(bytes)
                : "N/A raw distributed value";
            Log.Information("Raw distributed value: {Value}", rawDistributedValue);

[angularsen]

Updated example with Expire + GetOrSet, found a couple of new things

1. Expire() must also specify IsFailSafeEnabled = true to expire instead of removing the entry from memory
2. GetOrSet() must also specify SkipDistributedCacheReadWhenStale = true, this is not default behavior

On a side-note, I think the API would be easier if Expire, Get, GetOrSet had different options types. It is not always easy to see what options are relevant for the operation.

[08:01:54 INF] Set key foo to value 'myCachedValue'
[08:01:54 INF] Expired key foo in memory only
[08:01:58 INF] GetOrSet factory, hasStale True, staleValue myCachedValue
[08:01:58 INF] GetOrSet value with fail-safe: fresh value

            const string key = "foo";

            await _fusionCache.SetAsync(key, "myCachedValue", new FusionCacheEntryOptions
            {
                IsFailSafeEnabled = true,
                Duration = TimeSpan.FromMinutes(30),
                FailSafeMaxDuration = TimeSpan.FromMinutes(60),
            }, ct);
            Log.Information("Set key {Key} to value 'myCachedValue'", key);

            if (! _fusionCache.HasDistributedCache) throw new InvalidOperationException("FusionCache is not using a distributed cache");

            await _fusionCache.ExpireAsync(key, new FusionCacheEntryOptions
            {
                IsFailSafeEnabled = true,
                SkipMemoryCache = false,     // Do update in-memory, expire will logically expire in-memory, but not remove it.
                SkipDistributedCache = true, // Don't update distributed cache, it would remove the entry instead of logically expire it. Also, for multiple nodes they won't try to concurrently update the same key.
            }, ct);

            Log.Information("Expired key {Key} in memory only", key);

            var getOrSetValue = await _fusionCache.GetOrSetAsync<string>(key, (ctx, _) =>
            {
                Log.Information("GetOrSet factory, hasStale {HasStale}, staleValue {StaleValue}", ctx.HasStaleValue, ctx.StaleValue.GetValueOrDefault() ?? "N/A");
                return Task.FromResult("fresh value");
            }, new FusionCacheEntryOptions
            {
                IsFailSafeEnabled = true,
                SkipDistributedCacheReadWhenStale = true, // Skip distributed cache to force getting fresh value now that in-memory is expired.
                Duration = TimeSpan.FromMinutes(30),
                FailSafeMaxDuration = TimeSpan.FromMinutes(60),
            }, ct);
            Log.Information("GetOrSet value with fail-safe: {Value}", getOrSetValue);

            if (getOrSetValue != "fresh value")
                throw new InvalidOperationException("Did not get fresh value from GetOrSet");

[angularsen]

I'll close this as solved, I have something that works for me.

To "force refresh" cache in a system with multiple instances of the same app/service:

• First call ExpireAsync() with options
  • IsFailSafeEnabled = true, to expire in-memory cache instead of removing it
  • SkipDistributedCache = true, to avoid cache stampede across server instances
• Then call GetOrSetAsync() with IsFailSafeEnabled = true to attempt to update cache, with fallback to the now "stale" cache if it fails to get a fresh value.