Merge pull request #2828 from DataDog/tvaleev/feature/RUM-11251-fix-serialization

[RUM-11251][FO]: Fix RumVitalEvent serialization logic

Author: satween

features/dd-sdk-android-rum/api/apiSurface

@@ -82,6 +82,7 @@ data class com.datadog.android.rum.RumConfiguration
     fun setActionEventMapper(com.datadog.android.event.EventMapper<com.datadog.android.rum.model.ActionEvent>): Builder
     fun setErrorEventMapper(com.datadog.android.event.EventMapper<com.datadog.android.rum.model.ErrorEvent>): Builder
     fun setLongTaskEventMapper(com.datadog.android.event.EventMapper<com.datadog.android.rum.model.LongTaskEvent>): Builder
+    fun setVitalEventMapper(com.datadog.android.event.EventMapper<com.datadog.android.rum.model.RumVitalEvent>): Builder
     fun trackBackgroundEvents(Boolean): Builder
     fun trackFrustrations(Boolean): Builder
     fun setVitalsUpdateFrequency(com.datadog.android.rum.configuration.VitalsUpdateFrequency): Builder

features/dd-sdk-android-rum/api/dd-sdk-android-rum.api

@@ -117,6 +117,7 @@ public final class com/datadog/android/rum/RumConfiguration$Builder {
 	public final fun setSlowFramesConfiguration (Lcom/datadog/android/rum/configuration/SlowFramesConfiguration;)Lcom/datadog/android/rum/RumConfiguration$Builder;
 	public final fun setTelemetrySampleRate (F)Lcom/datadog/android/rum/RumConfiguration$Builder;
 	public final fun setViewEventMapper (Lcom/datadog/android/rum/event/ViewEventMapper;)Lcom/datadog/android/rum/RumConfiguration$Builder;
+	public final fun setVitalEventMapper (Lcom/datadog/android/event/EventMapper;)Lcom/datadog/android/rum/RumConfiguration$Builder;
 	public final fun setVitalsUpdateFrequency (Lcom/datadog/android/rum/configuration/VitalsUpdateFrequency;)Lcom/datadog/android/rum/RumConfiguration$Builder;
 	public final fun trackAnonymousUser (Z)Lcom/datadog/android/rum/RumConfiguration$Builder;
 	public final fun trackBackgroundEvents (Z)Lcom/datadog/android/rum/RumConfiguration$Builder;

features/dd-sdk-android-rum/src/main/kotlin/com/datadog/android/rum/RumConfiguration.kt

@@ -22,6 +22,7 @@ import com.datadog.android.rum.model.ActionEvent
 import com.datadog.android.rum.model.ErrorEvent
 import com.datadog.android.rum.model.LongTaskEvent
 import com.datadog.android.rum.model.ResourceEvent
+import com.datadog.android.rum.model.RumVitalEvent
 import com.datadog.android.rum.model.ViewEvent
 import com.datadog.android.rum.tracking.ActionTrackingStrategy
 import com.datadog.android.rum.tracking.ActivityViewTrackingStrategy
@@ -219,6 +220,17 @@ data class RumConfiguration internal constructor(
             return this
         }
 
+        /**
+         * Sets the [EventMapper] for the RUM [RumVitalEvent]. You can use this interface implementation
+         * to modify the [RumVitalEvent] attributes before serialisation.
+         *
+         * @param eventMapper the [EventMapper] implementation.
+         */
+        fun setVitalEventMapper(eventMapper: EventMapper<RumVitalEvent>): Builder {
+            rumConfig = rumConfig.copy(vitalEventMapper = eventMapper)
+            return this
+        }
+
         /**
          * Enables/Disables tracking RUM event when no Activity is in foreground.
          *

features/dd-sdk-android-rum/src/main/kotlin/com/datadog/android/rum/internal/RumFeature.kt

@@ -90,6 +90,7 @@ import com.datadog.android.rum.model.ActionEvent
 import com.datadog.android.rum.model.ErrorEvent
 import com.datadog.android.rum.model.LongTaskEvent
 import com.datadog.android.rum.model.ResourceEvent
+import com.datadog.android.rum.model.RumVitalEvent
 import com.datadog.android.rum.model.ViewEvent
 import com.datadog.android.rum.tracking.ActionTrackingStrategy
 import com.datadog.android.rum.tracking.ActivityViewTrackingStrategy
@@ -329,6 +330,7 @@ internal class RumFeature(
                     resourceEventMapper = configuration.resourceEventMapper,
                     actionEventMapper = configuration.actionEventMapper,
                     longTaskEventMapper = configuration.longTaskEventMapper,
+                    vitalEventMapper = configuration.vitalEventMapper,
                     telemetryConfigurationMapper = configuration.telemetryConfigurationMapper,
                     internalLogger = sdkCore.internalLogger
                 ),
@@ -641,6 +643,7 @@ internal class RumFeature(
         val resourceEventMapper: EventMapper<ResourceEvent>,
         val actionEventMapper: EventMapper<ActionEvent>,
         val longTaskEventMapper: EventMapper<LongTaskEvent>,
+        val vitalEventMapper: EventMapper<RumVitalEvent>,
         val telemetryConfigurationMapper: EventMapper<TelemetryConfigurationEvent>,
         val backgroundEventTracking: Boolean,
         val trackFrustrations: Boolean,
@@ -692,6 +695,7 @@ internal class RumFeature(
             resourceEventMapper = NoOpEventMapper(),
             actionEventMapper = NoOpEventMapper(),
             longTaskEventMapper = NoOpEventMapper(),
+            vitalEventMapper = NoOpEventMapper(),
             telemetryConfigurationMapper = NoOpEventMapper(),
             backgroundEventTracking = false,
             trackFrustrations = true,

features/dd-sdk-android-rum/src/main/kotlin/com/datadog/android/rum/internal/domain/event/RumEventMapper.kt

@@ -13,6 +13,7 @@ import com.datadog.android.rum.model.ActionEvent
 import com.datadog.android.rum.model.ErrorEvent
 import com.datadog.android.rum.model.LongTaskEvent
 import com.datadog.android.rum.model.ResourceEvent
+import com.datadog.android.rum.model.RumVitalEvent
 import com.datadog.android.rum.model.ViewEvent
 import com.datadog.android.telemetry.model.TelemetryConfigurationEvent
 import com.datadog.android.telemetry.model.TelemetryDebugEvent
@@ -26,6 +27,7 @@ internal data class RumEventMapper(
     val resourceEventMapper: EventMapper<ResourceEvent> = NoOpEventMapper(),
     val actionEventMapper: EventMapper<ActionEvent> = NoOpEventMapper(),
     val longTaskEventMapper: EventMapper<LongTaskEvent> = NoOpEventMapper(),
+    val vitalEventMapper: EventMapper<RumVitalEvent> = NoOpEventMapper(),
     val telemetryConfigurationMapper: EventMapper<TelemetryConfigurationEvent> = NoOpEventMapper(),
     private val internalLogger: InternalLogger
 ) : EventMapper<Any> {
@@ -60,6 +62,7 @@ internal data class RumEventMapper(
             }
             is ResourceEvent -> resourceEventMapper.map(event)
             is LongTaskEvent -> longTaskEventMapper.map(event)
+            is RumVitalEvent -> vitalEventMapper.map(event)
             is TelemetryConfigurationEvent -> telemetryConfigurationMapper.map(event)
             is TelemetryDebugEvent,
             is TelemetryUsageEvent,

features/dd-sdk-android-rum/src/main/kotlin/com/datadog/android/rum/internal/domain/event/RumEventSerializer.kt

@@ -16,6 +16,7 @@ import com.datadog.android.rum.model.ActionEvent
 import com.datadog.android.rum.model.ErrorEvent
 import com.datadog.android.rum.model.LongTaskEvent
 import com.datadog.android.rum.model.ResourceEvent
+import com.datadog.android.rum.model.RumVitalEvent
 import com.datadog.android.rum.model.ViewEvent
 import com.datadog.android.telemetry.model.TelemetryConfigurationEvent
 import com.datadog.android.telemetry.model.TelemetryDebugEvent
@@ -47,6 +48,9 @@ internal class RumEventSerializer(
             is LongTaskEvent -> {
                 serializeLongTaskEvent(model)
             }
+            is RumVitalEvent -> {
+                serializeVitalEvent(model)
+            }
             is TelemetryDebugEvent -> {
                 model.toJson().toString()
             }
@@ -201,6 +205,30 @@ internal class RumEventSerializer(
         return extractKnownAttributes(sanitizedModel.toJson().asJsonObject).toString()
     }
 
+    private fun serializeVitalEvent(model: RumVitalEvent): String {
+        val sanitizedUser = model.usr?.copy(
+            additionalProperties = validateUserAttributes(model.usr.additionalProperties)
+                .safeMapValuesToJson(internalLogger)
+                .toMutableMap()
+        )
+        val sanitizedAccount = model.account?.copy(
+            additionalProperties = validateAccountAttributes(model.account.additionalProperties)
+                .safeMapValuesToJson(internalLogger)
+                .toMutableMap()
+        )
+        val sanitizedContext = model.context?.copy(
+            additionalProperties = validateContextAttributes(model.context.additionalProperties)
+                .safeMapValuesToJson(internalLogger)
+                .toMutableMap()
+        )
+        val sanitizedModel = model.copy(
+            usr = sanitizedUser,
+            account = sanitizedAccount,
+            context = sanitizedContext
+        )
+        return extractKnownAttributes(sanitizedModel.toJson().asJsonObject).toString()
+    }
+
     private fun validateContextAttributes(attributes: Map<String, Any?>): MutableMap<String, Any?> {
         return dataConstraints.validateAttributes(
             attributes.filterKeys {

features/dd-sdk-android-rum/src/test/kotlin/com/datadog/android/rum/RumConfigurationBuilderTest.kt

@@ -25,6 +25,7 @@ import com.datadog.android.rum.model.ActionEvent
 import com.datadog.android.rum.model.ErrorEvent
 import com.datadog.android.rum.model.LongTaskEvent
 import com.datadog.android.rum.model.ResourceEvent
+import com.datadog.android.rum.model.RumVitalEvent
 import com.datadog.android.rum.model.ViewEvent
 import com.datadog.android.rum.tracking.ActionTrackingStrategy
 import com.datadog.android.rum.tracking.ActivityViewTrackingStrategy
@@ -448,6 +449,24 @@ internal class RumConfigurationBuilderTest {
         )
     }
 
+    @Test
+    fun `M build config with RUM Vital eventMapper W seVitalEventMapper() & build()`() {
+        // Given
+        val eventMapper: EventMapper<RumVitalEvent> = mock()
+
+        // When
+        val rumConfiguration = testedBuilder
+            .setVitalEventMapper(eventMapper)
+            .build()
+
+        // Then
+        assertThat(rumConfiguration.featureConfiguration).isEqualTo(
+            RumFeature.DEFAULT_RUM_CONFIG.copy(
+                vitalEventMapper = eventMapper
+            )
+        )
+    }
+
     @Test
     fun `M use the given frequency W setVitalsMonitorUpdateFrequency`(
         @Forgery fakeFrequency: VitalsUpdateFrequency

features/dd-sdk-android-rum/src/test/kotlin/com/datadog/android/rum/internal/domain/event/RumEventMapperTest.kt

@@ -12,6 +12,7 @@ import com.datadog.android.rum.model.ActionEvent
 import com.datadog.android.rum.model.ErrorEvent
 import com.datadog.android.rum.model.LongTaskEvent
 import com.datadog.android.rum.model.ResourceEvent
+import com.datadog.android.rum.model.RumVitalEvent
 import com.datadog.android.rum.model.ViewEvent
 import com.datadog.android.rum.utils.forge.Configurator
 import com.datadog.android.rum.utils.forge.aRumEvent
@@ -64,6 +65,9 @@ internal class RumEventMapperTest {
     @Mock
     lateinit var mockLongTaskEventMapper: EventMapper<LongTaskEvent>
 
+    @Mock
+    lateinit var mockVitalEventMapper: EventMapper<RumVitalEvent>
+
     @Mock
     lateinit var mockTelemetryConfigurationMapper: EventMapper<TelemetryConfigurationEvent>
 
@@ -80,6 +84,7 @@ internal class RumEventMapperTest {
             resourceEventMapper = mockResourceEventMapper,
             errorEventMapper = mockErrorEventMapper,
             longTaskEventMapper = mockLongTaskEventMapper,
+            vitalEventMapper = mockVitalEventMapper,
             telemetryConfigurationMapper = mockTelemetryConfigurationMapper,
             internalLogger = mockInternalLogger
         )
@@ -172,6 +177,20 @@ internal class RumEventMapperTest {
         assertThat(mappedRumEvent).isEqualTo(fakeRumEvent)
     }
 
+    @Test
+    fun `M map the bundled event W map { RumVitalEvent }`(forge: Forge) {
+        // GIVEN
+        val fakeRumEvent = forge.getForgery<RumVitalEvent>()
+        whenever(mockVitalEventMapper.map(fakeRumEvent)).thenReturn(fakeRumEvent)
+
+        // WHEN
+        val mappedRumEvent = testedRumEventMapper.map(fakeRumEvent)
+
+        // THEN
+        assertThat(mappedRumEvent).isNotNull
+        assertThat(mappedRumEvent).isEqualTo(fakeRumEvent)
+    }
+
     @Test
     fun `M return the original event W map { no internal mapper used }`(forge: Forge) {
         // GIVEN
@@ -387,6 +406,26 @@ internal class RumEventMapperTest {
         )
     }
 
+    @Test
+    fun `M return null event W map returns null object { RumVitalEvent }`(forge: Forge) {
+        // GIVEN
+        val fakeRumEvent = forge.getForgery<RumVitalEvent>()
+        whenever(mockVitalEventMapper.map(fakeRumEvent))
+            .thenReturn(null)
+
+        // WHEN
+        val mappedRumEvent = testedRumEventMapper.map(fakeRumEvent)
+
+        // THEN
+        assertThat(mappedRumEvent).isNull()
+        mockInternalLogger.verifyLog(
+            InternalLogger.Level.INFO,
+            InternalLogger.Target.USER,
+            RumEventMapper.EVENT_NULL_WARNING_MESSAGE.format(Locale.US, fakeRumEvent)
+
+        )
+    }
+
     @Test
     fun `M use the original event W map returns different object { ViewEvent }`(forge: Forge) {
         // GIVEN
@@ -491,6 +530,26 @@ internal class RumEventMapperTest {
         )
     }
 
+    @Test
+    fun `M return null event W map returns different object { RumVitalEvent }`(forge: Forge) {
+        // GIVEN
+        val fakeRumEvent = forge.getForgery<RumVitalEvent>()
+        whenever(mockVitalEventMapper.map(fakeRumEvent))
+            .thenReturn(forge.getForgery())
+
+        // WHEN
+        val mappedRumEvent = testedRumEventMapper.map(fakeRumEvent)
+
+        // THEN
+        assertThat(mappedRumEvent).isNull()
+        mockInternalLogger.verifyLog(
+            InternalLogger.Level.WARN,
+            InternalLogger.Target.USER,
+            RumEventMapper.NOT_SAME_EVENT_INSTANCE_WARNING_MESSAGE.format(Locale.US, fakeRumEvent)
+
+        )
+    }
+
     @Test
     fun `M use the original event W map returns a copy { ViewEvent }`(forge: Forge) {
         // GIVEN
@@ -593,4 +652,24 @@ internal class RumEventMapperTest {
 
         )
     }
+
+    @Test
+    fun `M return null event W map returns a copy { RumVitalEvent }`(forge: Forge) {
+        // GIVEN
+        val fakeRumEvent = forge.getForgery<RumVitalEvent>()
+        whenever(mockVitalEventMapper.map(fakeRumEvent))
+            .thenReturn(fakeRumEvent.copy())
+
+        // WHEN
+        val mappedRumEvent = testedRumEventMapper.map(fakeRumEvent)
+
+        // THEN
+        assertThat(mappedRumEvent).isNull()
+        mockInternalLogger.verifyLog(
+            InternalLogger.Level.WARN,
+            InternalLogger.Target.USER,
+            RumEventMapper.NOT_SAME_EVENT_INSTANCE_WARNING_MESSAGE.format(Locale.US, fakeRumEvent)
+
+        )
+    }
 }