ref(normalization): Add origin and event_type tags to normalization decision (#3764)

S4S processing relays run some normalization and I can't explain why.

Adding these two tags should provide enough clarity:
- `origin`: whether the event is coming from an internal relay.
- `event_type`: the type of the event _before_ normalizing it (i.e. it
could be inaccurate). Could processing relays create transactions and
explain it?

Author: iker-barriocanal

relay-base-schema/src/events.rs

@@ -53,6 +53,23 @@ pub enum EventType {
     Default,
 }
 
+impl EventType {
+    /// Returns the string representation of this event type.
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            EventType::Default => "default",
+            EventType::Error => "error",
+            EventType::Csp => "csp",
+            EventType::Hpkp => "hpkp",
+            EventType::ExpectCt => "expectct",
+            EventType::ExpectStaple => "expectstaple",
+            EventType::Nel => "nel",
+            EventType::Transaction => "transaction",
+            EventType::UserReportV2 => "feedback",
+        }
+    }
+}
+
 /// An error used when parsing `EventType`.
 #[derive(Clone, Copy, Debug)]
 pub struct ParseEventTypeError;
@@ -86,17 +103,7 @@ impl FromStr for EventType {
 
 impl fmt::Display for EventType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {
-            EventType::Default => write!(f, "default"),
-            EventType::Error => write!(f, "error"),
-            EventType::Csp => write!(f, "csp"),
-            EventType::Hpkp => write!(f, "hpkp"),
-            EventType::ExpectCt => write!(f, "expectct"),
-            EventType::ExpectStaple => write!(f, "expectstaple"),
-            EventType::Nel => write!(f, "nel"),
-            EventType::Transaction => write!(f, "transaction"),
-            EventType::UserReportV2 => write!(f, "feedback"),
-        }
+        write!(f, "{}", self.as_str())
     }
 }
 

relay-server/src/services/processor.rs

@@ -1381,11 +1381,23 @@ impl EnvelopeProcessorService {
             .get_item_by(|item| item.attachment_type().is_some())
             .and_then(|item| item.attachment_type())
             .map(|ty| ty.to_string());
+        let event_type = state
+            .event
+            .value()
+            .and_then(|e| e.ty.value())
+            .map(|ty| ty.as_str())
+            .unwrap_or("none");
 
         if !state.has_event() {
             metric!(
                 counter(RelayCounters::NormalizationDecision) += 1,
+                event_type = event_type,
                 attachment_type = attachment_type.as_deref().unwrap_or("none"),
+                origin = if state.envelope().meta().is_from_internal_relay() {
+                    "internal"
+                } else {
+                    "external"
+                },
                 decision = "no_event"
             );
 
@@ -1407,7 +1419,13 @@ impl EnvelopeProcessorService {
                 {
                     metric!(
                         counter(RelayCounters::NormalizationDecision) += 1,
+                        event_type = event_type,
                         attachment_type = attachment_type.as_deref().unwrap_or("none"),
+                        origin = if state.envelope().meta().is_from_internal_relay() {
+                            "internal"
+                        } else {
+                            "external"
+                        },
                         decision = "skip_normalized"
                     );
                     return Ok(());
@@ -1419,7 +1437,13 @@ impl EnvelopeProcessorService {
 
         metric!(
             counter(RelayCounters::NormalizationDecision) += 1,
+            event_type = event_type,
             attachment_type = attachment_type.as_deref().unwrap_or("none"),
+            origin = if state.envelope().meta().is_from_internal_relay() {
+                "internal"
+            } else {
+                "external"
+            },
             decision = if full_normalization {
                 "full_normalization"
             } else {