mirror of
https://github.com/neondatabase/neon.git
synced 2026-01-09 22:42:57 +00:00
effd6bf829
Exposes metrics for caches. LKB-2594
This exposes a high level namespace, `cache`, that all cache metrics can
be added to - this makes it easier to make library panels for the caches
as I understand it.
To calculate the current cache fill ratio, you could use the following
query:
```
(
cache_inserted_total{cache="node_info"}
- sum (cache_evicted_total{cache="node_info"}) without (cause)
)
/ cache_capacity{cache="node_info"}
```
To calculate the cache hit ratio, you could use the following query:
```
cache_request_total{cache="node_info", outcome="hit"}
/ sum (cache_request_total{cache="node_info"}) without (outcome)
```
61 lines
1.9 KiB
Rust
61 lines
1.9 KiB
Rust
use crate::cache::common::{Cache, count_cache_insert, count_cache_outcome, eviction_listener};
|
|
use crate::cache::{Cached, ControlPlaneResult, CplaneExpiry};
|
|
use crate::config::CacheOptions;
|
|
use crate::control_plane::NodeInfo;
|
|
use crate::metrics::{CacheKind, Metrics};
|
|
use crate::types::EndpointCacheKey;
|
|
|
|
pub(crate) struct NodeInfoCache(moka::sync::Cache<EndpointCacheKey, ControlPlaneResult<NodeInfo>>);
|
|
pub(crate) type CachedNodeInfo = Cached<&'static NodeInfoCache, NodeInfo>;
|
|
|
|
impl Cache for NodeInfoCache {
|
|
type Key = EndpointCacheKey;
|
|
type Value = ControlPlaneResult<NodeInfo>;
|
|
|
|
fn invalidate(&self, info: &EndpointCacheKey) {
|
|
self.0.invalidate(info);
|
|
}
|
|
}
|
|
|
|
impl NodeInfoCache {
|
|
pub fn new(config: CacheOptions) -> Self {
|
|
let builder = moka::sync::Cache::builder()
|
|
.name("node_info")
|
|
.expire_after(CplaneExpiry::default());
|
|
let builder = config.moka(builder);
|
|
|
|
if let Some(size) = config.size {
|
|
Metrics::get()
|
|
.cache
|
|
.capacity
|
|
.set(CacheKind::NodeInfo, size as i64);
|
|
}
|
|
|
|
let builder = builder
|
|
.eviction_listener(|_k, _v, cause| eviction_listener(CacheKind::NodeInfo, cause));
|
|
|
|
Self(builder.build())
|
|
}
|
|
|
|
pub fn insert(&self, key: EndpointCacheKey, value: ControlPlaneResult<NodeInfo>) {
|
|
count_cache_insert(CacheKind::NodeInfo);
|
|
self.0.insert(key, value);
|
|
}
|
|
|
|
pub fn get(&self, key: &EndpointCacheKey) -> Option<ControlPlaneResult<NodeInfo>> {
|
|
count_cache_outcome(CacheKind::NodeInfo, self.0.get(key))
|
|
}
|
|
|
|
pub fn get_entry(
|
|
&'static self,
|
|
key: &EndpointCacheKey,
|
|
) -> Option<ControlPlaneResult<CachedNodeInfo>> {
|
|
self.get(key).map(|res| {
|
|
res.map(|value| Cached {
|
|
token: Some((self, key.clone())),
|
|
value,
|
|
})
|
|
})
|
|
}
|
|
}
|