Feature suggestion: Auto-refresh when remaining TTL is below under certain threshold about cached HOT 1 OPEN

That's an interesting case. I've just released some changes to support this in 0.27.0. Unfortunately, it's not something simple enough that I think it should handled completely by the #[cached] macro since refreshing the value would involve blocking the current thread, or knowing how not to block the current thread (new thread / async task).

Instead of adding that complexity to the macro itself, the macro now generates an additional function *_prime_cache to let you forcefully update the cache yourself. See

So to get the functionality you're looking for you can manually run a thread of logic with your preferred concurrency mechanism (threads or async) to continuously update the cache for a specific set of arguments or for a #[once] singleton like this example from the readme

The one "downside" of this is that you must prime the cache using every distinct set of function arguments. If you'd like to always re-prime every key, you can do so by iterating over the cache keys directly and passing those keys as function arguments like so

use std::thread::sleep;
use std::time::Duration;
use cached::proc_macro::cached;

#[cached(key = "String", convert = r#"{ String::from(a) }"#)]
fn keyed(a: &str) -> usize {
    a.len()
}
pub fn main() {
    std::thread::spawn(|| {
        loop {
            sleep(Duration::from_secs(60));
            let keys: Vec<String> = {
                // note the cache keys are a tuple of all function arguments, unless it's one value
                KEYED.lock().unwrap().get_store().keys().map(|k| k.clone()).collect()
            };
            for k in &keys {
                keyed_prime_cache(k);
            }
        }
    });
}

from cached.