Clean up of ReplayError messages

Author: arjunr2

crates/wasmtime/src/runtime/component/func/options.rs

@@ -635,7 +635,9 @@ impl<'a, T: 'static> LowerContext<'a, T> {
                 RREvent::ComponentLowerFlatReturn(e) => {
                     #[cfg(feature = "rr-validate")]
                     if run_validate {
-                        _lower_stack.pop().ok_or(ReplayError::InvalidOrdering)?;
+                        _lower_stack
+                            .pop()
+                            .ok_or(ReplayError::InvalidEventPosition)?;
                     }
                     lowering_error = e.0.ret().map_err(Into::into).err();
                 }
@@ -644,7 +646,7 @@ impl<'a, T: 'static> LowerContext<'a, T> {
                     if run_validate {
                         _lower_store_stack
                             .pop()
-                            .ok_or(ReplayError::InvalidOrdering)?;
+                            .ok_or(ReplayError::InvalidEventPosition)?;
                     }
                     lowering_error = e.0.ret().map_err(Into::into).err();
                 }

crates/wasmtime/src/runtime/rr/core.rs

@@ -3,6 +3,7 @@ use crate::prelude::*;
 use core::fmt;
 use events::EventError;
 use serde::{Deserialize, Serialize};
+use wasmtime_environ::EntityIndex;
 // Use component events internally even without feature flags enabled
 // so that [`RREvent`] has a well-defined serialization format, but export
 // it for other modules only when enabled
