ref(general): Streamline the use of lenient and JSON strings

Author: jan-auer

general/src/protocol/logentry.rs

@@ -1,4 +1,4 @@
-use crate::protocol::LenientString;
+use crate::protocol::JsonLenientString;
 use crate::types::{Annotated, Array, FromValue, Object, Value};
 
 /// A log entry message.
@@ -32,7 +32,7 @@ impl FromValue for LogEntry {
         // add the former as the 'formatted' attribute of the latter.
         // See GH-3248
         match value {
-            x @ Annotated(Some(Value::Object(_)), _) | x @ Annotated(None, _) => {
+            x @ Annotated(Some(Value::Object(_)), _) => {
                 #[derive(Debug, FromValue)]
                 struct Helper {
                     message: Annotated<String>,
@@ -56,9 +56,13 @@ impl FromValue for LogEntry {
                     },
                 )
             }
+            Annotated(None, meta) => Annotated(None, meta),
+            // The next two cases handle the legacy top-level `message` attribute, which was sent as
+            // literal string, false (which should be ignored) or even as deep JSON object. Sentry
+            // historically JSONified this field.
             Annotated(Some(Value::Bool(false)), _) => Annotated(None, Default::default()),
             x => Annotated::new(LogEntry {
-                formatted: LenientString::from_value(x).map_value(|x| x.into_inner()),
+                formatted: JsonLenientString::from_value(x).map_value(|x| x.into_inner()),
                 ..Default::default()
             }),
         }

general/src/protocol/types.rs

@@ -594,8 +594,10 @@ impl FromValue for JsonLenientString {
     fn from_value(value: Annotated<Value>) -> Annotated<Self> {
         match value {
             Annotated(Some(Value::String(string)), meta) => Annotated(Some(string.into()), meta),
+            Annotated(Some(other), meta) => {
+                Annotated(Some(serde_json::to_string(&other).unwrap().into()), meta)
+            }
             Annotated(None, meta) => Annotated(None, meta),
-            x => Annotated(Some(x.payload_to_json().unwrap().into()), x.1),
         }
     }
 }

general/src/protocol/user.rs

@@ -1,4 +1,4 @@
-use crate::protocol::{IpAddr, JsonLenientString};
+use crate::protocol::{IpAddr, LenientString};
 use crate::types::{Annotated, Object, Value};
 
 /// Geographical location of the end user or device.
@@ -28,7 +28,7 @@ pub struct Geo {
 pub struct User {
     /// Unique identifier of the user.
     #[metastructure(pii = "true", max_chars = "enumlike")]
-    pub id: Annotated<JsonLenientString>,
+    pub id: Annotated<LenientString>,
 
     /// Email address of the user.
     #[metastructure(pii = "true", max_chars = "email", match_regex = r"@")]
@@ -143,6 +143,34 @@ fn test_user_roundtrip() {
     assert_eq_str!(json, user.to_json_pretty().unwrap());
 }
 
+#[test]
+fn test_user_lenient_id() {
+    let input = r#"{"id":42}"#;
+    let output = r#"{"id":"42"}"#;
+    let user = Annotated::new(User {
+        id: Annotated::new("42".to_string().into()),
+        ..User::default()
+    });
+
+    assert_eq_dbg!(user, Annotated::from_json(input).unwrap());
+    assert_eq_str!(output, user.to_json().unwrap());
+}
+
+#[test]
+fn test_user_invalid_id() {
+    use crate::types::Error;
+    let json = r#"{"id":[]}"#;
+    let user = Annotated::new(User {
+        id: Annotated::from_error(
+            Error::expected("primitive value"),
+            Some(Value::Array(vec![])),
+        ),
+        ..User::default()
+    });
+
+    assert_eq_dbg!(user, Annotated::from_json(json).unwrap());
+}
+
 #[test]
 fn test_explicit_none() {
     let json = r#"{