Struct merino_cache::MemoryCacheSuggester

pub struct MemoryCacheSuggester {
    inner: Box<dyn SuggestionProvider>,
    metrics_client: StatsdClient,
    items: Arc<DedupedMap<String, Instant, Vec<Suggestion>>>,
    default_ttl: Duration,
    default_lock_timeout: Duration,
    max_background_removals: usize,
}

A in-memory cache for suggestions.

Fields

inner: Box<dyn SuggestionProvider>

The suggester to query on cache-miss.

metrics_client: StatsdClient

The Statsd client used to record statistics.

items: Arc<DedupedMap<String, Instant, Vec<Suggestion>>>

The cached items.

default_ttl: Duration

TTL to apply to items if the underlying provider does not give one.

default_lock_timeout: Duration

TTL for locks on cache refresh updates

max_background_removals: usize

Maximum number of entries to remove in a single background expiration iteration.

Implementations

impl Suggester

pub fn new_boxed(
    config: MemoryCacheConfig,
    provider: Box<dyn SuggestionProvider>,
    metrics_client: StatsdClient
) -> Box<Self>

Create a in-memory suggestion cache from settings that wraps provider.

fn remove_expired_entries(&mut self)

Remove expired entries from items

fn clone_with_null_provider(&self) -> Self

It is often useful to have access to most of the fields on this object, but providers are not generally cloneable, so self.inner cannot be cloned.

Introducing an Arc around inner complicates things, but the situations where we want clones of this object don’t need the inner provider. So perform a partial clone that clones most fields, replacing the provider with a dummy value.

Trait Implementations

impl SuggestionProvider for Suggester

fn name(&self) -> String

An operator-visible name for this suggestion provider.

fn cache_inputs(
    &self,
    req: &SuggestionRequest,
    cache_inputs: &mut dyn CacheInputs
)

Generate a set of cache inputs for a given query specific to this provider. Any property of the query that affects how suggestions are generated should be included.

fn suggest<'life0, 'async_trait>(
    &'life0 self,
    query: SuggestionRequest
) -> Pin<Box<dyn Future<Output = Result<SuggestionResponse, SuggestError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Provide suggested results for query.

fn reconfigure<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    new_config: Value,
    make_fresh: &'life1 MakeFreshType
) -> Pin<Box<dyn Future<Output = Result<(), SetupError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Reconfigure the provider, using a new configuration object. State should be preserved if possible.

fn is_null(&self) -> bool

Return if this provider is null and can be ignored. Providers that set this to true should be ignored in any place where suggestions are needed. Providers with this set to true likely only serve as a blank space where we may need a provider but can’t otherwise supply one.

fn cache_key(&self, req: &SuggestionRequest) -> String

Use Self::cache_inputs to generate a single cache key. This function should not normally be overridden by provider implementations.