ref(replay): Run geo info normalization on the replay user

Author: Dav1dde

CHANGELOG.md

@@ -13,6 +13,7 @@
 - Add a config option to add default tags to all Relay Sentry events. ([#3944](https://github.com/getsentry/relay/pull/3944))
 - Automatically derive `client.address` and `user.geo` for standalone spans. ([#4047](https://github.com/getsentry/relay/pull/4047))
 - Add support for uploading compressed (gzip, xz, zstd, bzip2) minidumps. ([#4029](https://github.com/getsentry/relay/pull/4029))
+- Add user geo information to Replays. ([#4088](https://github.com/getsentry/relay/pull/4088))
 - Configurable span.op inference. ([#4056](https://github.com/getsentry/relay/pull/4056))
 
 **Internal:**

relay-event-normalization/src/replay.rs

@@ -6,9 +6,10 @@ use relay_event_schema::processor::{self, ProcessingState, Processor};
 use relay_event_schema::protocol::{Contexts, IpAddr, Replay};
 use relay_protocol::Annotated;
 
+use crate::event::normalize_user_geoinfo;
 use crate::normalize::user_agent;
-use crate::trimming;
 use crate::user_agent::RawUserAgentInfo;
+use crate::{trimming, GeoIpLookup};
 
 /// Replay validation or normalization error.
 ///
@@ -82,11 +83,17 @@ pub fn validate(replay: &Replay) -> Result<(), ReplayError> {
 pub fn normalize(
     replay: &mut Annotated<Replay>,
     client_ip: Option<StdIpAddr>,
-    user_agent: &RawUserAgentInfo<&str>,
+    user_agent: RawUserAgentInfo<&str>,
+    geoip_lookup: Option<&GeoIpLookup>,
 ) {
     let _ = processor::apply(replay, |replay_value, meta| {
         normalize_platform(replay_value);
         normalize_ip_address(replay_value, client_ip);
+        if let Some(geoip_lookup) = geoip_lookup {
+            if let Some(user) = replay_value.user.value_mut() {
+                normalize_user_geoinfo(geoip_lookup, user);
+            }
+        }
         normalize_user_agent(replay_value, user_agent);
         normalize_type(replay_value);
         normalize_array_fields(replay_value);
@@ -124,7 +131,7 @@ fn normalize_ip_address(replay: &mut Replay, ip_address: Option<StdIpAddr>) {
     );
 }
 
-fn normalize_user_agent(replay: &mut Replay, default_user_agent: &RawUserAgentInfo<&str>) {
+fn normalize_user_agent(replay: &mut Replay, default_user_agent: RawUserAgentInfo<&str>) {
     let headers = match replay
         .request
         .value()
@@ -139,11 +146,11 @@ fn normalize_user_agent(replay: &mut Replay, default_user_agent: &RawUserAgentIn
     let user_agent_info = if user_agent_info.is_empty() {
         default_user_agent
     } else {
-        &user_agent_info
+        user_agent_info
     };
 
     let contexts = replay.contexts.get_or_insert_with(Contexts::new);
-    user_agent::normalize_user_agent_info_generic(contexts, &replay.platform, user_agent_info);
+    user_agent::normalize_user_agent_info_generic(contexts, &replay.platform, &user_agent_info);
 }
 
 fn normalize_platform(replay: &mut Replay) {
@@ -165,7 +172,8 @@ mod tests {
     use std::net::{IpAddr, Ipv4Addr};
 
     use chrono::{TimeZone, Utc};
-    use relay_protocol::{assert_annotated_snapshot, get_value};
+    use insta::{assert_debug_snapshot, assert_json_snapshot};
+    use relay_protocol::{assert_annotated_snapshot, get_value, SerializableAnnotated};
     use uuid::Uuid;
 
     use relay_event_schema::protocol::{
@@ -253,7 +261,7 @@ mod tests {
         let payload = include_str!("../../tests/fixtures/replay.json");
 
         let mut replay: Annotated<Replay> = Annotated::from_json(payload).unwrap();
-        normalize(&mut replay, None, &RawUserAgentInfo::default());
+        normalize(&mut replay, None, RawUserAgentInfo::default(), None);
 
         let contexts = get_value!(replay.contexts!);
         assert_eq!(
@@ -290,37 +298,61 @@ mod tests {
         let mut replay: Annotated<Replay> = Annotated::from_json(payload).unwrap();
 
         // No user object and no ip-address was provided.
-        normalize(&mut replay, None, &RawUserAgentInfo::default());
+        normalize(&mut replay, None, RawUserAgentInfo::default(), None);
         assert_eq!(get_value!(replay.user), None);
 
         // No user object but an ip-address was provided.
         let ip_address = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
-        normalize(&mut replay, Some(ip_address), &RawUserAgentInfo::default());
+        normalize(
+            &mut replay,
+            Some(ip_address),
+            RawUserAgentInfo::default(),
+            None,
+        );
 
         let ipaddr = get_value!(replay.user!).ip_address.as_str();
         assert_eq!(Some("127.0.0.1"), ipaddr);
     }
 
     #[test]
-    fn test_set_ip_address_missing_user_ip_address() {
-        let ip_address = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
+    fn test_set_ip_address_missing_user_ip_address_and_geo() {
+        let lookup = GeoIpLookup::open("tests/fixtures/GeoIP2-Enterprise-Test.mmdb").unwrap();
+        let ip_address = IpAddr::V4(Ipv4Addr::new(2, 125, 160, 216));
 
         // IP-Address set.
         let payload = include_str!("../../tests/fixtures/replay_missing_user_ip_address.json");
 
         let mut replay: Annotated<Replay> = Annotated::from_json(payload).unwrap();
-        normalize(&mut replay, Some(ip_address), &RawUserAgentInfo::default());
+        normalize(
+            &mut replay,
+            Some(ip_address),
+            RawUserAgentInfo::default(),
+            Some(&lookup),
+        );
 
-        let ipaddr = get_value!(replay.user!).ip_address.as_str();
-        assert_eq!(Some("127.0.0.1"), ipaddr);
+        let user = &replay.value().unwrap().user;
+        assert_json_snapshot!(SerializableAnnotated(user), @r###"
+        {
+          "id": "123",
+          "email": "[email protected]",
+          "ip_address": "2.125.160.216",
+          "username": "user",
+          "geo": {
+            "country_code": "GB",
+            "city": "Boxford",
+            "subdivision": "England",
+            "region": "United Kingdom"
+          }
+        }
+        "###);
     }
 
     #[test]
     fn test_loose_type_requirements() {
         let payload = include_str!("../../tests/fixtures/replay_failure_22_08_31.json");
 
         let mut replay: Annotated<Replay> = Annotated::from_json(payload).unwrap();
-        normalize(&mut replay, None, &RawUserAgentInfo::default());
+        normalize(&mut replay, None, RawUserAgentInfo::default(), None);
 
         let user = get_value!(replay.user!);
         assert_eq!(user.ip_address.as_str(), Some("127.1.1.1"));
@@ -444,7 +476,7 @@ mod tests {
         let json = format!(r#"{{"dist": "{}"}}"#, "0".repeat(100));
         let mut replay = Annotated::<Replay>::from_json(json.as_str()).unwrap();
 
-        normalize(&mut replay, None, &RawUserAgentInfo::default());
+        normalize(&mut replay, None, RawUserAgentInfo::default(), None);
         assert_annotated_snapshot!(replay, @r#"{
   "platform": "other",
   "dist": "0000000000000000000000000000000000000000000000000000000000000...",

relay-server/src/services/processor.rs

@@ -1835,7 +1835,11 @@ impl EnvelopeProcessorService {
         &self,
         state: &mut ProcessEnvelopeState<ReplayGroup>,
     ) -> Result<(), ProcessingError> {
-        replay::process(state, &self.inner.global_config.current())?;
+        replay::process(
+            state,
+            &self.inner.global_config.current(),
+            self.inner.geoip_lookup.as_ref(),
+        )?;
         if_processing!(self.inner.config, {
             self.enforce_quotas(state)?;
         });