lmcache-cli 0.4.5.dev0__py3-none-any.whl

lmcache/v1/mp_observability/subscribers/metrics/l0_lifecycle.py

@@ -0,0 +1,290 @@
+# SPDX-License-Identifier: Apache-2.0
+
+"""L0 (GPU) KV cache metrics subscriber — OTel histograms for block lifecycle.
+
+Subscribes to ``MP_VLLM_BLOCK_ALLOCATION`` and ``MP_VLLM_END_SESSION`` events
+and maintains a shadow map of physical GPU block IDs to detect cache hits and
+evictions.
+
+State machine per block:
+
+  1. Block first seen in allocation → ACTIVE (owned by req_id)
+  2. Same block, same tokens, same req_id → ignore (decode continuation)
+  3. Same block, same tokens, different req_id, block ACTIVE →
+     prefix sharing, just add req_id as co-owner
+  4. Same block, same tokens, block RELEASED → true cache hit (reuse),
+     record access, transition to ACTIVE
+  5. Same block, different tokens → eviction detected,
+     emit metrics, start fresh
+  6. END_SESSION(req_id) → remove req_id from all blocks it owns.
+     If a block has no remaining owners → RELEASED.
+
+Limitations:
+  - ``BlockAllocationRecord`` only reports **new** block IDs per request per
+    scheduler step, not all blocks a request uses.  Blocks reused via prefix
+    cache are invisible after initial allocation.  This means the subscriber
+    only tracks a subset of physical blocks and will undercount evictions
+    compared to vLLM's internal ``KVCacheMetricsCollector``.
+  - Eviction is detected at **reallocation** time, not at the exact moment
+    vLLM frees the block.  Lifetime measurements include the gap between
+    eviction and reallocation.
+"""
+
+# Future
+from __future__ import annotations
+
+# Standard
+from collections import deque
+from dataclasses import dataclass, field
+from enum import Enum
+import random
+import time
+
+# Third Party
+from opentelemetry import metrics
+
+# First Party
+from lmcache.v1.mp_observability.event import Event, EventType
+from lmcache.v1.mp_observability.event_bus import EventCallback, EventSubscriber
+
+# Maximum number of recent access timestamps kept per block (ring buffer).
+_MAX_ACCESS_HISTORY = 4
+
+
+class _BlockStatus(Enum):
+    ACTIVE = "active"  # Owned by at least one live request.
+    RELEASED = "released"  # All owning requests have ended.
+
+
+@dataclass
+class _L0BlockState:
+    """Per-block lifecycle state in the shadow map."""
+
+    instance_id: int
+    model_name: str
+    token_ids: list[int]
+    owners: set[str]  # Set of req_ids currently using this block.
+    status: _BlockStatus
+    alloc_time: float
+    last_access_time: float
+    access_history: deque[float] = field(
+        default_factory=lambda: deque(maxlen=_MAX_ACCESS_HISTORY)
+    )
+
+
+class L0LifecycleSubscriber(EventSubscriber):
+    """Tracks GPU (L0) KV cache block lifecycle via shadow monitoring.
+
+    Metrics (all histograms, in seconds):
+    - ``lmcache_mp.l0_block_lifetime_seconds``
+    - ``lmcache_mp.l0_block_idle_before_evict_seconds``
+    - ``lmcache_mp.l0_block_reuse_gap_seconds``
+
+    Parameters:
+        sample_rate: Fraction of blocks to track (0, 1.0].  Default 0.01
+            (1%) matches vLLM's default.
+    """
+
+    def __init__(self, sample_rate: float = 0.01) -> None:
+        assert 0 < sample_rate <= 1.0, (
+            f"sample_rate must be in (0, 1.0], got {sample_rate}"
+        )
+        self._sample_rate = sample_rate
+
+        # Shadow map: (instance_id, block_id) -> lifecycle state.
+        self._shadow: dict[tuple[int, int], _L0BlockState] = {}
+        # Set of (instance_id, block_id) we decided NOT to sample.
+        self._skipped: set[tuple[int, int]] = set()
+        # Reverse index: req_id -> set of (instance_id, block_id) owned.
+        self._req_blocks: dict[str, set[tuple[int, int]]] = {}
+
+        meter = metrics.get_meter("lmcache.l0")
+        self._lifetime_hist = meter.create_histogram(
+            "lmcache_mp.l0_block_lifetime_seconds",
+            description=(
+                "Histogram of GPU KV cache block lifetime from "
+                "allocation to eviction (seconds)."
+            ),
+            unit="s",
+        )
+        self._idle_hist = meter.create_histogram(
+            "lmcache_mp.l0_block_idle_before_evict_seconds",
+            description=(
+                "Histogram of idle time before GPU KV cache block eviction (seconds)."
+            ),
+            unit="s",
+        )
+        self._reuse_gap_hist = meter.create_histogram(
+            "lmcache_mp.l0_block_reuse_gap_seconds",
+            description=(
+                "Histogram of time gaps between consecutive GPU KV "
+                "cache block accesses (seconds)."
+            ),
+            unit="s",
+        )
+
+    # -- EventSubscriber interface -----------------------------------------
+
+    def get_subscriptions(self) -> dict[EventType, EventCallback]:
+        return {
+            EventType.MP_VLLM_BLOCK_ALLOCATION: self._on_block_allocation,
+            EventType.MP_VLLM_END_SESSION: self._on_end_session,
+        }
+
+    # -- Event handlers ----------------------------------------------------
+
+    def _on_block_allocation(self, event: Event) -> None:
+        """Process a batch of ``BlockAllocationRecord`` from vLLM."""
+        instance_id = event.metadata.get("instance_id", 0)
+        model_name = event.metadata.get("model_name", "")
+        records = event.metadata.get("records", [])
+        now = event.timestamp or time.time()
+
+        for record in records:
+            self._process_record(instance_id, model_name, record, now)
+
+    def _on_end_session(self, event: Event) -> None:
+        """Handle request completion — release blocks owned by this request."""
+        req_id = event.metadata.get("request_id", "")
+        if not req_id:
+            return
+
+        block_keys = self._req_blocks.pop(req_id, set())
+        for block_key in block_keys:
+            state = self._shadow.get(block_key)
+            if state is None:
+                continue
+            state.owners.discard(req_id)
+            if not state.owners:
+                state.status = _BlockStatus.RELEASED
+
+    # -- Record processing -------------------------------------------------
+
+    def _process_record(
+        self, instance_id: int, model_name: str, record: object, now: float
+    ) -> None:
+        """Process a single BlockAllocationRecord."""
+        req_id: str = record.req_id  # type: ignore[attr-defined]
+        block_ids: list[int] = record.new_block_ids  # type: ignore[attr-defined]
+        token_ids: list[int] = record.new_token_ids  # type: ignore[attr-defined]
+
+        if not block_ids:
+            return
+
+        num_blocks = len(block_ids)
+        block_size = (
+            (len(token_ids) + num_blocks - 1) // num_blocks if num_blocks else 0
+        )
+
+        for i, block_id in enumerate(block_ids):
+            start = i * block_size
+            end = min(start + block_size, len(token_ids))
+            chunk_tokens = token_ids[start:end]
+            if not chunk_tokens:
+                continue
+            self._process_block(
+                instance_id, model_name, block_id, chunk_tokens, req_id, now
+            )
+
+    def _process_block(
+        self,
+        instance_id: int,
+        model_name: str,
+        block_id: int,
+        token_ids: list[int],
+        req_id: str,
+        now: float,
+    ) -> None:
+        """Update shadow map for a single physical block."""
+        block_key = (instance_id, block_id)
+        existing = self._shadow.get(block_key)
+
+        if existing is None:
+            # Block not in shadow map.
+            if block_key in self._skipped:
+                return
+
+            if not self._should_sample():
+                self._skipped.add(block_key)
+                return
+
+            # New allocation — start tracking.
+            self._shadow[block_key] = _L0BlockState(
+                instance_id=instance_id,
+                model_name=model_name,
+                token_ids=token_ids,
+                owners={req_id},
+                status=_BlockStatus.ACTIVE,
+                alloc_time=now,
+                last_access_time=now,
+            )
+            self._req_blocks.setdefault(req_id, set()).add(block_key)
+            return
+
+        # Block exists in shadow map.
+        if existing.token_ids == token_ids:
+            # Same content.
+            if req_id in existing.owners:
+                # Case 2: Same request reporting same block again (decode
+                # continuation or redundant report). Ignore.
+                return
+
+            if existing.status == _BlockStatus.ACTIVE:
+                # Case 3: Prefix sharing — another request is using this
+                # block while original request(s) still active. Not a reuse.
+                existing.owners.add(req_id)
+                self._req_blocks.setdefault(req_id, set()).add(block_key)
+            else:
+                # Case 4: Block was RELEASED, now reused with same content.
+                # This is a true cache hit.
+                existing.owners.add(req_id)
+                existing.status = _BlockStatus.ACTIVE
+                existing.last_access_time = now
+                existing.access_history.append(now)
+                self._req_blocks.setdefault(req_id, set()).add(block_key)
+        else:
+            # Case 5: Different content — eviction detected.
+            self._emit_eviction_metrics(existing, now)
+
+            # Clear old owners from reverse index.
+            for old_req in existing.owners:
+                block_set = self._req_blocks.get(old_req)
+                if block_set:
+                    block_set.discard(block_key)
+
+            # Start fresh.
+            self._shadow[block_key] = _L0BlockState(
+                instance_id=instance_id,
+                model_name=model_name,
+                token_ids=token_ids,
+                owners={req_id},
+                status=_BlockStatus.ACTIVE,
+                alloc_time=now,
+                last_access_time=now,
+            )
+            self._req_blocks.setdefault(req_id, set()).add(block_key)
+
+    # -- Metrics emission --------------------------------------------------
+
+    def _emit_eviction_metrics(self, state: _L0BlockState, now: float) -> None:
+        """Record histogram observations for an evicted block."""
+        lifetime = now - state.alloc_time
+        idle_time = now - state.last_access_time
+        attrs = {
+            "instance_id": str(state.instance_id),
+            "model_name": state.model_name,
+        }
+
+        self._lifetime_hist.record(lifetime, attrs)
+        self._idle_hist.record(idle_time, attrs)
+
+        # Reuse gaps from access history.
+        history = list(state.access_history)
+        for i in range(1, len(history)):
+            gap = history[i] - history[i - 1]
+            self._reuse_gap_hist.record(gap, attrs)
+
+    # -- Sampling ----------------------------------------------------------
+
+    def _should_sample(self) -> bool:
+        return random.random() < self._sample_rate

