feat(feedback): add User Feedbacks as Events

CHANGELOG.md

@@ -30,6 +30,7 @@
 - Accept spans needed for the mobile Starfish module. ([#2570](https://github.com/getsentry/relay/pull/2570))
 - Extract size metrics and blocking status tag for resource spans. ([#2578](https://github.com/getsentry/relay/pull/2578))
 - Add a setting to rollout ingesting all resource spans. ([#2586](https://github.com/getsentry/relay/pull/2586))
+- Add User Feedback Ingestion. ([#2604](https://github.com/getsentry/relay/pull/2604))
 - Drop events starting or ending before January 1, 1970 UTC. ([#2613](https://github.com/getsentry/relay/pull/2613))
 - Add support for X-Sentry-Forwarded-For header. ([#2572](https://github.com/getsentry/relay/pull/2572))
 

relay-base-schema/src/data_category.rs

@@ -57,6 +57,12 @@ pub enum DataCategory {
     /// but we define it here to prevent clashing values since this data category enumeration
     /// is also used outside of Relay via the Python package.
     MonitorSeat = 13,
+    /// User Feedback
+    ///
+    /// Represents a User Feedback processed.
+    /// Currently standardized on name UserReportV2 to avoid clashing with the old UserReport.
+    /// TODO(jferg): Rename this to UserFeedback once old UserReport is deprecated.
+    UserReportV2 = 14,
     //
     // IMPORTANT: After adding a new entry to DataCategory, go to the `relay-cabi` subfolder and run
     // `make header` to regenerate the C-binding. This allows using the data category from Python.
@@ -108,6 +114,7 @@ impl DataCategory {
             Self::Monitor => "monitor",
             Self::Span => "span",
             Self::MonitorSeat => "monitor_seat",
+            Self::UserReportV2 => "user_report_v2",
             Self::Unknown => "unknown",
         }
     }
@@ -157,6 +164,7 @@ impl From<EventType> for DataCategory {
             EventType::Csp | EventType::Hpkp | EventType::ExpectCt | EventType::ExpectStaple => {
                 Self::Security
             }
+            EventType::UserReportV2 => Self::UserReportV2,
         }
     }
 }

relay-base-schema/src/events.rs

@@ -41,6 +41,10 @@ pub enum EventType {
     ExpectStaple,
     /// Performance monitoring transactions carrying spans.
     Transaction,
+    /// User feedback payload.
+    ///
+    /// TODO(Jferg): Change this to UserFeedback once old UserReport logic is deprecated.
+    UserReportV2,
     /// All events that do not qualify as any other type.
     #[serde(other)]
     #[default]
@@ -71,6 +75,7 @@ impl FromStr for EventType {
             "expectct" => EventType::ExpectCt,
             "expectstaple" => EventType::ExpectStaple,
             "transaction" => EventType::Transaction,
+            "feedback" => EventType::UserReportV2,
             _ => return Err(ParseEventTypeError),
         })
     }
@@ -86,6 +91,7 @@ impl fmt::Display for EventType {
             EventType::ExpectCt => write!(f, "expectct"),
             EventType::ExpectStaple => write!(f, "expectstaple"),
             EventType::Transaction => write!(f, "transaction"),
+            EventType::UserReportV2 => write!(f, "feedback"),
         }
     }
 }

relay-dynamic-config/src/feature.rs

@@ -11,6 +11,11 @@ pub enum Feature {
     /// Enables data scrubbing of replay recording payloads.
     #[serde(rename = "organizations:session-replay-recording-scrubbing")]
     SessionReplayRecordingScrubbing,
+    /// Enables new User Feedback ingest.
+    ///
+    /// TODO(jferg): rename to UserFeedbackIngest once old UserReport logic is deprecated.
+    #[serde(rename = "organizations:user-feedback-ingest")]
+    UserReportV2Ingest,
     /// Enables device.class synthesis
     ///
     /// Enables device.class tag synthesis on mobile events.

relay-event-normalization/src/normalize/mod.rs

@@ -246,6 +246,9 @@ impl<'a> NormalizeProcessor<'a> {
         if event.ty.value() == Some(&EventType::Transaction) {
             return EventType::Transaction;
         }
+        if event.ty.value() == Some(&EventType::UserReportV2) {
+            return EventType::UserReportV2;
+        }
 
         // The SDKs do not describe event types, and we must infer them from available attributes.
         let has_exceptions = event

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

@@ -12,7 +12,7 @@ mod reprocessing;
 mod response;
 mod runtime;
 mod trace;
-
+mod user_report_v2;
 pub use app::*;
 pub use browser::*;
 pub use cloud_resource::*;
@@ -27,6 +27,7 @@ pub use reprocessing::*;
 pub use response::*;
 pub use runtime::*;
 pub use trace::*;
+pub use user_report_v2::*;
 
 #[cfg(feature = "jsonschema")]
 use relay_jsonschema_derive::JsonSchema;
@@ -67,6 +68,8 @@ pub enum Context {
     Profile(Box<ProfileContext>),
     /// Information related to Replay.
     Replay(Box<ReplayContext>),
+    /// Information related to User Report V2. TODO:(jferg): rename to UserFeedbackContext
+    UserReportV2(Box<UserReportV2Context>),
     /// Information related to Monitors feature.
     Monitor(Box<MonitorContext>),
     /// Auxilliary information for reprocessing.

relay-event-schema/src/protocol/contexts/replay.rs

@@ -59,7 +59,7 @@ mod tests {
     use crate::protocol::Context;
 
     #[test]
-    fn test_trace_context_roundtrip() {
+    fn test_replay_context() {
         let json = r#"{
   "replay_id": "4c79f60c11214eb38604f4ae0781bfb2",
   "type": "replay"

relay-event-schema/src/protocol/contexts/user_report_v2.rs

@@ -0,0 +1,78 @@
+#[cfg(feature = "jsonschema")]
+use relay_jsonschema_derive::JsonSchema;
+use relay_protocol::{Annotated, Empty, FromValue, IntoValue, Object, Value};
+
+use crate::processor::ProcessValue;
+
+/// Feedback context.
+///
+/// This contexts contains user feedback specific attributes.
+/// We don't PII scrub contact_email as that is provided by the user.
+/// TODO(jferg): rename to FeedbackContext once old UserReport logic is deprecated.
+#[derive(Clone, Debug, Default, PartialEq, Empty, FromValue, IntoValue, ProcessValue)]
+#[cfg_attr(feature = "jsonschema", derive(JsonSchema))]
+pub struct UserReportV2Context {
+    /// The feedback message which contains what the user has to say.
+    pub message: Annotated<String>,
+
+    /// an email optionally provided by the user, which can be different from user.email
+    #[metastructure(pii = "false")]
+    pub contact_email: Annotated<String>,
+    /// Additional arbitrary fields for forwards compatibility.
+    #[metastructure(additional_properties, retain = "true")]
+    pub other: Object<Value>,
+}
+
+impl super::DefaultContext for UserReportV2Context {
+    fn default_key() -> &'static str {
+        "feedback"
+    }
+
+    fn from_context(context: super::Context) -> Option<Self> {
+        match context {
+            super::Context::UserReportV2(c) => Some(*c),
+            _ => None,
+        }
+    }
+
+    fn cast(context: &super::Context) -> Option<&Self> {
+        match context {
+            super::Context::UserReportV2(c) => Some(c),
+            _ => None,
+        }
+    }
+
+    fn cast_mut(context: &mut super::Context) -> Option<&mut Self> {
+        match context {
+            super::Context::UserReportV2(c) => Some(c),
+            _ => None,
+        }
+    }
+
+    fn into_context(self) -> super::Context {
+        super::Context::UserReportV2(Box::new(self))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::protocol::Context;
+
+    #[test]
+    fn test_feedback_context() {
+        let json = r#"{
+  "message": "test message",
+  "contact_email": "test@test.com",
+  "type": "userreportv2"
+}"#;
+        let context = Annotated::new(Context::UserReportV2(Box::new(UserReportV2Context {
+            message: Annotated::new("test message".to_string()),
+            contact_email: Annotated::new("test@test.com".to_string()),
+            other: Object::default(),
+        })));
+
+        assert_eq!(context, Annotated::from_json(json).unwrap());
+        assert_eq!(json, context.to_json_pretty().unwrap());
+    }
+}

relay-quotas/src/quota.rs

@@ -110,7 +110,8 @@ impl CategoryUnit {
             | DataCategory::TransactionIndexed
             | DataCategory::Span
             | DataCategory::MonitorSeat
-            | DataCategory::Monitor => Some(Self::Count),
+            | DataCategory::Monitor
+            | DataCategory::UserReportV2 => Some(Self::Count),
             DataCategory::Attachment => Some(Self::Bytes),
             DataCategory::Session => Some(Self::Batched),
 

relay-server/src/actors/processor.rs

@@ -1644,6 +1644,7 @@ impl EnvelopeProcessorService {
             ItemType::Security => true,
             ItemType::FormData => true,
             ItemType::RawSecurity => true,
+            ItemType::UserReportV2 => true,
 
             // These should be removed conditionally:
             ItemType::UnrealReport => self.inner.config.processing_enabled(),
@@ -1687,6 +1688,9 @@ impl EnvelopeProcessorService {
         let transaction_item = envelope.take_item_by(|item| item.ty() == &ItemType::Transaction);
         let security_item = envelope.take_item_by(|item| item.ty() == &ItemType::Security);
         let raw_security_item = envelope.take_item_by(|item| item.ty() == &ItemType::RawSecurity);
+        let user_report_v2_item =
+            envelope.take_item_by(|item| item.ty() == &ItemType::UserReportV2);
+
         let form_item = envelope.take_item_by(|item| item.ty() == &ItemType::FormData);
         let attachment_item = envelope
             .take_item_by(|item| item.attachment_type() == Some(&AttachmentType::EventPayload));
@@ -1718,6 +1722,14 @@ impl EnvelopeProcessorService {
                 // hint to normalization that we're dealing with a transaction now.
                 self.event_from_json_payload(item, Some(EventType::Transaction))?
             })
+        } else if let Some(item) = user_report_v2_item {
+            relay_log::trace!("processing user_report_v2");
+            let project_state = &state.project_state;
+            let user_report_v2_ingest = project_state.has_feature(Feature::UserReportV2Ingest);
+            if !user_report_v2_ingest {
+                return Err(ProcessingError::NoEventPayload);
+            }
+            self.event_from_json_payload(item, Some(EventType::UserReportV2))?
         } else if let Some(mut item) = raw_security_item {
             relay_log::trace!("processing security report");
             sample_rates = item.take_sample_rates();

relay-server/src/actors/store.rs

@@ -121,7 +121,10 @@ impl StoreService {
         let event_item = envelope.get_item_by(|item| {
             matches!(
                 item.ty(),
-                ItemType::Event | ItemType::Transaction | ItemType::Security
+                ItemType::Event
+                    | ItemType::Transaction
+                    | ItemType::Security
+                    | ItemType::UserReportV2
             )
         });
 

relay-server/src/envelope.rs

@@ -112,6 +112,8 @@ pub enum ItemType {
     CheckIn,
     /// A standalone span.
     Span,
+    /// UserReport as an Event
+    UserReportV2,
     /// A new item type that is yet unknown by this version of Relay.
     ///
     /// By default, items of this type are forwarded without modification. Processing Relays and
@@ -127,6 +129,7 @@ impl ItemType {
         match event_type {
             EventType::Default | EventType::Error => ItemType::Event,
             EventType::Transaction => ItemType::Transaction,
+            EventType::UserReportV2 => ItemType::UserReportV2,
             EventType::Csp | EventType::Hpkp | EventType::ExpectCt | EventType::ExpectStaple => {
                 ItemType::Security
             }
@@ -145,6 +148,7 @@ impl fmt::Display for ItemType {
             Self::RawSecurity => write!(f, "raw_security"),
             Self::UnrealReport => write!(f, "unreal_report"),
             Self::UserReport => write!(f, "user_report"),
+            Self::UserReportV2 => write!(f, "feedback"),
             Self::Session => write!(f, "session"),
             Self::Sessions => write!(f, "sessions"),
             Self::Statsd => write!(f, "statsd"),
@@ -173,6 +177,7 @@ impl std::str::FromStr for ItemType {
             "raw_security" => Self::RawSecurity,
             "unreal_report" => Self::UnrealReport,
             "user_report" => Self::UserReport,
+            "feedback" => Self::UserReportV2,
             "session" => Self::Session,
             "sessions" => Self::Sessions,
             "statsd" => Self::Statsd,
@@ -556,6 +561,7 @@ impl Item {
             ItemType::Statsd | ItemType::MetricBuckets => None,
             ItemType::FormData => None,
             ItemType::UserReport => None,
+            ItemType::UserReportV2 => None,
             ItemType::Profile => Some(if indexed {
                 DataCategory::ProfileIndexed
             } else {
@@ -700,7 +706,8 @@ impl Item {
             | ItemType::Transaction
             | ItemType::Security
             | ItemType::RawSecurity
-            | ItemType::UnrealReport => true,
+            | ItemType::UnrealReport
+            | ItemType::UserReportV2 => true,
 
             // Attachments are only event items if they are crash reports or if they carry partial
             // event payloads. Plain attachments never create event payloads.
@@ -758,6 +765,8 @@ impl Item {
             ItemType::RawSecurity => true,
             ItemType::UnrealReport => true,
             ItemType::UserReport => true,
+            ItemType::UserReportV2 => true,
+
             ItemType::ReplayEvent => true,
             ItemType::Session => false,
             ItemType::Sessions => false,

relay-server/src/utils/rate_limits.rs

@@ -94,6 +94,7 @@ fn infer_event_category(item: &Item) -> Option<DataCategory> {
         ItemType::Transaction => Some(DataCategory::Transaction),
         ItemType::Security | ItemType::RawSecurity => Some(DataCategory::Security),
         ItemType::UnrealReport => Some(DataCategory::Error),
+        ItemType::UserReportV2 => Some(DataCategory::UserReportV2),
         ItemType::Attachment if item.creates_event() => Some(DataCategory::Error),
         ItemType::Attachment => None,
         ItemType::Session => None,

relay-server/src/utils/sizes.rs

@@ -29,6 +29,7 @@ pub fn check_envelope_size_limits(config: &Config, envelope: &Envelope) -> bool
             | ItemType::Security
             | ItemType::ReplayEvent
             | ItemType::RawSecurity
+            | ItemType::UserReportV2
             | ItemType::FormData => {
                 event_size += item.len();
             }

relay-server/tests/snapshots/test_fixtures__event_schema.snap

@@ -913,6 +913,9 @@ expression: "relay_event_schema::protocol::event_json_schema()"
         {
           "$ref": "#/definitions/ReplayContext"
         },
+        {
+          "$ref": "#/definitions/UserReportV2Context"
+        },
         {
           "$ref": "#/definitions/MonitorContext"
         },
@@ -1492,6 +1495,7 @@ expression: "relay_event_schema::protocol::event_json_schema()"
         "expectct",
         "expectstaple",
         "transaction",
+        "userreportv2",
         "default"
       ]
     },
@@ -3773,6 +3777,33 @@ expression: "relay_event_schema::protocol::event_json_schema()"
           "additionalProperties": false
         }
       ]
+    },
+    "UserReportV2Context": {
+      "description": " Feedback context.\n\n This contexts contains user feedback specific attributes.\n We don't PII scrub contact_email as that is provided by the user.\n TODO(jferg): rename to FeedbackContext once old UserReport logic is deprecated.",
+      "anyOf": [
+        {
+          "type": "object",
+          "properties": {
+            "contact_email": {
+              "description": " an email optionally provided by the user, which can be different from user.email",
+              "default": null,
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "message": {
+              "description": " The feedback message which contains what the user has to say.",
+              "default": null,
+              "type": [
+                "string",
+                "null"
+              ]
+            }
+          },
+          "additionalProperties": false
+        }
+      ]
     }
   }
 }

tests/integration/fixtures/__init__.py

@@ -220,6 +220,11 @@ def send_client_report(self, project_id, payload):
         envelope.add_item(Item(PayloadRef(json=payload), type="client_report"))
         self.send_envelope(project_id, envelope)
 
+    def send_user_feedback(self, project_id, payload):
+        envelope = Envelope()
+        envelope.add_item(Item(PayloadRef(json=payload), type="feedback"))
+        self.send_envelope(project_id, envelope)
+
     def send_metrics(self, project_id, payload):
         envelope = Envelope()
         envelope.add_item(