ref: Move attributes out of ourlogs (#4715)

No functional changes. This is in preparation for introducing Spans V2,
which will use these types as well.

#skip-changelog

ref: RELAY-62

Author: loewenheim

relay-event-schema/src/protocol/attributes.rs

@@ -0,0 +1,125 @@
+use relay_protocol::{Annotated, Empty, FromValue, IntoValue, Object, SkipSerialization, Value};
+use std::fmt;
+
+use crate::processor::ProcessValue;
+
+#[derive(Clone, PartialEq, Empty, FromValue, IntoValue, ProcessValue)]
+pub struct Attribute {
+    #[metastructure(flatten)]
+    pub value: AttributeValue,
+
+    /// Additional arbitrary fields for forwards compatibility.
+    #[metastructure(additional_properties)]
+    pub other: Object<Value>,
+}
+
+impl Attribute {
+    pub fn new(attribute_type: AttributeType, value: Value) -> Self {
+        Self {
+            value: AttributeValue {
+                ty: Annotated::new(attribute_type),
+                value: Annotated::new(value),
+            },
+            other: Object::new(),
+        }
+    }
+}
+
+impl fmt::Debug for Attribute {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Attribute")
+            .field("value", &self.value.value)
+            .field("type", &self.value.ty)
+            .field("other", &self.other)
+            .finish()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Empty, FromValue, IntoValue, ProcessValue)]
+pub struct AttributeValue {
+    #[metastructure(field = "type", required = true, trim = false)]
+    pub ty: Annotated<AttributeType>,
+    #[metastructure(required = true, pii = "true")]
+    pub value: Annotated<Value>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum AttributeType {
+    Boolean,
+    Integer,
+    Double,
+    String,
+    Unknown(String),
+}
+
+impl ProcessValue for AttributeType {}
+
+impl AttributeType {
+    pub fn as_str(&self) -> &str {
+        match self {
+            Self::Boolean => "boolean",
+            Self::Integer => "integer",
+            Self::Double => "double",
+            Self::String => "string",
+            Self::Unknown(value) => value,
+        }
+    }
+
+    pub fn unknown_string() -> String {
+        "unknown".to_string()
+    }
+}
+
+impl fmt::Display for AttributeType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+impl From<String> for AttributeType {
+    fn from(value: String) -> Self {
+        match value.as_str() {
+            "boolean" => Self::Boolean,
+            "integer" => Self::Integer,
+            "double" => Self::Double,
+            "string" => Self::String,
+            _ => Self::Unknown(value),
+        }
+    }
+}
+
+impl Empty for AttributeType {
+    #[inline]
+    fn is_empty(&self) -> bool {
+        false
+    }
+}
+
+impl FromValue for AttributeType {
+    fn from_value(value: Annotated<Value>) -> Annotated<Self> {
+        match String::from_value(value) {
+            Annotated(Some(value), meta) => Annotated(Some(value.into()), meta),
+            Annotated(None, meta) => Annotated(None, meta),
+        }
+    }
+}
+
+impl IntoValue for AttributeType {
+    fn into_value(self) -> Value
+    where
+        Self: Sized,
+    {
+        Value::String(match self {
+            Self::Unknown(s) => s,
+            s => s.to_string(),
+        })
+    }
+
+    fn serialize_payload<S>(&self, s: S, _behavior: SkipSerialization) -> Result<S::Ok, S::Error>
+    where
+        Self: Sized,
+        S: serde::Serializer,
+    {
+        serde::ser::Serialize::serialize(self.as_str(), s)
+    }
+}

relay-event-schema/src/protocol/mod.rs

@@ -1,5 +1,6 @@
 //! Implements the sentry event protocol.
 
+mod attributes;
 mod base;
 mod breadcrumb;
 mod breakdowns;
@@ -38,6 +39,7 @@ mod utils;
 #[doc(inline)]
 pub use relay_base_schema::{events::*, spans::*};
 
+pub use self::attributes::*;
 pub use self::breadcrumb::*;
 pub use self::breakdowns::*;
 pub use self::client_report::*;

relay-event-schema/src/protocol/ourlog.rs

@@ -4,7 +4,7 @@ use std::fmt::{self, Display};
 use serde::{Serialize, Serializer};
 
 use crate::processor::ProcessValue;
-use crate::protocol::{SpanId, Timestamp, TraceId};
+use crate::protocol::{Attribute, SpanId, Timestamp, TraceId};
 
 #[derive(Clone, Debug, Default, PartialEq, Empty, FromValue, IntoValue, ProcessValue)]
 #[metastructure(process_func = "process_ourlog", value_type = "OurLog")]
@@ -31,7 +31,7 @@ pub struct OurLog {
 
     /// Arbitrary attributes on a log.
     #[metastructure(pii = "true", trim = false)]
-    pub attributes: Annotated<Object<OurLogAttribute>>,
+    pub attributes: Annotated<Object<Attribute>>,
 
     /// Additional arbitrary fields for forwards compatibility.
     #[metastructure(additional_properties, retain = true, pii = "maybe")]
@@ -44,127 +44,6 @@ impl OurLog {
     }
 }
 
-#[derive(Clone, PartialEq, Empty, FromValue, IntoValue, ProcessValue)]
-pub struct OurLogAttribute {
-    #[metastructure(flatten)]
-    pub value: OurLogAttributeValue,
-
-    /// Additional arbitrary fields for forwards compatibility.
-    #[metastructure(additional_properties)]
-    pub other: Object<Value>,
-}
-
-impl OurLogAttribute {
-    pub fn new(attribute_type: OurLogAttributeType, value: Value) -> Self {
-        Self {
-            value: OurLogAttributeValue {
-                ty: Annotated::new(attribute_type),
-                value: Annotated::new(value),
-            },
-            other: Object::new(),
-        }
-    }
-}
-
-impl fmt::Debug for OurLogAttribute {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("OurLogAttribute")
-            .field("value", &self.value.value)
-            .field("type", &self.value.ty)
-            .field("other", &self.other)
-            .finish()
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Empty, FromValue, IntoValue, ProcessValue)]
-pub struct OurLogAttributeValue {
-    #[metastructure(field = "type", required = true, trim = false)]
-    pub ty: Annotated<OurLogAttributeType>,
-    #[metastructure(required = true, pii = "true")]
-    pub value: Annotated<Value>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum OurLogAttributeType {
-    Boolean,
-    Integer,
-    Double,
-    String,
-    Unknown(String),
-}
-
-impl ProcessValue for OurLogAttributeType {}
-
-impl OurLogAttributeType {
-    pub fn as_str(&self) -> &str {
-        match self {
-            Self::Boolean => "boolean",
-            Self::Integer => "integer",
-            Self::Double => "double",
-            Self::String => "string",
-            Self::Unknown(value) => value,
-        }
-    }
-
-    pub fn unknown_string() -> String {
-        "unknown".to_string()
-    }
-}
-
-impl fmt::Display for OurLogAttributeType {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.as_str())
-    }
-}
-
-impl From<String> for OurLogAttributeType {
-    fn from(value: String) -> Self {
-        match value.as_str() {
-            "boolean" => Self::Boolean,
-            "integer" => Self::Integer,
-            "double" => Self::Double,
-            "string" => Self::String,
-            _ => Self::Unknown(value),
-        }
-    }
-}
-
-impl Empty for OurLogAttributeType {
-    #[inline]
-    fn is_empty(&self) -> bool {
-        false
-    }
-}
-
-impl FromValue for OurLogAttributeType {
-    fn from_value(value: Annotated<Value>) -> Annotated<Self> {
-        match String::from_value(value) {
-            Annotated(Some(value), meta) => Annotated(Some(value.into()), meta),
-            Annotated(None, meta) => Annotated(None, meta),
-        }
-    }
-}
-
-impl IntoValue for OurLogAttributeType {
-    fn into_value(self) -> Value
-    where
-        Self: Sized,
-    {
-        Value::String(match self {
-            Self::Unknown(s) => s,
-            s => s.to_string(),
-        })
-    }
-
-    fn serialize_payload<S>(&self, s: S, _behavior: SkipSerialization) -> Result<S::Ok, S::Error>
-    where
-        Self: Sized,
-        S: serde::Serializer,
-    {
-        serde::ser::Serialize::serialize(self.as_str(), s)
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum OurLogLevel {
     Trace,
@@ -289,7 +168,7 @@ mod tests {
         }"#;
 
         let data = Annotated::<OurLog>::from_json(json).unwrap();
-        insta::assert_debug_snapshot!(data, @r#"
+        insta::assert_debug_snapshot!(data, @r###"
         OurLog {
             timestamp: Timestamp(
                 2018-12-13T16:51:00Z,
@@ -301,49 +180,49 @@ mod tests {
             level: Info,
             body: "Example log record",
             attributes: {
-                "boolean.attribute": OurLogAttribute {
+                "boolean.attribute": Attribute {
                     value: Bool(
                         true,
                     ),
                     type: Boolean,
                     other: {},
                 },
-                "double.attribute": OurLogAttribute {
+                "double.attribute": Attribute {
                     value: F64(
                         1.23,
                     ),
                     type: Double,
                     other: {},
                 },
-                "sentry.observed_timestamp_nanos": OurLogAttribute {
+                "sentry.observed_timestamp_nanos": Attribute {
                     value: String(
                         "1544712660300000000",
                     ),
                     type: Integer,
                     other: {},
                 },
-                "sentry.severity_number": OurLogAttribute {
+                "sentry.severity_number": Attribute {
                     value: String(
                         "10",
                     ),
                     type: Integer,
                     other: {},
                 },
-                "sentry.severity_text": OurLogAttribute {
+                "sentry.severity_text": Attribute {
                     value: String(
                         "info",
                     ),
                     type: String,
                     other: {},
                 },
-                "sentry.trace_flags": OurLogAttribute {
+                "sentry.trace_flags": Attribute {
                     value: String(
                         "10",
                     ),
                     type: Integer,
                     other: {},
                 },
-                "string.attribute": OurLogAttribute {
+                "string.attribute": Attribute {
                     value: String(
                         "some string",
                     ),
@@ -353,7 +232,7 @@ mod tests {
             },
             other: {},
         }
-        "#);
+        "###);
 
         insta::assert_json_snapshot!(SerializableAnnotated(&data), @r###"
         {