feat: Metrics tracking for network management

sequence/network_management/network_manager.py

@@ -14,7 +14,8 @@
 
 from ..components.memory import MemoryArray
 from ..message import Message
-from ..utils import log
+from ..utils import log, metrics
+from ..utils.metrics.event_types import EventTypes
 from .forwarding import ForwardingProtocol
 from .memory_timecard import MemoryTimeCard
 from .reservation import Reservation
@@ -226,12 +227,38 @@ def pop(self, msg: RSVPMessage):
         """
         reservation: Reservation = msg.reservation
         if msg.msg_type == RSVPMsgType.APPROVE:
+            metrics.record(
+                EventTypes.RESERVATION_APPROVED,
+                self.owner.name,
+                identity=reservation.identity,
+                initiator=reservation.initiator,
+                responder=reservation.responder,
+                start_time=reservation.start_time,
+                end_time=reservation.end_time,
+                memory_size=reservation.memory_size,
+                entanglement_number=reservation.entanglement_number,
+                target_fidelity=reservation.fidelity,
+                path=list(reservation.path),
+            )
             self.generate_rules(reservation)
             if reservation.initiator == self.owner.name:
                 self.owner.get_reservation_result(reservation, True) # Deliver the result to the Node
             elif reservation.responder == self.owner.name:
                 self.owner.get_other_reservation(reservation)
         elif msg.msg_type == RSVPMsgType.REJECT:
+            metrics.record(
+                EventTypes.RESERVATION_REJECTED,
+                self.owner.name,
+                identity=reservation.identity,
+                initiator=reservation.initiator,
+                responder=reservation.responder,
+                start_time=reservation.start_time,
+                end_time=reservation.end_time,
+                memory_size=reservation.memory_size,
+                entanglement_number=reservation.entanglement_number,
+                target_fidelity=reservation.fidelity,
+                path=[],
+            )
             if reservation.initiator == self.owner.name:
                 self.owner.get_reservation_result(reservation, False)
 

sequence/utils/metrics/__init__.py

@@ -26,18 +26,10 @@
 from .event_types import (
     EventType,
     EventTypes,
-    get_event_type,
     list_event_types,
     register_event_type,
 )
-from .metric_types import (
-    CollectContext,
-    CounterMetric,
-    DeliveryTimeMetric,
-    FidelityMetric,
-    Metric,
-    RateMetric,
-)
+from .metric_types import CollectContext, CounterMetric, DeliveryTimeMetric, FidelityMetric, Metric, ThroughputMetric
 from .registry import (
     clear_registry,
     get_counter,
@@ -131,17 +123,13 @@ def collect_trial_metrics(
     *,
     delivery_owner: str | None = None,
     target_pairs: int | None = None,
-    reservation_start_time: int | None = None,
-    throughput: float | None = None,
 ) -> dict[str, Any]:
     """Collect per-trial metrics for a node from the metrics module.
 
     Args:
         owner_name: Node name to collect counter and fidelity metrics for.
         delivery_owner: Node name used for delivery-time metrics; defaults to `owner_name`.
         target_pairs: Number of delivered pairs required to compute delivery time.
-        reservation_start_time: Simulation time when the reservation started (ps).
-        throughput: Application throughput to include in collected metrics.
 
     Returns:
         Mapping of metric output keys to per-trial values.
@@ -151,15 +139,76 @@ def collect_trial_metrics(
         storage=storage,
         delivery_owner=delivery_owner or owner_name,
         target_pairs=target_pairs,
-        reservation_start_time=reservation_start_time,
-        throughput=throughput,
     )
     result: dict[str, Any] = {}
     for metric in list_metrics():
         result.update(metric.collect(ctx))
     return result
 
 
