Enum TelemetryEvent 

pub enum TelemetryEvent {
    MetricUpdate {
        id: MetricId,
        value: MetricValue,
    },
    ResourceReport(ResourceUsageReport),
    HardwareReport(HardwareReport),
    GpuReport(GpuReport),
    PhaseChange(String),
    AgentCost {
        id: AgentId,
        n: f64,
        time_ms: f64,
    },
    WavePlan {
        waves: Vec<Vec<AgentId>>,
    },
    ComponentAccess {
        type_name: String,
        size_bytes: usize,
        query_count: u64,
        rows_scanned: u64,
    },
}

A high-level telemetry event produced by the Hot Path or hardware sensors.

Variants

MetricUpdate

A single metric sample update.

Fields

id: MetricId

The metric identifier.

value: MetricValue

The new value.

ResourceReport(ResourceUsageReport)

A hardware resource usage report (typically bytes/memory).

HardwareReport(HardwareReport)

A physical hardware health report (thermal, CPU load).

GpuReport(GpuReport)

A GPU performance report (frame timings, draw calls, triangles).

PhaseChange(String)

A change in the execution phase signaled by the engine.

AgentCost

A per-agent execution-cost sample: the workload size n an agent processed this frame and the wall-clock time it took. The DCC feeds these to a per-agent cost model (c·f(n)) so it can forecast a budget breach (“at this growth rate the frame budget breaks at ~N”) instead of only reacting. Published once per agent per frame from the hot path.

Fields

id: AgentId

The agent that produced the sample.

n: f64

Workload size processed this frame (e.g. live entity count).

time_ms: f64

Wall-clock execution time, in milliseconds.

WavePlan

The scheduler’s per-frame wave plan: how the agents will actually be grouped for execution. Each inner list is one wave — agents that run concurrently (an Isolated set plus at most one SharedWorld agent); a singleton list is a serially-executed agent. Published only when parallel execution is enabled (serial execution needs no grouping — the DCC then falls back to summing per-agent costs).

The DCC uses it to cost a concurrent wave by its critical path (max of its members) instead of the sum, so budget fitting doesn’t leave frame time on the table for work that overlaps.

Fields

waves: Vec<Vec<AgentId>>

Agent ids grouped by wave, in execution order.

ComponentAccess

A per-component access-pattern snapshot from the ECS, for the layout advisor (AGDF). Cumulative counters, sampled at a low rate (not every frame); the DCC turns them into a read-only layout recommendation.

Fields

type_name: String

Component type name (for the glass-box report).

size_bytes: usize

Component size in bytes (size_of).

query_count: u64

Cumulative number of queries that touched this component.

rows_scanned: u64

Cumulative rows scanned across those queries.

Trait Implementations

impl Clone for TelemetryEvent

fn clone(&self) -> TelemetryEvent

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TelemetryEvent

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.