core: Classify StoreError as non/deterministic

Author: lutter

core/src/subgraph/error.rs

@@ -1,10 +1,15 @@
 use graph::data::subgraph::schema::SubgraphError;
-use graph::prelude::{thiserror, Error, StoreError};
+use graph::env::ENV_VARS;
+use graph::prelude::{anyhow, thiserror, Error, StoreError};
 
 pub trait DeterministicError: std::fmt::Debug + std::fmt::Display + Send + Sync + 'static {}
 
 impl DeterministicError for SubgraphError {}
 
+impl DeterministicError for StoreError {}
+
+impl DeterministicError for anyhow::Error {}
+
 /// An error happened during processing and we need to classify errors into
 /// deterministic and non-deterministic errors. This struct holds the result
 /// of that classification
@@ -26,7 +31,34 @@ impl ProcessingError {
     pub fn is_deterministic(&self) -> bool {
         matches!(self, ProcessingError::Deterministic(_))
     }
+
+    pub fn detail(self, ctx: &str) -> ProcessingError {
+        match self {
+            ProcessingError::Unknown(e) => {
+                let x = e.context(ctx.to_string());
+                ProcessingError::Unknown(x)
+            }
+            ProcessingError::Deterministic(e) => {
+                ProcessingError::Deterministic(Box::new(anyhow!("{e}").context(ctx.to_string())))
+            }
+            ProcessingError::Canceled => ProcessingError::Canceled,
+        }
+    }
 }
+
+/// Similar to `anyhow::Context`, but for `Result<T, ProcessingError>`. We
+/// call the method `detail` to avoid ambiguity with anyhow's `context`
+/// method
+pub trait DetailHelper<T, E> {
+    fn detail(self: Self, ctx: &str) -> Result<T, ProcessingError>;
+}
+
+impl<T> DetailHelper<T, ProcessingError> for Result<T, ProcessingError> {
+    fn detail(self, ctx: &str) -> Result<T, ProcessingError> {
+        self.map_err(|e| e.detail(ctx))
+    }
+}
+
 /// Implement this for errors that are always non-deterministic.
 pub(crate) trait NonDeterministicErrorHelper<T, E> {
     fn non_deterministic(self: Self) -> Result<T, ProcessingError>;
@@ -43,3 +75,26 @@ impl<T> NonDeterministicErrorHelper<T, StoreError> for Result<T, StoreError> {
         self.map_err(|e| ProcessingError::Unknown(Error::from(e)))
     }
 }
+
+/// Implement this for errors where it depends on the details whether they
+/// are deterministic or not.
+pub(crate) trait ClassifyErrorHelper<T, E> {
+    fn classify(self: Self) -> Result<T, ProcessingError>;
+}
+
+impl<T> ClassifyErrorHelper<T, StoreError> for Result<T, StoreError> {
+    fn classify(self) -> Result<T, ProcessingError> {
+        self.map_err(|e| {
+            if ENV_VARS.mappings.store_errors_are_nondeterministic {
+                // Old behavior, just in case the new behavior causes issues
+                ProcessingError::Unknown(Error::from(e))
+            } else {
+                if e.is_deterministic() {
+                    ProcessingError::Deterministic(Box::new(e))
+                } else {
+                    ProcessingError::Unknown(Error::from(e))
+                }
+            }
+        })
+    }
+}

core/src/subgraph/runner.rs

@@ -1,5 +1,7 @@
 use crate::subgraph::context::IndexingContext;
-use crate::subgraph::error::{NonDeterministicErrorHelper as _, ProcessingError};
+use crate::subgraph::error::{
+    ClassifyErrorHelper as _, DetailHelper as _, NonDeterministicErrorHelper as _, ProcessingError,
+};
 use crate::subgraph::inputs::IndexingInputs;
 use crate::subgraph::state::IndexingState;
 use crate::subgraph::stream::new_block_stream;
@@ -746,7 +748,8 @@ where
                 is_caught_up,
             )
             .await
-            .non_deterministic()?;
+            .classify()
+            .detail("Failed to transact block operations")?;
 
         // For subgraphs with `nonFatalErrors` feature disabled, we consider
         // any error as fatal.
@@ -1476,8 +1479,8 @@ where
                 is_caught_up,
             )
             .await
-            .context("Failed to transact block operations")
-            .non_deterministic()?;
+            .classify()
+            .detail("Failed to transact block operations")?;
 
         // For subgraphs with `nonFatalErrors` feature disabled, we consider
         // any error as fatal.