+def collect_reservation_data(owner_name: str | None = None) -> list[list]:
+    """Collect per-reservation tabular metrics from recorded delivery events."""
+    from collections import defaultdict
+
+    records = storage.get_by_event(EventTypes.DELIVERY)
+    if owner_name is not None:
+        records = [record for record in records if record["owner_name"] == owner_name]
+
+    groups: dict[tuple[str, int], list[dict[str, Any]]] = defaultdict(list)
+    for record in records:
+        groups[(record["owner_name"], record["identity"])].append(record)
+
+    data: list[list] = []
+    for (node, _), deliveries in groups.items():
+        if not deliveries:
+            continue
+        deliveries.sort(key=lambda record: record["sim_time"])
+        timestamps = [record["sim_time"] for record in deliveries]
+        fidelities = [record["fidelity"] for record in deliveries]
+
+        first = deliveries[0]
+        start_time = first["start_time"]
+        end_time = first["end_time"]
+        reserved_time = end_time - start_time
+        served_pairs = len(deliveries)
+        throughput = served_pairs / reserved_time * 1e12 if reserved_time > 0 else 0.0
+        completion_time = timestamps[-1]
+        entanglement_number = first["entanglement_number"]
+        fulfilled = served_pairs == entanglement_number
+        path = first.get("path", [])
+        path_length = len(path)
+        first_pair = timestamps[0]
+        avg_fidelity = mean(fidelities) if fidelities else 0.0
+        std_fidelity = stdev(fidelities) if len(fidelities) > 1 else 0.0
+        durations = [n - c for c, n in zip(timestamps, timestamps[1:])]
+        avg_duration = mean(durations) if durations else 0.0
+        std_duration = stdev(durations) if len(durations) > 1 else 0.0
+
+        data.append(
+            [
+                node,
+                first["identity"],
+                first["initiator"],
+                first["responder"],
+                start_time,
+                end_time,
+                reserved_time,
+                entanglement_number,
+                served_pairs,
+                throughput,
+                completion_time,
+                fulfilled,
+                path_length,
+                first_pair,
+                avg_fidelity,
+                std_fidelity,
+                avg_duration,
+                std_duration,
+            ]
+        )
+    return data
+
+
 def _mean_and_std(values: list[float]) -> tuple[float, float]:
     finite_values = [value for value in values if math.isfinite(value)]
     if not finite_values:
