Bypass limit for log properties when not sending data to Embrace

Author: bidetofevil

embrace-android-core/src/main/kotlin/io/embrace/android/embracesdk/internal/logs/EmbraceLogService.kt

@@ -16,7 +16,7 @@ import io.embrace.android.embracesdk.internal.otel.attrs.embExceptionHandling
 import io.embrace.android.embracesdk.internal.payload.AppFramework
 import io.embrace.android.embracesdk.internal.payload.Envelope
 import io.embrace.android.embracesdk.internal.session.orchestrator.PayloadStore
-import io.embrace.android.embracesdk.internal.utils.PropertyUtils.normalizeProperties
+import io.embrace.android.embracesdk.internal.utils.PropertyUtils.sanitizeProperties
 import io.embrace.android.embracesdk.internal.utils.Uuid
 import io.opentelemetry.semconv.incubating.LogIncubatingAttributes
 
@@ -31,6 +31,7 @@ class EmbraceLogService(
 ) : LogService {
 
     private val behavior = configService.logMessageBehavior
+    private val bypassLimitsValidation = configService.isOnlyUsingOtelExporters()
     private val logCounters = mapOf(
         Severity.INFO to LogCounter(behavior::getInfoLogLimit),
         Severity.WARNING to LogCounter(behavior::getWarnLogLimit),
@@ -45,7 +46,7 @@ class EmbraceLogService(
         customLogAttrs: Map<String, String>,
         logAttachment: Attachment.EmbraceHosted?,
     ) {
-        val redactedProperties = redactSensitiveProperties(normalizeProperties(properties))
+        val redactedProperties = redactSensitiveProperties(sanitizeProperties(properties, bypassLimitsValidation))
         val attrs = createTelemetryAttributes(redactedProperties, customLogAttrs)
 
         val schemaProvider: (TelemetryAttributes) -> SchemaType = when {

embrace-android-core/src/main/kotlin/io/embrace/android/embracesdk/internal/utils/PropertyUtils.kt

@@ -10,42 +10,21 @@ object PropertyUtils {
 
     const val MAX_PROPERTY_SIZE: Int = 10
 
-    /**
-     * This method will normalize the map by applying the following rules:
-     *
-     * - Null key registries will be discarded.
-     * - Null value registries will be renamed to null as a String.
-     * - Cap the properties map to a maximum of [PropertyUtils.MAX_PROPERTY_SIZE] properties.
-     *
-     * @param properties properties to be normalized.
-     * @return a normalized Map of the provided properties.
-     */
-    @JvmStatic
-    fun sanitizeProperties(properties: Map<String, Any?>?): Map<String, Any> {
-        properties ?: return emptyMap()
-
-        return properties.entries
-            .take(MAX_PROPERTY_SIZE)
-            .associate { Pair(it.key, checkIfSerializable(it.value)) }
-    }
-
-    @JvmStatic
-    fun normalizeProperties(properties: Map<String, Any>?): Map<String, Any>? {
-        var normalizedProperties: Map<String, Any> = HashMap()
-        if (properties != null) {
-            runCatching {
-                normalizedProperties = sanitizeProperties(properties)
-            }
-            return normalizedProperties
+    fun sanitizeProperties(properties: Map<String, Any>?, bypassPropertyLimit: Boolean = false): Map<String, Any> {
+        return if (properties == null) {
+            emptyMap()
         } else {
-            return null
+            runCatching {
+                if (bypassPropertyLimit) {
+                    properties.entries
+                } else {
+                    properties.entries.take(MAX_PROPERTY_SIZE)
+                }.associate { Pair(it.key, checkIfSerializable(it.value)) }
+            }.getOrDefault(emptyMap())
         }
     }
 
-    private fun checkIfSerializable(value: Any?): Any {
-        if (value == null) {
-            return "null"
-        }
+    private fun checkIfSerializable(value: Any): Any {
         if (!(value is Parcelable || value is Serializable)) {
             return "not serializable"
         }

embrace-android-core/src/test/java/io/embrace/android/embracesdk/internal/utils/PropertiesTest.kt

@@ -2,6 +2,8 @@ package io.embrace.android.embracesdk.internal.utils
 
 import io.embrace.android.embracesdk.internal.utils.PropertyUtils.sanitizeProperties
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
 import org.junit.Test
 
 internal class PropertyUtilsTest {
@@ -19,11 +21,6 @@ internal class PropertyUtilsTest {
         assertEquals(expected, sanitizeProperties(input as Map<String, Any>?))
     }
 
-    @Test
-    fun testNullValue() {
-        assertEquals("null", sanitizeProperties(mapOf("a" to null))["a"])
-    }
-
     @Test
     fun testSerializableValue() {
         val obj = SerializableClass()
@@ -35,6 +32,41 @@ internal class PropertyUtilsTest {
         assertEquals("not serializable", sanitizeProperties(mapOf("a" to UnSerializableClass()))["a"])
     }
 
+    @Test
+    fun `bypass limits`() {
+        val input = (0..20).associateBy { "$it" }
+        assertEquals(input.size, sanitizeProperties(input, true).size)
+    }
+
+    @Test
+    fun testPropertiesNormalization() {
+        val sourceMap: MutableMap<String, Any> = HashMap()
+        sourceMap[""] = "Empty key"
+        sourceMap["EmptyValue"] = ""
+        sourceMap["NullValue"] = ""
+        for (i in 1..9) {
+            sourceMap["Key$i"] = "Value$i"
+        }
+        val resultMap = sanitizeProperties(sourceMap)
+        assertTrue(
+            "Unexpected normalized map size.",
+            resultMap.size <= PropertyUtils.MAX_PROPERTY_SIZE
+        )
+        resultMap.entries.stream()
+            .peek { (key): Map.Entry<String, Any> ->
+                assertNotNull(
+                    "Unexpected normalized map key: NULL.",
+                    key
+                )
+            }
+            .peek { (_, value): Map.Entry<String, Any> ->
+                assertNotNull(
+                    "Unexpected normalized map value: NULL.",
+                    value
+                )
+            }
+    }
+
     private class SerializableClass : java.io.Serializable
     private class UnSerializableClass
 }