lmcache/v1/mp_observability/subscribers/metrics/l1.py

@@ -0,0 +1,55 @@
+# SPDX-License-Identifier: Apache-2.0
+
+"""L1 metrics subscriber — OTel counters for L1Manager events."""
+
+# Future
+from __future__ import annotations
+
+# Third Party
+from opentelemetry import metrics
+
+# First Party
+from lmcache.v1.mp_observability.event import Event, EventType
+from lmcache.v1.mp_observability.event_bus import EventCallback, EventSubscriber
+
+
+class L1MetricsSubscriber(EventSubscriber):
+    """Maintains OTel counters for L1Manager operations.
+
+    Metric parity with the old ``L1ManagerStatsLogger``:
+    - ``lmcache_mp.l1_read_keys``  — keys read from L1
+    - ``lmcache_mp.l1_write_keys`` — keys written to L1
+    - ``lmcache_mp.l1_evicted_keys`` — keys evicted from L1
+    """
+
+    def __init__(self) -> None:
+        meter = metrics.get_meter("lmcache.l1")
+        self._read_counter = meter.create_counter(
+            "lmcache_mp.l1_read_keys",
+            description="Total keys read from L1",
+        )
+        self._write_counter = meter.create_counter(
+            "lmcache_mp.l1_write_keys",
+            description="Total keys written to L1",
+        )
+        self._evicted_counter = meter.create_counter(
+            "lmcache_mp.l1_evicted_keys",
+            description="Total keys evicted from L1",
+        )
+
+    def get_subscriptions(self) -> dict[EventType, EventCallback]:
+        return {
+            EventType.L1_READ_FINISHED: self._on_read_finished,
+            EventType.L1_WRITE_FINISHED: self._on_write_finished,
+            EventType.L1_WRITE_FINISHED_AND_READ_RESERVED: self._on_write_finished,
+            EventType.L1_KEYS_EVICTED: self._on_evicted,
+        }
+
+    def _on_read_finished(self, event: Event) -> None:
+        self._read_counter.add(len(event.metadata["keys"]))
+
+    def _on_write_finished(self, event: Event) -> None:
+        self._write_counter.add(len(event.metadata["keys"]))
+
+    def _on_evicted(self, event: Event) -> None:
+        self._evicted_counter.add(len(event.metadata["keys"]))

