How can I list all the keys/values in the cache?

[oasaleh]

I'm trying to list the cache entries with their expiration. How can I do that?

[jodydonetti]

Hi @oasaleh , that is not possible.

Since FusionCache is an hybrid cache with support for an optional L2 (distributed cache level) in a transparent way, the operations available are the ones doable on both levels, and it's not possible to enumerate cache entries on a distributed cache.

Hope this helps.

[oasaleh]

@jodydonetti, how do I verify that the expiration was set properly?

[jodydonetti]

What do you mean? Like to test if it's working correctly?
I do that in FusionCache test suite, and I set some expiration, wait, and see that the cache value si not there anymore.

Or did you mean something else?

NB: FusionCache underneath uses IMemoryCache and IDistributedCache, so if they work correctly (and I think we can agree they work, otherwise it would've been noticed already), then it works in FusionCache too.

[oasaleh]

No, I want to make sure I'm setting expiration correctly.

Also, how can I log when I retrieve a value from FusionCache? Right now, I use a flag; isFromCache. Is there a better way?

    private async Task<string> GetSecretInternalAsync(
        string secretCacheKey,
        Func<Task<KeyVaultSecret>> acquireSecretFunc)
    {
        bool isFromCache = true;

        string result = await _cache.GetOrSetAsync<string>(
            secretCacheKey, async (ctx, _) =>
            {
                isFromCache = false;
                logger.LogInformation("{secret} not found in cache. Acquiring a new secret.", secretCacheKey);

                KeyVaultSecret secret = await acquireSecretFunc();

                // Set the cache expiration based on the secret's expiration time
                if (secret.Properties.ExpiresOn.HasValue)
                {
                    ctx.Options.Duration = secret.Properties.ExpiresOn.Value - DateTime.UtcNow;
                }
                else
                {
                    logger.LogWarning(
                        "Secret {secret} has no expiration date. Using default cache duration.", secretCacheKey);
                }

                logger.LogInformation(
                    "New {secret} acquired. Expiration date (UTC) is {expirationDateUtc}.", secretCacheKey,
                    (secret.Properties.ExpiresOn ?? DateTime.UtcNow.Add(ctx.Options.Duration)).ToUniversalTime());

                return secret.Value;
            }, options => options.SetDuration(TimeSpan.FromHours(1))); // Defaults to 1 hour if not specified

        if (isFromCache)
        {
            logger.LogInformation("Secret {secret} was retrieved from the cache.", secretCacheKey);
        }

        return result;
    }

[jodydonetti]

No, I want to make sure I'm setting expiration correctly.

Hi, I can confirm that by doing ctx.Options.Duration = secret.Properties.ExpiresOn.Value - DateTime.UtcNow; you are in fact setting the duration dynamically.

On top this, except for logging (as you are already doing), looking at the source code or debugging+inspecting the underlying memory cache at runtime, I can't think of any other way of being sure.

Also, how can I log when I retrieve a value from FusionCache? Right now, I use a flag; isFromCache. Is there a better way?
Can confirm: as of today this is the way to do it.

I'm thinking about a couple of other ways to achieve the same result, but there's (currently) nothing yet ready to play with.

Hope this helps.

[oasaleh]

debugging+inspecting the underlying memory cache at runtime

This does not work. It drove me crazy before with MemoryCache until I figured another way to do it. I replied with the code below. However, it does not work for FusionCache for somereason.

[lonix1]

@oasaleh I also need to enumerate the cache entries. Did you find a workaround?

[lonix1]

Me too L1 (I assume that means MemoryCache) only.

[jodydonetti]

@lonix1 yes with L1 I meant the memory level.

@oasaleh since in FusionCache the L1 is implemented with IMemoryCache, can I ask which was the reflection trick you've used?

[oasaleh]

Here's the code.

public static class MemoryCacheExtensions
{
    /// <summary>
    ///     Lists all fields of the given memory cache instance using reflection.
    /// </summary>
    /// <param name="cache">The memory cache instance to list fields from.</param>
    public static void ListAllFields(this IMemoryCache cache)
    {
        FieldInfo[] fields = cache.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Instance);
        foreach (FieldInfo field in fields)
        {
            Console.WriteLine(field.Name);
        }
    }

    /// <summary>
    ///     Retrieves all cache items from the given memory cache instance.
    /// </summary>
    /// <param name="cache">The memory cache instance to retrieve items from.</param>
    /// <returns>
    ///     A dictionary containing all cache items, where the keys are cache item keys and the values are cache item
    ///     values.
    /// </returns>
    /// <exception cref="InvalidOperationException">Thrown when the internal field '_coherentState' cannot be found.</exception>
    public static Dictionary<string, object> GetAllCacheItems(this IMemoryCache cache)
    {
        Dictionary<string, object> cacheItems = [];

        // Use reflection to find all fields
        FieldInfo entriesField =
            cache.GetType().GetField("_coherentState", BindingFlags.NonPublic | BindingFlags.Instance) ??
            throw new InvalidOperationException("Unable to find _entries field.");

        object coherentStateValue = entriesField.GetValue(cache);

        PropertyInfo entriesProperty = coherentStateValue.GetType()
            .GetProperty("EntriesCollection", BindingFlags.NonPublic | BindingFlags.Instance);

        if (entriesProperty?.GetValue(coherentStateValue) is IDictionary entries)
        {
            foreach (DictionaryEntry entry in entries)
            {
                var key = entry.Key.ToString();
                PropertyInfo valueProperty = entry.Value.GetType().GetProperty("Value");
                object value = valueProperty?.GetValue(entry.Value);

                if (key != null && value != null)
                {
                    cacheItems[key] = value;
                }
            }
        }

        return cacheItems;
    }
}

[lonix1]

Very clever from a technical standpoint, but I wouldn't use that in production. It's begging for trouble.

My workaround works and is safe. I created an adapter which encapsulates FusionCache and updates the cache key collection during various events. An (messy) alternative would be to keep that collection somewhere else, thus avoiding the adapter.

Of course, a built-in way would be better.

[lonix1]

One problem with my approach: it only exposes the key not the value. Handling those events means the value is already lost. So either we need PreFoo and Foo events, or we need to store keys and values separately, in a parallel structure, which is messy.

So in the future, hopefully we'll have a built-in way to get the keys and values.