use std::fmt; use crate::{OwnedRgba8888Frame, RenderSubmission}; /// Typed failure surface for the real render worker and its backend. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum RenderWorkerError { BackendUnavailable, RenderFailed, PublishFailed, PresentFailed, ShutdownTimeout, StaleSubmissionDiscarded, WorkerPanic, InternalFailure, } impl fmt::Display for RenderWorkerError { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { Self::BackendUnavailable => f.write_str("render backend unavailable"), Self::RenderFailed => f.write_str("render failed"), Self::PublishFailed => f.write_str("render publish failed"), Self::PresentFailed => f.write_str("render present failed"), Self::ShutdownTimeout => f.write_str("render worker shutdown timed out"), Self::StaleSubmissionDiscarded => f.write_str("stale render submission discarded"), Self::WorkerPanic => f.write_str("render worker panicked"), Self::InternalFailure => f.write_str("internal render worker failure"), } } } impl std::error::Error for RenderWorkerError {} pub trait RenderWorkerBackend: Send + 'static { fn render( &self, submission: &RenderSubmission, ) -> Result; } pub trait RenderWorkerFrameSink: Send + 'static { fn publish(&self, frame: OwnedRgba8888Frame) -> Result<(), RenderWorkerError>; } /// Snapshot of render worker handoff, render, publish, and shutdown counters. #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)] pub struct RenderWorkerTelemetry { pub produced_submissions: u64, pub replaced_before_consume: u64, pub consumed_submissions: u64, pub published_frames: u64, pub presented_frames: u64, pub repeated_frames: u64, pub stale_submission_discards: u64, pub render_failures: u64, pub publish_failures: u64, pub present_failures: u64, pub shutdown_timeouts: u64, pub worker_panics: u64, pub last_produced_frame_id: u64, pub last_consumed_frame_id: u64, pub last_published_frame_id: u64, pub last_presented_frame_id: u64, pub last_dropped_frame_id: u64, pub last_error_frame_id: u64, pub active_render_epoch: u64, } impl RenderWorkerTelemetry { pub fn record_produced(&mut self, frame_id: u64) { self.produced_submissions += 1; self.last_produced_frame_id = frame_id; } pub fn record_replaced_before_consume(&mut self, frame_id: u64) { self.replaced_before_consume += 1; self.last_dropped_frame_id = frame_id; } pub fn record_consumed(&mut self, frame_id: u64) { self.consumed_submissions += 1; self.last_consumed_frame_id = frame_id; } pub fn record_published(&mut self, frame_id: u64) { self.published_frames += 1; self.last_published_frame_id = frame_id; } pub fn record_presented(&mut self, frame_id: u64) { self.presented_frames += 1; self.last_presented_frame_id = frame_id; } pub fn record_repeated_frame(&mut self, frame_id: u64) { self.repeated_frames += 1; self.last_presented_frame_id = frame_id; } pub fn record_stale_submission_discarded(&mut self, frame_id: u64) { self.stale_submission_discards += 1; self.last_dropped_frame_id = frame_id; } pub fn record_error(&mut self, error: RenderWorkerError, frame_id: u64) { match error { RenderWorkerError::BackendUnavailable | RenderWorkerError::RenderFailed => { self.render_failures += 1; } RenderWorkerError::PublishFailed => { self.publish_failures += 1; } RenderWorkerError::PresentFailed => { self.present_failures += 1; } RenderWorkerError::ShutdownTimeout => { self.shutdown_timeouts += 1; } RenderWorkerError::WorkerPanic => { self.worker_panics += 1; } RenderWorkerError::StaleSubmissionDiscarded => { self.stale_submission_discards += 1; self.last_dropped_frame_id = frame_id; } RenderWorkerError::InternalFailure => { self.render_failures += 1; } } self.last_error_frame_id = frame_id; } } #[cfg(test)] mod tests { use super::*; #[test] fn render_worker_error_is_copy_equatable_and_debuggable() { let error = RenderWorkerError::ShutdownTimeout; let copied = error; assert_eq!(copied, RenderWorkerError::ShutdownTimeout); assert_eq!(format!("{:?}", error), "ShutdownTimeout"); assert_eq!(error.to_string(), "render worker shutdown timed out"); } #[test] fn render_worker_telemetry_defaults_to_zero() { assert_eq!( RenderWorkerTelemetry::default(), RenderWorkerTelemetry { produced_submissions: 0, replaced_before_consume: 0, consumed_submissions: 0, published_frames: 0, presented_frames: 0, repeated_frames: 0, stale_submission_discards: 0, render_failures: 0, publish_failures: 0, present_failures: 0, shutdown_timeouts: 0, worker_panics: 0, last_produced_frame_id: 0, last_consumed_frame_id: 0, last_published_frame_id: 0, last_presented_frame_id: 0, last_dropped_frame_id: 0, last_error_frame_id: 0, active_render_epoch: 0, } ); } #[test] fn render_worker_telemetry_records_counters_and_frame_ids() { let mut telemetry = RenderWorkerTelemetry::default(); telemetry.record_produced(10); telemetry.record_replaced_before_consume(10); telemetry.record_consumed(11); telemetry.record_published(11); telemetry.record_presented(11); telemetry.record_repeated_frame(11); telemetry.record_error(RenderWorkerError::PublishFailed, 12); telemetry.record_error(RenderWorkerError::WorkerPanic, 13); telemetry.record_stale_submission_discarded(14); assert_eq!(telemetry.produced_submissions, 1); assert_eq!(telemetry.replaced_before_consume, 1); assert_eq!(telemetry.consumed_submissions, 1); assert_eq!(telemetry.published_frames, 1); assert_eq!(telemetry.presented_frames, 1); assert_eq!(telemetry.repeated_frames, 1); assert_eq!(telemetry.publish_failures, 1); assert_eq!(telemetry.worker_panics, 1); assert_eq!(telemetry.stale_submission_discards, 1); assert_eq!(telemetry.last_error_frame_id, 13); assert_eq!(telemetry.last_dropped_frame_id, 14); } }