RUMM-55 Add the Log loggerName property

dd-sdk-android/src/androidTest/kotlin/com/datadog/android/internal/utils/utils.kt

@@ -32,7 +32,8 @@ internal fun randomLog(forge: Forge): Log {
         networkInfo = NetworkInfo(
             carrierName = forge.anAlphaNumericalString(),
             carrierId = forge.anInt()
-        )
+        ),
+        loggerName = forge.anAlphabeticalString()
     )
 }
 

dd-sdk-android/src/main/kotlin/com/datadog/android/log/Logger.kt

@@ -31,6 +31,7 @@ private constructor(
     val serviceName: String,
     val datadogLogsEnabled: Boolean,
     val logcatLogsEnabled: Boolean,
+    val loggerName: String,
     private val logWriter: LogWriter,
     internal val networkInfoProvider: NetworkInfoProvider?
 ) {
@@ -122,6 +123,7 @@ private constructor(
 
         private var logStrategy: LogStrategy? = null
         private var networkInfoProvider: NetworkInfoProvider? = null
+        private var loggerName: String = Datadog.packageName
 
         /**
          * Builds a [Logger] based on the current state of this Builder.
@@ -133,6 +135,7 @@ private constructor(
                 serviceName = serviceName,
                 datadogLogsEnabled = datadogLogsEnabled,
                 logcatLogsEnabled = logcatLogsEnabled,
+                loggerName = loggerName,
                 networkInfoProvider = if (networkInfoEnabled && datadogLogsEnabled) {
                     networkInfoProvider ?: Datadog.getNetworkInfoProvider()
                 } else null
@@ -185,6 +188,15 @@ private constructor(
             return this
         }
 
+        /**
+         * Use this if you want to set a custom name for this logger.
+         * @param name the logger custom name (default = application package name)
+         */
+        fun setLoggerName(name: String): Builder {
+            loggerName = name
+            return this
+        }
+
         private fun overrideLogStrategy(strategy: LogStrategy): Builder {
             logStrategy = strategy
             return this
@@ -366,7 +378,8 @@ private constructor(
             throwable = throwable,
             attributes = attributes.toMap(),
             tags = tags.toList(),
-            networkInfo = networkInfoProvider?.getLatestNetworkInfos()
+            networkInfo = networkInfoProvider?.getLatestNetworkInfos(),
+            loggerName = loggerName
         )
     }
 

dd-sdk-android/src/main/kotlin/com/datadog/android/log/internal/Log.kt

@@ -19,5 +19,6 @@ internal data class Log(
     val attributes: Map<String, Any?>,
     val tags: List<String>,
     val throwable: Throwable?,
-    val networkInfo: NetworkInfo?
+    val networkInfo: NetworkInfo?,
+    val loggerName: String
 )

dd-sdk-android/src/main/kotlin/com/datadog/android/log/internal/LogStrategy.kt

@@ -30,6 +30,9 @@ internal interface LogStrategy {
         internal const val TAG_ERROR_MESSAGE = "error.message"
         internal const val TAG_ERROR_STACK = "error.stack"
 
+        // THREAD RELATED TAGS
+        internal const val TAG_LOGGER_NAME = "logger.name"
+
         // ANDROID SPECIFIC TAGS
         internal const val TAG_NETWORK = "network"
         internal const val TAG_NETWORK_CONNECTIVITY = "connectivity"

dd-sdk-android/src/main/kotlin/com/datadog/android/log/internal/file/LogFileWriter.kt

@@ -84,6 +84,24 @@ internal class LogFileWriter(
         jsonLog.addProperty(LogStrategy.TAG_DATE, formattedDate)
 
         // Network Infos
+        addLogNetworkInfo(log, jsonLog)
+
+        // Custom Attributes
+        addLogAttributes(log, jsonLog)
+
+        // Tags
+        addLogTags(log, jsonLog)
+
+        // Throwable
+        addLogThrowable(log, jsonLog)
+
+        return jsonLog.toString()
+    }
+
+    private fun addLogNetworkInfo(
+        log: Log,
+        jsonLog: JsonObject
+    ) {
         val info = log.networkInfo
         if (info != null) {
             val network = JsonObject()
@@ -96,8 +114,34 @@ internal class LogFileWriter(
             }
             jsonLog.add(LogStrategy.TAG_NETWORK, network)
         }
+    }
 
-        // Custom Attributes
+    private fun addLogThrowable(
+        log: Log,
+        jsonLog: JsonObject
+    ) {
+        log.throwable?.let {
+            jsonLog.addProperty(LogStrategy.TAG_LOGGER_NAME, log.loggerName)
+            val sw = StringWriter()
+            it.printStackTrace(PrintWriter(sw))
+            jsonLog.addProperty(LogStrategy.TAG_ERROR_KIND, it.javaClass.simpleName)
+            jsonLog.addProperty(LogStrategy.TAG_ERROR_MESSAGE, it.message)
+            jsonLog.addProperty(LogStrategy.TAG_ERROR_STACK, sw.toString())
+        }
+    }
+
+    private fun addLogTags(
+        log: Log,
+        jsonLog: JsonObject
+    ) {
+        val tags = log.tags.joinToString(",")
+        jsonLog.addProperty(LogStrategy.TAG_DATADOG_TAGS, tags)
+    }
+
+    private fun addLogAttributes(
+        log: Log,
+        jsonLog: JsonObject
+    ) {
         log.attributes
             .filter { it.key.isNotBlank() && it.key !in LogStrategy.reservedAttributes }
             .forEach {
@@ -114,21 +158,6 @@ internal class LogFileWriter(
                 }
                 jsonLog.add(it.key, jsonValue)
             }
-
-        // Tags
-        val tags = log.tags.joinToString(",")
-        jsonLog.addProperty(LogStrategy.TAG_DATADOG_TAGS, tags)
-
-        // Throwable
-        log.throwable?.let {
-            val sw = StringWriter()
-            it.printStackTrace(PrintWriter(sw))
-            jsonLog.addProperty(LogStrategy.TAG_ERROR_KIND, it.javaClass.simpleName)
-            jsonLog.addProperty(LogStrategy.TAG_ERROR_MESSAGE, it.message)
-            jsonLog.addProperty(LogStrategy.TAG_ERROR_STACK, sw.toString())
-        }
-
-        return jsonLog.toString()
     }
 
     private fun obfuscateAndWriteLog(strLog: String) {

dd-sdk-android/src/test/kotlin/com/datadog/android/DatadogTest.kt

@@ -93,7 +93,7 @@ internal class DatadogTest {
         }
     }
 
-    fun `it will initialize all dependencies at initialize`(){
+    fun `it will initialize all dependencies at initialize`() {
         Datadog.initialize(mockContext, fakeToken)
 
         assertThat(Datadog.packageName).isEqualTo(packageName)

dd-sdk-android/src/test/kotlin/com/datadog/android/log/LoggerBuilderTest.kt

@@ -17,14 +17,12 @@ import com.nhaarman.mockitokotlin2.whenever
 import fr.xgouchet.elmyr.Forge
 import fr.xgouchet.elmyr.annotation.Forgery
 import fr.xgouchet.elmyr.junit5.ForgeExtension
-import java.io.File
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.AfterEach
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.extension.ExtendWith
 import org.junit.jupiter.api.extension.Extensions
-import org.junit.jupiter.api.io.TempDir
 import org.mockito.Mock
 import org.mockito.junit.jupiter.MockitoExtension
 import org.mockito.junit.jupiter.MockitoSettings
@@ -42,15 +40,16 @@ internal class LoggerBuilderTest {
     @Mock
     lateinit var mockContext: Context
 
-    @TempDir
-    lateinit var tempDir: File
+    lateinit var packageName: String
 
     @BeforeEach
     fun `set up Datadog`(forge: Forge) {
+        packageName = forge.anAlphabeticalString()
         val mockContext: Context = mock()
         val mockConnectivityMgr: ConnectivityManager = mock()
         val mockNetworkInfo: NetworkInfo = mock()
         whenever(mockContext.applicationContext) doReturn mockContext
+        whenever(mockContext.packageName) doReturn packageName
         whenever(mockContext.getSystemService(Context.CONNECTIVITY_SERVICE))
             .doReturn(mockConnectivityMgr)
         whenever(mockConnectivityMgr.activeNetworkInfo) doReturn mockNetworkInfo
@@ -73,6 +72,7 @@ internal class LoggerBuilderTest {
         assertThat(logger.datadogLogsEnabled).isTrue()
         assertThat(logger.logcatLogsEnabled).isFalse()
         assertThat(logger.networkInfoProvider).isNull()
+        assertThat(logger.loggerName).isEqualTo(packageName)
     }
 
     @Test
@@ -123,4 +123,15 @@ internal class LoggerBuilderTest {
             assertThat(logger.networkInfoProvider).isNull()
         }
     }
+
+    @Test
+    fun `buider can set the logger name`(@Forgery forge: Forge) {
+        val loggerName = forge.anAlphabeticalString()
+
+        val logger = Logger.Builder()
+            .setLoggerName(loggerName)
+            .build()
+
+        assertThat(logger.loggerName).isEqualTo(loggerName)
+    }
 }

dd-sdk-android/src/test/kotlin/com/datadog/android/log/LoggerFullFeaturesTest.kt

@@ -49,6 +49,7 @@ internal class LoggerFullFeaturesTest {
     lateinit var fakeMessage: String
     lateinit var fakeUserAgent: String
     lateinit var fakeNetworkInfo: NetworkInfo
+    lateinit var fakeLoggerName: String
 
     @Mock
     lateinit var mockContext: Context
@@ -73,13 +74,15 @@ internal class LoggerFullFeaturesTest {
         fakeMessage = forge.anAlphabeticalString()
         fakeUserAgent = forge.anAlphabeticalString()
         fakeNetworkInfo = forge.getForgery()
+        fakeLoggerName = forge.anAlphabeticalString()
         whenever(mockNetworkInfoProvider.getLatestNetworkInfos()) doReturn fakeNetworkInfo
 
         testedLogger = Logger.Builder()
             .setServiceName(fakeServiceName)
             .setLogcatLogsEnabled(true)
             .setDatadogLogsEnabled(true)
             .setNetworkInfoEnabled(true)
+            .setLoggerName(fakeLoggerName)
             .withLogStrategy(mockLogStrategy)
             .withNetworkInfoProvider(mockNetworkInfoProvider)
             .build()
@@ -167,6 +170,7 @@ internal class LoggerFullFeaturesTest {
                 .hasMessage(fakeMessage)
                 .hasTimestamp(timestamp)
                 .hasNetworkInfo(fakeNetworkInfo)
+                .hasLoggerName(fakeLoggerName)
         }
     }
 

dd-sdk-android/src/test/kotlin/com/datadog/android/log/assertj/LogAssert.kt

@@ -73,12 +73,20 @@ internal class LogAssert(actual: Log) :
         assertThat(actual.networkInfo)
             .overridingErrorMessage(
                 "Expected log to have networkInfo $expected " +
-                    "but was ${actual.networkInfo}"
+                        "but was ${actual.networkInfo}"
             )
             .isEqualTo(expected)
         return this
     }
 
+    fun hasLoggerName(expected: String) {
+        assertThat(actual.loggerName)
+            .overridingErrorMessage(
+                "Expected log to have loggerName $expected but was ${actual.loggerName}"
+            )
+            .isEqualTo(expected)
+    }
+
     companion object {
 
         private const val TIMESTAMP_THRESHOLD_MS = 50

dd-sdk-android/src/test/kotlin/com/datadog/android/log/forge/LogForgeryFactory.kt

@@ -27,7 +27,8 @@ internal class LogForgeryFactory : ForgeryFactory<Log> {
             throwable = forge.getForgery(),
             attributes = forge.exhaustiveAttributes(),
             tags = forge.exhaustiveTags(),
-            networkInfo = forge.getForgery()
+            networkInfo = forge.getForgery(),
+            loggerName = forge.anAlphabeticalString(size = forge.aTinyInt())
         )
     }
 

dd-sdk-android/src/test/kotlin/com/datadog/android/log/internal/LogStrategyTest.kt

@@ -195,7 +195,8 @@ internal abstract class LogStrategyTest {
                 carrierName = forge.anAlphabeticalString(size = 256)
             ),
             throwable = ArrayIndexOutOfBoundsException(forge.anAlphabeticalString()),
-            timestamp = forge.aLong()
+            timestamp = forge.aLong(),
+            loggerName = forge.anAlphabeticalString()
         )
 
         testedLogWriter.writeLog(bigLog)
@@ -409,9 +410,16 @@ internal abstract class LogStrategyTest {
             throwable.printStackTrace(PrintWriter(sw))
 
             assertThat(jsonObject)
+                .hasField(LogStrategy.TAG_LOGGER_NAME, log.loggerName)
                 .hasField(LogStrategy.TAG_ERROR_KIND, throwable.javaClass.simpleName)
                 .hasField(LogStrategy.TAG_ERROR_MESSAGE, throwable.message)
                 .hasField(LogStrategy.TAG_ERROR_STACK, sw.toString())
+        } else {
+            assertThat(jsonObject)
+                .doesNotHaveField(LogStrategy.TAG_LOGGER_NAME)
+                .doesNotHaveField(LogStrategy.TAG_ERROR_KIND)
+                .doesNotHaveField(LogStrategy.TAG_ERROR_MESSAGE)
+                .doesNotHaveField(LogStrategy.TAG_ERROR_STACK)
         }
     }