lmcache/v1/mp_observability/subscribers/metrics/l1_lifecycle.py

@@ -0,0 +1,166 @@
+# SPDX-License-Identifier: Apache-2.0
+
+"""L1 chunk lifecycle subscriber — OTel histograms for L1 chunk lifecycle.
+
+Separated from L1MetricsSubscriber (counters) so that users can enable/disable
+lifecycle tracking independently.  The shadow map and sampling overhead are
+non-negligible, so this subscriber should only be registered when lifecycle
+metrics are needed.
+"""
+
+# Future
+from __future__ import annotations
+
+# Standard
+from dataclasses import dataclass
+from typing import Any
+import time
+
+# Third Party
+from opentelemetry import metrics
+
+# First Party
+from lmcache.v1.mp_observability.event import Event, EventType
+from lmcache.v1.mp_observability.event_bus import EventCallback, EventSubscriber
+
+
+@dataclass
+class _L1ChunkState:
+    """Per-chunk lifecycle state in the shadow map."""
+
+    alloc_time: float
+    last_access_time: float
+
+
+class L1LifecycleSubscriber(EventSubscriber):
+    """Tracks L1 chunk lifecycle via shadow monitoring.
+
+    Histograms (chunk lifecycle):
+    - ``lmcache_mp.l1_chunk_lifetime_seconds`` — allocation to eviction
+    - ``lmcache_mp.l1_chunk_idle_before_evict_seconds`` — last access to eviction
+    - ``lmcache_mp.l1_chunk_reuse_gap_seconds`` — gap between consecutive touches
+    - ``lmcache_mp.l1_chunk_evict_reuse_gap_seconds`` — eviction to
+      next reuse (capped at ``max_evict_reuse_wait``)
+
+    Parameters:
+        sample_rate: Fraction of chunks to track (0, 1.0].  Default 0.01 (1%).
+        max_evict_reuse_wait: Maximum seconds to track an evicted chunk
+            waiting for reuse.  Default 300 s (5 min).
+    """
+
+    def __init__(
+        self,
+        sample_rate: float = 0.01,
+        max_evict_reuse_wait: float = 300.0,
+    ) -> None:
+        assert 0 < sample_rate <= 1.0, (
+            f"sample_rate must be in (0, 1.0], got {sample_rate}"
+        )
+        self._sample_rate = sample_rate
+        self._max_evict_reuse_wait = max_evict_reuse_wait
+        # Deterministic sampling via hash: hash(key) % _SAMPLE_PRIME < threshold.
+        # O(1) memory, no set growth, same key always gets the same decision.
+        self._sample_prime = 1_000_003
+        self._sample_threshold = int(sample_rate * self._sample_prime)
+        meter = metrics.get_meter("lmcache.l1")
+        self._lifetime_hist = meter.create_histogram(
+            "lmcache_mp.l1_chunk_lifetime_seconds",
+            description=(
+                "Histogram of L1 chunk lifetime from allocation to eviction (seconds)."
+            ),
+            unit="s",
+        )
+        self._idle_hist = meter.create_histogram(
+            "lmcache_mp.l1_chunk_idle_before_evict_seconds",
+            description=("Histogram of idle time before L1 chunk eviction (seconds)."),
+            unit="s",
+        )
+        self._reuse_gap_hist = meter.create_histogram(
+            "lmcache_mp.l1_chunk_reuse_gap_seconds",
+            description=(
+                "Histogram of time gaps between consecutive "
+                "touches (write or read) of the same L1 chunk (seconds)."
+            ),
+            unit="s",
+        )
+        self._evict_reuse_gap_hist = meter.create_histogram(
+            "lmcache_mp.l1_chunk_evict_reuse_gap_seconds",
+            description=(
+                "Histogram of time from L1 chunk eviction to "
+                "next reuse.  Capped at max_evict_reuse_wait."
+            ),
+            unit="s",
+        )
+
+        # Shadow map: key -> chunk lifecycle state (live chunks).
+        self._shadow: dict[Any, _L1ChunkState] = {}
+        # Evicted map: key -> eviction timestamp (waiting for reuse).
+        self._evicted_at: dict[Any, float] = {}
+
+    def get_subscriptions(self) -> dict[EventType, EventCallback]:
+        return {
+            EventType.L1_READ_FINISHED: self._on_read_finished,
+            EventType.L1_WRITE_FINISHED: self._on_write_finished,
+            EventType.L1_WRITE_FINISHED_AND_READ_RESERVED: self._on_write_finished,
+            EventType.L1_KEYS_EVICTED: self._on_evicted,
+        }
+
+    def _on_read_finished(self, event: Event) -> None:
+        now = event.timestamp or time.time()
+        for key in event.metadata["keys"]:
+            state = self._shadow.get(key)
+            if state is not None:
+                self._reuse_gap_hist.record(now - state.last_access_time)
+                state.last_access_time = now
+
+    def _on_write_finished(self, event: Event) -> None:
+        now = event.timestamp or time.time()
+        for key in event.metadata["keys"]:
+            # Check if this is a reuse of an evicted chunk.
+            evict_time = self._evicted_at.pop(key, None)
+            if evict_time is not None:
+                gap = min(now - evict_time, self._max_evict_reuse_wait)
+                self._evict_reuse_gap_hist.record(gap)
+
+            state = self._shadow.get(key)
+            if state is not None:
+                # Re-write of existing chunk counts as a touch.
+                self._reuse_gap_hist.record(now - state.last_access_time)
+                self._shadow[key] = _L1ChunkState(
+                    alloc_time=now,
+                    last_access_time=now,
+                )
+            else:
+                # First time seeing this key — deterministic sample check.
+                if not self._should_sample(key):
+                    continue
+                self._shadow[key] = _L1ChunkState(
+                    alloc_time=now,
+                    last_access_time=now,
+                )
+        self._sweep_stale_evictions(now)
+
+    def _on_evicted(self, event: Event) -> None:
+        now = event.timestamp or time.time()
+        for key in event.metadata["keys"]:
+            state = self._shadow.pop(key, None)
+            if state is not None:
+                self._lifetime_hist.record(now - state.alloc_time)
+                self._idle_hist.record(now - state.last_access_time)
+                # Start tracking eviction-to-reuse gap (only for sampled).
+                self._evicted_at[key] = now
+        self._sweep_stale_evictions(now)
+
+    def _should_sample(self, key: object) -> bool:
+        return hash(key) % self._sample_prime < self._sample_threshold
+
+    def _sweep_stale_evictions(self, now: float) -> None:
+        """Report T and discard evicted entries older than max_evict_reuse_wait."""
+        stale = [
+            key
+            for key, evict_time in self._evicted_at.items()
+            if now - evict_time >= self._max_evict_reuse_wait
+        ]
+        for key in stale:
+            self._evicted_at.pop(key, None)
+            self._evict_reuse_gap_hist.record(self._max_evict_reuse_wait)

