Adjust log level for serialize/deserialize and encrypt/decrypt.

Author: marcin-cebo

pubnub-kotlin/pubnub-kotlin-impl/src/main/kotlin/com/pubnub/internal/crypto/CryptoModuleImpl.kt

@@ -41,7 +41,7 @@ class CryptoModuleImpl(
     private val headerParser: HeaderParser = HeaderParser(logConfig)
 
     override fun encrypt(data: ByteArray): ByteArray {
-        logDebugMessage("Encrypting data of size: ${data.size} bytes")
+        logTraceMessage("Encrypting data of size: ${data.size} bytes")
 
         val cryptorId = primaryCryptor.id()
         validateData(data)
@@ -54,36 +54,36 @@ class CryptoModuleImpl(
             val cryptorHeader = headerParser.createCryptorHeader(cryptorId, metadata)
             cryptorHeader + encryptedData
         }
-        logDebugMessage("Encrypting successful")
+        logTraceMessage("Encrypting successful")
         return result
     }
 
     override fun decrypt(encryptedData: ByteArray): ByteArray {
-        logDebugMessage("Decrypting data of size: ${encryptedData.size} bytes")
+        logTraceMessage("Decrypting data of size: ${encryptedData.size} bytes")
 
         validateData(encryptedData)
         val parsedData: ParseResult<out ByteArray> = headerParser.parseDataWithHeader(encryptedData)
         val decryptedData: ByteArray =
             when (parsedData) {
                 is ParseResult.NoHeader -> {
-                    logDebugMessage("Using legacy cryptor for decryption")
+                    logTraceMessage("Using legacy cryptor for decryption")
                     getDecryptedDataForLegacyCryptor(encryptedData)
                 }
 
                 is ParseResult.Success -> {
-                    logDebugMessage("Using cryptor with header for decryption")
+                    logTraceMessage("Using cryptor with header for decryption")
                     getDecryptedDataForCryptorWithHeader(parsedData)
                 }
             }
-        logDebugMessage("Decryption successful")
+        logTraceMessage("Decryption successful")
         return decryptedData
     }
 
     override fun encryptStream(stream: InputStream): InputStream {
-        logDebugMessage("Encrypting stream")
+        logTraceMessage("Encrypting stream")
         val bufferedInputStream = validateStreamAndReturnBuffered(stream)
         val (metadata, encryptedData) = primaryCryptor.encryptStream(bufferedInputStream)
-        logDebugMessage("Encrypting stream successful")
+        logTraceMessage("Encrypting stream successful")
         return if (primaryCryptor.id().contentEquals(LEGACY_CRYPTOR_ID)) {
             encryptedData
         } else {
@@ -93,7 +93,7 @@ class CryptoModuleImpl(
     }
 
     override fun decryptStream(encryptedData: InputStream): InputStream {
-        logDebugMessage("Decrypting stream")
+        logTraceMessage("Decrypting stream")
         val bufferedInputStream = validateStreamAndReturnBuffered(encryptedData)
         return when (val parsedHeader = headerParser.parseDataWithHeader(bufferedInputStream)) {
             ParseResult.NoHeader -> {
@@ -119,8 +119,8 @@ class CryptoModuleImpl(
         }
     }
 
-    private fun logDebugMessage(message: String) {
-        log.debug(LogMessage(message = LogMessageContent.Text(message)))
+    private fun logTraceMessage(message: String) {
+        log.trace(LogMessage(message = LogMessageContent.Text(message)))
     }
 
     private fun validateCryptorIdSize(cryptorId: ByteArray) {

pubnub-kotlin/pubnub-kotlin-impl/src/main/kotlin/com/pubnub/internal/managers/MapperManager.kt

@@ -234,11 +234,11 @@ class MapperManager(private val logConfig: LogConfig) {
         input: JsonElement?,
         clazz: Class<T>,
     ): T {
-        log.debug(LogMessage(message = LogMessageContent.Text("Deserializing message content")))
+        log.trace(LogMessage(message = LogMessageContent.Text("Deserializing message content")))
 
         val result = this.objectMapper.fromJson(input, clazz) as T
 
-        log.debug(LogMessage(message = LogMessageContent.Text("Message deserialized successfully")))
+        log.trace(LogMessage(message = LogMessageContent.Text("Message deserialized successfully")))
 
         return result
     }
@@ -251,7 +251,7 @@ class MapperManager(private val logConfig: LogConfig) {
     }
 
     fun toJson(input: Any?): String {
-        log.debug(LogMessage(message = LogMessageContent.Text("Serializing message content")))
+        log.trace(LogMessage(message = LogMessageContent.Text("Serializing message content")))
         try {
             val result = if (input is List<*> && input.javaClass.isAnonymousClass) {
                 objectMapper.toJson(input, List::class.java)
@@ -263,7 +263,7 @@ class MapperManager(private val logConfig: LogConfig) {
                 objectMapper.toJson(input)
             }
 
-            log.debug(LogMessage(message = LogMessageContent.Text("Message serialized successfully")))
+            log.trace(LogMessage(message = LogMessageContent.Text("Message serialized successfully")))
 
             return result
         } catch (e: JsonParseException) {