@@ -223,7 +272,6 @@ def aggregate_trial_metrics(
     # From event_types
     "EventType",
     "EventTypes",
-    "get_event_type",
     "list_event_types",
     "register_event_type",
     # From metric_types
@@ -232,7 +280,7 @@ def aggregate_trial_metrics(
     "DeliveryTimeMetric",
     "FidelityMetric",
     "Metric",
-    "RateMetric",
+    "ThroughputMetric",
     # From registry
     "clear_registry",
     "get_counter",

sequence/utils/metrics/builtins.py

@@ -3,15 +3,10 @@
 from __future__ import annotations
 
 from .event_types import EventTypes
-from .metric_types import (
-    CounterMetric,
-    DeliveryTimeMetric,
-    FidelityMetric,
-    Metric,
-    RateMetric,
-)
+from .metric_types import CounterMetric, DeliveryTimeMetric, FidelityMetric, Metric, ThroughputMetric
 from .registry import register_metric
 
+# Entanglement Management Metrics
 EG_METRIC = CounterMetric(
     prefix="eg",
     failure_event=EventTypes.EG_FAILURE,
@@ -24,28 +19,43 @@
     success_event=EventTypes.EP_SUCCESS,
     rate_field="ep_success_rate",
 )
-THROUGHPUT_METRIC = RateMetric(key="app_throughput")
-PURIFIED_FIDELITIES_METRIC = FidelityMetric(
-    key="purified_fidelities",
-    event=EventTypes.EP_SUCCESS,
-    field="fidelity",
-)
-DELIVERY_TIME_METRIC = DeliveryTimeMetric(
-    key="delivery_time",
-    delivery_event=EventTypes.DELIVERY,
-)
 ES_METRIC = CounterMetric(
     prefix="es",
     failure_event=EventTypes.ES_FAILURE,
     success_event=EventTypes.ES_SUCCESS,
     rate_field="es_success_rate",
 )
+PURIFIED_FIDELITIES_METRIC = FidelityMetric(
+    key="purified_fidelities",
+    event=EventTypes.EP_SUCCESS,
+    field="fidelity",
+)
 SWAPPED_FIDELITIES_METRIC = FidelityMetric(
     key="swapped_fidelities",
     event=EventTypes.ES_SUCCESS,
     field="fidelity",
 )
 
+# Network Management Metrics
+RESERVATION_APPROVAL_RATE = CounterMetric(
+    prefix="reservation_approval_rate",
+    failure_event=EventTypes.RESERVATION_REJECTED,
+    success_event=EventTypes.RESERVATION_APPROVED,
+    rate_field="reservation_approval_rate",
+)
+
+# Resource Management Metrics
+
+# Application Metrics
+THROUGHPUT_METRIC = ThroughputMetric(
+    key="app_throughput",
+    delivery_event=EventTypes.DELIVERY,
+)
+DELIVERY_TIME_METRIC = DeliveryTimeMetric(
+    key="delivery_time",
+    delivery_event=EventTypes.DELIVERY,
+)
+
 
 def register_builtin_metrics() -> None:
     """Register all built-in metrics with the global registry.
@@ -57,10 +67,10 @@ def register_builtin_metrics() -> None:
     BUILTIN_METRICS: list[Metric] = [
         EG_METRIC,
         EP_METRIC,
+        ES_METRIC,
         THROUGHPUT_METRIC,
         PURIFIED_FIDELITIES_METRIC,
         DELIVERY_TIME_METRIC,
-        ES_METRIC,
         SWAPPED_FIDELITIES_METRIC,
     ]
 

sequence/utils/metrics/event_types.py

@@ -34,21 +34,6 @@ def register_event_type(name: str) -> EventType:
     return event_type
 
 
-def get_event_type(name: str) -> EventType:
-    """Return a registered event type by name.
-
-    Args:
-        name: Name of the event type to look up.
-
-    Returns:
-        The registered event type.
-    """
-    try:
-        return _registry[name]
-    except KeyError as exc:
-        raise KeyError(f"Event type '{name}' is not registered.") from exc
-
-
 def list_event_types() -> list[EventType]:
     """Return all registered event types.
 
@@ -61,10 +46,30 @@ def list_event_types() -> list[EventType]:
 class EventTypes:
     """Namespace for built-in simulation event types."""
 
+    # Entanglement Management Events
     EG_FAILURE = register_event_type("EG_FAILURE")
     EG_SUCCESS = register_event_type("EG_SUCCESS")
     EP_FAILURE = register_event_type("EP_FAILURE")
     EP_SUCCESS = register_event_type("EP_SUCCESS")
-    DELIVERY = register_event_type("DELIVERY")
     ES_FAILURE = register_event_type("ES_FAILURE")
     ES_SUCCESS = register_event_type("ES_SUCCESS")
+
+    # Network Management Events
+    RESERVATION_APPROVED = register_event_type("RESERVATION_APPROVED")
+    RESERVATION_REJECTED = register_event_type("RESERVATION_REJECTED")
+    RESERVATION_REQUESTED = register_event_type("RESERVATION_REQUESTED")
+    RESERVATION_HOP_REJECT = register_event_type("RESERVATION_HOP_REJECT")
+    RESERVATION_REACHED_RESPONDER = register_event_type("RESERVATION_REACHED_RESPONDER")
+
+    # Forwarding
+    FORWARDING_TABLE_MISS = register_event_type("FORWARDING_TABLE_MISS")
+
+    # Routing
+    NEIGHBOR_DOWN = register_event_type("NEIGHBOR_DOWN")
+    NEIGHBOR_FULL = register_event_type("NEIGHBOR_FULL")
+    ROUTE_RECOMPUTED = register_event_type("ROUTE_RECOMPUTED")
+    LSA_ORIGINATED = register_event_type("LSA_ORIGINATED")
+    LSDB_UPDATED = register_event_type("LSDB_UPDATED")
+
+    # Application Events
+    DELIVERY = register_event_type("DELIVERY")