@@ -198,12 +199,14 @@ pub enum ReplayError {
     EmptyBuffer,
     FailedValidation,
     IncorrectEventVariant,
-    InvalidOrdering,
+    InvalidEventPosition,
     FailedRead(IOError),
     EventError(Box<dyn EventError>),
-    MissingComponentOrModule,
-    MissingComponentOrModuleInstance,
-    IncorrectCoreFuncIndex,
+    MissingComponent([u8; 32]),
+    MissingModule([u8; 32]),
+    MissingComponentInstance(u32),
+    MissingModuleInstance(u32),
+    InvalidCoreFuncIndex(EntityIndex),
 }
 
 impl fmt::Display for ReplayError {
@@ -213,10 +216,13 @@ impl fmt::Display for ReplayError {
                 write!(f, "replay buffer is empty")
             }
             Self::FailedValidation => {
-                write!(f, "replay event validation failed")
+                write!(
+                    f,
+                    "failed validation check during replay; see wasmtime log for error"
+                )
             }
             Self::IncorrectEventVariant => {
-                write!(f, "event method invoked on incorrect variant")
+                write!(f, "event type mismatch during replay")
             }
             Self::EventError(e) => {
                 write!(f, "{:?}", e)
@@ -225,17 +231,37 @@ impl fmt::Display for ReplayError {
                 write!(f, "{}", e)?;
                 f.write_str("Note: Ensure sufficient `deserialization-buffer-size` in replay settings if you included `validation-metadata` during recording")
             }
-            Self::InvalidOrdering => {
+            Self::InvalidEventPosition => {
                 write!(f, "event occured at an invalid position in the trace")
             }
-            Self::MissingComponentOrModule => {
-                write!(f, "missing component or module for replay")
+            Self::MissingComponent(checksum) => {
+                write!(
+                    f,
+                    "missing component binary with checksum 0x{} during replay",
+                    checksum
+                        .iter()
+                        .map(|b| format!("{:02x}", b))
+                        .collect::<String>()
+                )
             }
-            Self::MissingComponentOrModuleInstance => {
-                write!(f, "missing component or module instance for replay")
+            Self::MissingModule(checksum) => {
+                write!(
+                    f,
+                    "missing module binary with checksum {:02x?} during replay",
+                    checksum
+                        .iter()
+                        .map(|b| format!("{:02x}", b))
+                        .collect::<String>()
+                )
             }
-            Self::IncorrectCoreFuncIndex => {
-                write!(f, "incorrect core function index encountered during replay")
+            Self::MissingComponentInstance(id) => {
+                write!(f, "missing component instance ID {:?} during replay", id)
+            }
+            Self::MissingModuleInstance(id) => {
+                write!(f, "missing module instance ID {:?} during replay", id)
+            }
+            Self::InvalidCoreFuncIndex(index) => {
+                write!(f, "replay core func ({:?}) during replay is invalid", index)
             }
         }
     }
@@ -306,9 +332,6 @@ pub trait Replayer: Iterator<Item = Result<RREvent, ReplayError>> {
     /// Get the settings (embedded within the trace) during recording
     fn trace_settings(&self) -> &RecordSettings;
 
-    ///// Peek at the next event without consuming it
-    //fn peek(&mut self) -> Option<Result<&RREvent, ReplayError>>;
-
     // Provided Methods
 
     /// Get the next functional replay event (skips past all non-marker events)
@@ -458,8 +481,6 @@ pub struct ReplayBuffer {
     deser_buffer: Vec<u8>,
     /// Whether buffer has been completely read
     eof_encountered: bool,
-    /// Peeked event for lookahead
-    peeked: Option<RREvent>,
 }
 
 impl Iterator for ReplayBuffer {
@@ -469,9 +490,6 @@ impl Iterator for ReplayBuffer {
         if self.eof_encountered {
             return None;
         }
-        if self.peeked.is_some() {
-            return self.peeked.take().map(Ok);
-        }
         let ret = 'event_loop: loop {
             let result = io::from_replay_reader(&mut self.reader, &mut self.deser_buffer);
             match result {
@@ -499,17 +517,17 @@ impl Drop for ReplayBuffer {
         let mut remaining_events = 0;
         log::info!("Replay buffer is being dropped; checking for remaining replay events...");
         // Cannot use count() in iterator because IO error may loop indefinitely
-        while let Some(event) = self.next() {
-            event.unwrap();
+        while let Some(e) = self.next() {
+            e.unwrap();
             remaining_events += 1;
         }
         if remaining_events > 0 {
             log::warn!(
-                "{} events were remaining in the replay buffer. This is likely the result of an erroneous/incomplete execution",
+                "{} events were not used in the replay buffer. This is likely the result of an erroneous/incomplete execution",
                 remaining_events
             );
         } else {
-            log::info!("All replay events were successfully processed.");
+            log::debug!("All replay events were successfully processed.");
         }
     }
 }
@@ -546,7 +564,6 @@ impl Replayer for ReplayBuffer {
             trace_settings,
             deser_buffer,
             eof_encountered: false,
-            peeked: None,
         })
     }
 
@@ -559,14 +576,6 @@ impl Replayer for ReplayBuffer {
     fn trace_settings(&self) -> &RecordSettings {
         &self.trace_settings
     }
-
-    //#[inline]
-    //fn peek(&mut self) -> Option<Result<&RREvent, ReplayError>> {
-    //    if self.peeked.is_none() {
-    //        self.peeked = self.next();
-    //    }
-    //    self.peeked.as_ref().map(|r| Ok(r))
-    //}
 }
 
 #[cfg(test)]

crates/wasmtime/src/runtime/rr/replay_driver.rs

@@ -120,7 +120,7 @@ impl<'a> ReplayInstance<'a> {
                         let component = self
                             .components
                             .get(&event.0)
-                            .ok_or(ReplayError::MissingComponentOrModule)?;
+                            .ok_or(ReplayError::MissingComponent(event.0))?;
 
                         let instance = self
                             .component_linker
@@ -151,7 +151,7 @@ impl<'a> ReplayInstance<'a> {
                         let instance = self
                             .component_instances
                             .get_mut(&key)
-                            .ok_or(ReplayError::MissingComponentOrModuleInstance)?;
+                            .ok_or(ReplayError::MissingComponentInstance(key.1.as_u32()))?;
 
                         // Replay lowering steps and obtain raw value arguments to raw function call
                         let func = component::Func::from_lifted_func(*instance, event.func_idx);
@@ -202,7 +202,7 @@ impl<'a> ReplayInstance<'a> {
                     let module = self
                         .modules
                         .get(&event.0)
-                        .ok_or(ReplayError::MissingComponentOrModule)?;
+                        .ok_or(ReplayError::MissingModule(event.0))?;
 
                     let instance = self
                         .module_linker
@@ -224,14 +224,14 @@ impl<'a> ReplayInstance<'a> {
                     let instance = self
                         .module_instances
                         .get_mut(&key)
-                        .ok_or(ReplayError::MissingComponentOrModule)?;
+                        .ok_or(ReplayError::MissingModuleInstance(key.1.as_u32()))?;
 
                     let entity = EntityIndex::from(event.origin.index);
                     let mut store = self.store.as_context_mut();
                     let func = instance
                         ._get_export(store.0, entity)
                         .into_func()
-                        .ok_or(ReplayError::IncorrectCoreFuncIndex)?;
+                        .ok_or(ReplayError::InvalidCoreFuncIndex(entity))?;
 
                     let params_ty = func.ty(&store).params().collect::<Vec<ValType>>();