Add context for errors potentially caused by non self describing types

chmp · Sep 30, 2024 · 55cb727 · 55cb727
1 parent 1132254
commit 55cb727
Show file tree

Hide file tree

Showing 3 changed files with 47 additions and 5 deletions.
diff --git a/serde_arrow/src/internal/error.rs b/serde_arrow/src/internal/error.rs
@@ -135,15 +135,21 @@ impl Error {
             Self::Custom(err) => Some(&err.0.annotations),
         }
     }
+
+    pub(crate) fn modify_message<F: FnOnce(&mut String)>(&mut self, func: F) {
+        let Error::Custom(this) = self;
+        let inner = this.0.as_mut();
+        func(&mut inner.message);
+    }
 }
 
 #[derive(PartialEq)]
 pub struct CustomError(pub(crate) Box<CustomErrorImpl>);
 
 pub struct CustomErrorImpl {
-    message: String,
-    backtrace: Backtrace,
-    cause: Option<Box<dyn std::error::Error + Send + Sync + 'static>>,
+    pub(crate) message: String,
+    pub(crate) backtrace: Backtrace,
+    pub(crate) cause: Option<Box<dyn std::error::Error + Send + Sync + 'static>>,
     pub(crate) annotations: BTreeMap<String, String>,
 }
 

diff --git a/serde_arrow/src/internal/schema/from_type/mod.rs b/serde_arrow/src/internal/schema/from_type/mod.rs
@@ -33,7 +33,30 @@ impl Tracer {
                     budget = tracer.get_options().from_type_budget,
                 );
             }
-            T::deserialize(TraceAny(&mut tracer))?;
+            let res = T::deserialize(TraceAny(&mut tracer));
+            if let Err(err) = res {
+                if !is_non_self_describing_error(err.message()) {
+                    return Err(err);
+                }
+                let mut err = err;
+                err.modify_message(|message| {
+                    *message = format!(
+                        concat!(
+                            "{message}{maybe_period} ",
+                            "It seems that `from_type` encountered a non self describing type. ",
+                            "Consider using `from_samples` instead. ",
+                        ),
+                        message = message,
+                        maybe_period = if message.trim_end().ends_with('.') {
+                            ""
+                        } else {
+                            "."
+                        },
+                    );
+                });
+                return Err(err);
+            }
+
             budget -= 1;
         }
 
@@ -44,6 +67,11 @@ impl Tracer {
     }
 }
 
+// check for known error messages of non self describing types
+fn is_non_self_describing_error(s: &str) -> bool {
+    s.contains("premature end of input")
+}
+
 struct TraceAny<'a>(&'a mut Tracer);
 
 impl<'a> Context for TraceAny<'a> {
@@ -61,7 +89,7 @@ impl<'de, 'a> serde::de::Deserializer<'de> for TraceAny<'a> {
             concat!(
             "Non self describing types cannot be traced with `from_type`. ",
             "Consider using `from_samples`. ",
-            "One example is `serde_json::Value`. ",
+            "One example is `serde_json::Value`: ",
             "the schema depends on the JSON content and cannot be determined from the type alone."
         ));
     }

diff --git a/serde_arrow/src/test/error_messages/trace_from_type.rs b/serde_arrow/src/test/error_messages/trace_from_type.rs
@@ -15,6 +15,10 @@ use crate::{
 fn example() {
     // NOTE: Value cannot be traced with from_type, as it is not self-describing
     let res = SerdeArrowSchema::from_type::<Item<Vec<Value>>>(TracingOptions::default());
+    assert_error_contains(
+        &res,
+        "Non self describing types cannot be traced with `from_type`.",
+    );
     assert_error_contains(&res, "path: \"$.item.element\"");
     assert_error_contains(&res, "tracer_type: \"Unknown\"");
 }
@@ -23,15 +27,19 @@ fn example() {
 fn chrono_types_are_not_self_describing() {
     let res = SerdeArrowSchema::from_type::<Item<DateTime<Utc>>>(TracingOptions::default());
     assert_error_contains(&res, "path: \"$.item\"");
+    assert_error_contains(&res, "non self describing type");
 
     let res = SerdeArrowSchema::from_type::<Item<NaiveDateTime>>(TracingOptions::default());
     assert_error_contains(&res, "path: \"$.item\"");
+    assert_error_contains(&res, "non self describing type");
 
     let res = SerdeArrowSchema::from_type::<Item<NaiveTime>>(TracingOptions::default());
     assert_error_contains(&res, "path: \"$.item\"");
+    assert_error_contains(&res, "non self describing type");
 
     let res = SerdeArrowSchema::from_type::<Item<NaiveDate>>(TracingOptions::default());
     assert_error_contains(&res, "path: \"$.item\"");
+    assert_error_contains(&res, "non self describing type");
 }
 
 #[test]