feat(unreal): Preserve values from the incoming event object over properties pulled from the Unreal context

Author: leops

relay-server/src/utils/unreal.rs

@@ -206,18 +206,17 @@ fn merge_unreal_context(event: &mut Event, context: Unreal4Context) {
     };
 
     if let Some(msg) = runtime_props.error_message.take() {
-        event
-            .logentry
-            .get_or_insert_with(LogEntry::default)
-            .formatted = Annotated::new(Message::from(msg));
+        let logentry = event.logentry.get_or_insert_with(LogEntry::default);
+        if logentry.formatted.is_empty() {
+            logentry.formatted = Annotated::new(Message::from(msg));
+        }
     }
 
     if let Some(username) = runtime_props.username.take() {
-        event
-            .user
-            .get_or_insert_with(User::default)
-            .username
-            .set_value(Some(username.into()));
+        let user = event.user.get_or_insert_with(User::default);
+        if user.username.is_empty() {
+            user.username.set_value(Some(username.into()));
+        }
     }
 
     if let Some(login_id) = &runtime_props.login_id {
@@ -232,47 +231,65 @@ fn merge_unreal_context(event: &mut Event, context: Unreal4Context) {
 
     if let Some(memory_physical) = runtime_props.memory_stats_total_physical.take() {
         let device_context = contexts.get_or_default::<DeviceContext>();
-        device_context.memory_size = Annotated::new(memory_physical);
+        if device_context.memory_size.is_empty() {
+            device_context.memory_size = Annotated::new(memory_physical);
+        }
     }
 
     // OS information is likely overwritten by Minidump processing later.
     if let Some(os_major) = runtime_props.misc_os_version_major.take() {
         let os_context = contexts.get_or_default::<OsContext>();
-        os_context.raw_description = Annotated::new(os_major);
+        if os_context.raw_description.is_empty() {
+            os_context.raw_description = Annotated::new(os_major);
+        }
     }
 
     // See https://github.com/EpicGames/UnrealEngine/blob/5.3.2-release/Engine/Source/Runtime/RHI/Private/DynamicRHI.cpp#L368-L376
     if let Some(adapter_name) = context.engine_data.get("RHI.AdapterName") {
         let gpu_context = contexts.get_or_default::<GpuContext>();
-        gpu_context.name = Annotated::new(adapter_name.into());
+        if gpu_context.name.is_empty() {
+            gpu_context.name = Annotated::new(adapter_name.into());
+        }
     } else if let Some(gpu_brand) = runtime_props.misc_primary_gpu_brand.take() {
         let gpu_context = contexts.get_or_default::<GpuContext>();
-        gpu_context.name = Annotated::new(gpu_brand);
+        if gpu_context.name.is_empty() {
+            gpu_context.name = Annotated::new(gpu_brand);
+        }
     }
 
     if let Some(device_id) = context.engine_data.get("RHI.DeviceId") {
         let gpu_context = contexts.get_or_default::<GpuContext>();
-        gpu_context.id = Annotated::new(Value::String(device_id.into()));
+        if gpu_context.id.is_empty() {
+            gpu_context.id = Annotated::new(Value::String(device_id.into()));
+        }
     }
 
     if let Some(feature_level) = context.engine_data.get("RHI.FeatureLevel") {
         let gpu_context = contexts.get_or_default::<GpuContext>();
-        gpu_context.graphics_shader_level = Annotated::new(feature_level.into());
+        if gpu_context.graphics_shader_level.is_empty() {
+            gpu_context.graphics_shader_level = Annotated::new(feature_level.into());
+        }
     }
 
     if let Some(vendor_name) = context.engine_data.get("RHI.GPUVendor") {
         let gpu_context = contexts.get_or_default::<GpuContext>();
-        gpu_context.vendor_name = Annotated::new(vendor_name.into());
+        if gpu_context.vendor_name.is_empty() {
+            gpu_context.vendor_name = Annotated::new(vendor_name.into());
+        }
     }
 
     if let Some(driver_version) = context.engine_data.get("RHI.UserDriverVersion") {
         let gpu_context = contexts.get_or_default::<GpuContext>();
-        gpu_context.version = Annotated::new(driver_version.into());
+        if gpu_context.version.is_empty() {
+            gpu_context.version = Annotated::new(driver_version.into());
+        }
     }
 
     if let Some(rhi_name) = context.engine_data.get("RHI.RHIName") {
         let gpu_context = contexts.get_or_default::<GpuContext>();
-        gpu_context.api_type = Annotated::new(rhi_name.into());
+        if gpu_context.api_type.is_empty() {
+            gpu_context.api_type = Annotated::new(rhi_name.into());
+        }
     }
 
     if event.level.is_empty() {
@@ -572,4 +589,73 @@ mod tests {
             LenientString("ebff51ef3c4878627823eebd9ff40eb4".to_owned())
         );
     }
+
+    #[test]
+    fn test_merge_unreal_context_is_input_preserved() {
+        let context = get_context();
+
+        let mut event = Event::default();
+
+        let logentry = event.logentry.get_or_insert_with(LogEntry::default);
+        logentry.formatted = Annotated::new(String::from("error_message").into());
+
+        let user = event.user.get_or_insert_with(User::default);
+        user.username = Annotated::new(String::from("user_name").into());
+
+        let contexts = event.contexts.get_or_insert_with(Contexts::default);
+
+        let device_context = contexts.get_or_default::<DeviceContext>();
+        device_context.memory_size = Annotated::new(123456789);
+
+        let os_context = contexts.get_or_default::<OsContext>();
+        os_context.name = Annotated::new(String::from("os_name"));
+
+        let gpu_context = contexts.get_or_default::<GpuContext>();
+        gpu_context.name = Annotated::new(String::from("adapter_name"));
+        gpu_context.id = Annotated::new(Value::String(String::from("device_id")));
+        gpu_context.graphics_shader_level = Annotated::new(String::from("feature_level"));
+        gpu_context.vendor_name = Annotated::new(String::from("vendor_name"));
+        gpu_context.version = Annotated::new(String::from("driver_version"));
+        gpu_context.api_type = Annotated::new(String::from("rhi_name"));
+
+        merge_unreal_context(&mut event, context);
+
+        let logentry = event.logentry.value().unwrap();
+        let formatted = logentry.formatted.value().unwrap();
+        assert_eq!(formatted.as_ref(), "error_message");
+
+        let user = event.user.value().unwrap();
+        let username = user.username.value().unwrap();
+        assert_eq!(username.as_ref(), "user_name");
+
+        let contexts = event.contexts.value().unwrap();
+
+        let device_context = contexts.get::<DeviceContext>().unwrap();
+        let memory_size = device_context.memory_size.value().unwrap();
+        assert_eq!(*memory_size, 123456789);
+
+        let os_context = contexts.get::<OsContext>().unwrap();
+        let os_name = os_context.name.value().unwrap();
+        assert_eq!(os_name, "os_name");
+
+        let gpu_context = contexts.get::<GpuContext>().unwrap();
+        let adapter_name = gpu_context.name.value().unwrap();
+        assert_eq!(adapter_name, "adapter_name");
+
+        let device_id = gpu_context.id.value().unwrap();
+        let device_id = device_id.as_str().unwrap();
+        assert_eq!(device_id, "device_id");
+
+        let feature_level = gpu_context.graphics_shader_level.value().unwrap();
+        assert_eq!(feature_level, "feature_level");
+
+        let vendor_name = gpu_context.vendor_name.value().unwrap();
+        assert_eq!(vendor_name, "vendor_name");
+
+        let driver_version = gpu_context.version.value().unwrap();
+        assert_eq!(driver_version, "driver_version");
+
+        let rhi_name = gpu_context.api_type.value().unwrap();
+        assert_eq!(rhi_name, "rhi_name");
+    }
 }