lmcache/v1/mp_observability/subscribers/metrics/l2.py

@@ -0,0 +1,121 @@
+# SPDX-License-Identifier: Apache-2.0
+
+"""L2 storage metrics subscriber — OTel counters for L2 store/prefetch events."""
+
+# Future
+from __future__ import annotations
+
+# Third Party
+from opentelemetry import metrics
+
+# First Party
+from lmcache.v1.mp_observability.event import Event, EventType
+from lmcache.v1.mp_observability.event_bus import EventCallback, EventSubscriber
+
+
+class L2MetricsSubscriber(EventSubscriber):
+    """Maintains OTel counters for L2 store and prefetch operations.
+
+    Metrics:
+    - ``lmcache_mp.l2_store_tasks``         — store tasks submitted to L2
+    - ``lmcache_mp.l2_store_keys``          — keys submitted for L2 store
+    - ``lmcache_mp.l2_store_completed``     — store tasks completed
+    - ``lmcache_mp.l2_store_succeeded_keys`` — keys successfully stored to L2
+    - ``lmcache_mp.l2_store_failed_keys``   — keys that failed to store to L2
+    - ``lmcache_mp.l2_prefetch_lookups``    — prefetch lookup requests
+    - ``lmcache_mp.l2_prefetch_lookup_keys`` — keys submitted for lookup
+    - ``lmcache_mp.l2_prefetch_hit_keys``   — prefix keys found in L2
+    - ``lmcache_mp.l2_prefetch_load_tasks`` — load tasks submitted
+    - ``lmcache_mp.l2_prefetch_load_keys``  — keys submitted for load
+    - ``lmcache_mp.l2_prefetch_loaded_keys`` — keys successfully loaded from L2
+    - ``lmcache_mp.l2_prefetch_failed_keys`` — keys that failed to load
+    """
+
+    def __init__(self) -> None:
+        meter = metrics.get_meter("lmcache.l2")
+
+        # Store counters
+        self._store_tasks = meter.create_counter(
+            "lmcache_mp.l2_store_tasks",
+            description="Total L2 store tasks submitted",
+        )
+        self._store_keys = meter.create_counter(
+            "lmcache_mp.l2_store_keys",
+            description="Total keys submitted for L2 store",
+        )
+        self._store_completed = meter.create_counter(
+            "lmcache_mp.l2_store_completed",
+            description="Total L2 store tasks completed",
+        )
+        self._store_succeeded_keys = meter.create_counter(
+            "lmcache_mp.l2_store_succeeded_keys",
+            description="Total keys successfully stored to L2",
+        )
+        self._store_failed_keys = meter.create_counter(
+            "lmcache_mp.l2_store_failed_keys",
+            description="Total keys that failed to store to L2",
+        )
+
+        # Prefetch counters
+        self._prefetch_lookups = meter.create_counter(
+            "lmcache_mp.l2_prefetch_lookups",
+            description="Total L2 prefetch lookup requests",
+        )
+        self._prefetch_lookup_keys = meter.create_counter(
+            "lmcache_mp.l2_prefetch_lookup_keys",
+            description="Total keys submitted for L2 prefetch lookup",
+        )
+        self._prefetch_hit_keys = meter.create_counter(
+            "lmcache_mp.l2_prefetch_hit_keys",
+            description="Total prefix keys found in L2 lookup",
+        )
+        self._prefetch_load_tasks = meter.create_counter(
+            "lmcache_mp.l2_prefetch_load_tasks",
+            description="Total L2 prefetch load tasks submitted",
+        )
+        self._prefetch_load_keys = meter.create_counter(
+            "lmcache_mp.l2_prefetch_load_keys",
+            description="Total keys submitted for L2 load",
+        )
+        self._prefetch_loaded_keys = meter.create_counter(
+            "lmcache_mp.l2_prefetch_loaded_keys",
+            description="Total keys successfully loaded from L2",
+        )
+        self._prefetch_failed_keys = meter.create_counter(
+            "lmcache_mp.l2_prefetch_failed_keys",
+            description="Total keys that failed to load from L2",
+        )
+
+    def get_subscriptions(self) -> dict[EventType, EventCallback]:
+        return {
+            EventType.L2_STORE_SUBMITTED: self._on_store_submitted,
+            EventType.L2_STORE_COMPLETED: self._on_store_completed,
+            EventType.L2_PREFETCH_LOOKUP_SUBMITTED: self._on_lookup_submitted,
+            EventType.L2_PREFETCH_LOOKUP_COMPLETED: self._on_lookup_completed,
+            EventType.L2_PREFETCH_LOAD_SUBMITTED: self._on_load_submitted,
+            EventType.L2_PREFETCH_LOAD_COMPLETED: self._on_load_completed,
+        }
+
+    def _on_store_submitted(self, event: Event) -> None:
+        self._store_tasks.add(1)
+        self._store_keys.add(event.metadata["key_count"])
+
+    def _on_store_completed(self, event: Event) -> None:
+        self._store_completed.add(1)
+        self._store_succeeded_keys.add(event.metadata["succeeded_count"])
+        self._store_failed_keys.add(event.metadata["failed_count"])
+
+    def _on_lookup_submitted(self, event: Event) -> None:
+        self._prefetch_lookups.add(1)
+        self._prefetch_lookup_keys.add(event.metadata["key_count"])
+
+    def _on_lookup_completed(self, event: Event) -> None:
+        self._prefetch_hit_keys.add(event.metadata["prefix_hit_count"])
+
+    def _on_load_submitted(self, event: Event) -> None:
+        self._prefetch_load_tasks.add(event.metadata["adapter_count"])
+        self._prefetch_load_keys.add(event.metadata["key_count"])
+
+    def _on_load_completed(self, event: Event) -> None:
+        self._prefetch_loaded_keys.add(event.metadata["loaded_count"])
+        self._prefetch_failed_keys.add(event.metadata["failed_count"])