[RKOTLIN-1038] Implement new log category for RealmLogger

CHANGELOG.md

@@ -9,6 +9,7 @@ This release will bump the Realm file format from version 23 to 24. Opening a fi
 ### Enhancements
 * Support for RealmLists and RealmDictionaries in `RealmAny`. (Issue [#1434](https://github.com/realm/realm-kotlin/issues/1434))
 * Optimized `RealmList.indexOf()` and `RealmList.contains()` using Core implementation of operations instead of iterating elements and comparing them in Kotlin. (Issue [#1625](https://github.com/realm/realm-kotlin/pull/1666) [RKOTLIN-995](https://jira.mongodb.org/browse/RKOTLIN-995)).
+* Add support for filtering logs by category. (Issue [#1691](https://github.com/realm/realm-kotlin/issues/1691) [JIRA](https://jira.mongodb.org/browse/RKOTLIN-1038))
 
 ### Fixed
 * None.

packages/cinterop/src/commonMain/kotlin/io/realm/kotlin/internal/interop/Callback.kt

@@ -43,7 +43,7 @@ interface SyncSessionTransferCompletionCallback {
 
 interface LogCallback {
     // Passes core log levels as shorts to avoid unnecessary jumping between the SDK and JNI
-    fun log(logLevel: Short, category: String?, message: String?)
+    fun log(logLevel: Short, categoryValue: String, message: String?)
 }
 
 interface SyncBeforeClientResetHandler {

packages/cinterop/src/commonMain/kotlin/io/realm/kotlin/internal/interop/RealmInterop.kt

@@ -617,6 +617,12 @@ expect object RealmInterop {
 
     fun realm_set_log_level(level: CoreLogLevel)
 
+    fun realm_set_log_level_category(category: String, level: CoreLogLevel)
+
+    fun realm_get_log_level_category(category: String): CoreLogLevel
+
+    fun realm_get_category_names(): List<String>
+
     fun realm_app_config_set_metadata_mode(
         appConfig: RealmAppConfigurationPointer,
         metadataMode: MetadataMode

packages/cinterop/src/jvm/jni/java_class_global_def.hpp

@@ -45,6 +45,7 @@ class JavaClassGlobalDef {
     JavaClassGlobalDef(JNIEnv* env)
         : m_java_util_hashmap(env, "java/util/HashMap", false)
         , m_java_lang_int(env, "java/lang/Integer", false)
+        , m_java_lang_string(env, "java/lang/String", false)
         , m_kotlin_jvm_functions_function0(env, "kotlin/jvm/functions/Function0", false)
         , m_kotlin_jvm_functions_function1(env, "kotlin/jvm/functions/Function1", false)
         , m_io_realm_kotlin_internal_interop_sync_network_transport(env, "io/realm/kotlin/internal/interop/sync/NetworkTransport", false)
@@ -74,6 +75,7 @@ class JavaClassGlobalDef {
 
     jni_util::JavaClass m_java_util_hashmap;
     jni_util::JavaClass m_java_lang_int;
+    jni_util::JavaClass m_java_lang_string;
     jni_util::JavaClass m_kotlin_jvm_functions_function0;
     jni_util::JavaClass m_kotlin_jvm_functions_function1;
     jni_util::JavaClass m_io_realm_kotlin_internal_interop_sync_network_transport;
@@ -133,6 +135,11 @@ class JavaClassGlobalDef {
         return env->NewObject(instance()->m_java_lang_int, init, value);
     }
 
+    inline static const jni_util::JavaClass& java_lang_string()
+    {
+        return instance()->m_java_lang_string;
+    }
+
     inline static const jni_util::JavaClass& network_transport_class()
     {
         return instance()->m_io_realm_kotlin_internal_interop_sync_network_transport;

packages/cinterop/src/jvm/kotlin/io/realm/kotlin/internal/interop/RealmInterop.kt

@@ -1365,9 +1365,21 @@ actual object RealmInterop {
         realmc.realm_set_log_level(level.priority)
     }
 
+    actual fun realm_set_log_level_category(category: String, level: CoreLogLevel) {
+        realmc.realm_set_log_level_category(category, level.priority)
+    }
+
+    actual fun realm_get_log_level_category(category: String): CoreLogLevel =
+        CoreLogLevel.valueFromPriority(realmc.realm_get_log_level_category(category).toShort())
+
+    actual fun realm_get_category_names(): List<String> {
+        val names: Array<String> = realmc.realm_get_log_category_names() as Array<String>
+        return names.asList()
+    }
+
     actual fun realm_app_config_set_metadata_mode(
         appConfig: RealmAppConfigurationPointer,
-        metadataMode: MetadataMode
+        metadataMode: MetadataMode,
     ) {
         realmc.realm_app_config_set_metadata_mode(
             appConfig.cptr(),

packages/cinterop/src/nativeDarwin/kotlin/io/realm/kotlin/internal/interop/RealmInterop.kt

@@ -15,6 +15,7 @@
  */
 // TODO https://github.com/realm/realm-kotlin/issues/889
 @file:Suppress("TooGenericExceptionThrown", "TooGenericExceptionCaught")
+@file:OptIn(ExperimentalForeignApi::class)
 
 package io.realm.kotlin.internal.interop
 
@@ -54,6 +55,7 @@ import kotlinx.cinterop.CPointerVar
 import kotlinx.cinterop.CPointerVarOf
 import kotlinx.cinterop.CValue
 import kotlinx.cinterop.CVariable
+import kotlinx.cinterop.ExperimentalForeignApi
 import kotlinx.cinterop.LongVar
 import kotlinx.cinterop.MemScope
 import kotlinx.cinterop.StableRef
@@ -2511,7 +2513,7 @@ actual object RealmInterop {
         realm_wrapper.realm_set_log_callback(
             staticCFunction { userData, category, logLevel, message ->
                 val userDataLogCallback = safeUserData<LogCallback>(userData)
-                userDataLogCallback.log(logLevel.toShort(), category?.toKString(), message?.toKString())
+                userDataLogCallback.log(logLevel.toShort(), category!!.toKString(), message?.toKString())
             },
             StableRef.create(callback).asCPointer(),
             staticCFunction { userData -> disposeUserData<() -> LogCallback>(userData) }
@@ -2522,9 +2524,28 @@ actual object RealmInterop {
         realm_wrapper.realm_set_log_level(level.priority.toUInt())
     }
 
+    actual fun realm_set_log_level_category(category: String, level: CoreLogLevel) {
+        realm_wrapper.realm_set_log_level_category(category, level.priority.toUInt())
+    }
+
+    actual fun realm_get_log_level_category(category: String): CoreLogLevel =
+        CoreLogLevel.valueFromPriority(realm_wrapper.realm_get_log_level_category(category).toShort())
+
+    actual fun realm_get_category_names(): List<String> {
+        memScoped {
+            val namesCount = realm_wrapper.realm_get_category_names(0u, null)
+            val namesBuffer = allocArray<CPointerVar<ByteVar>>(namesCount.toInt())
+            realm_wrapper.realm_get_category_names(namesCount, namesBuffer)
+
+            return List(namesCount.toInt()) {
+                namesBuffer[it].safeKString()
+            }
+        }
+    }
+
     actual fun realm_app_config_set_metadata_mode(
         appConfig: RealmAppConfigurationPointer,
-        metadataMode: MetadataMode
+        metadataMode: MetadataMode,
     ) {
         realm_wrapper.realm_app_config_set_metadata_mode(
             appConfig.cptr(),

packages/jni-swig-stub/src/main/jni/realm_api_helpers.cpp

@@ -960,8 +960,8 @@ realm_sync_socket_t* realm_sync_websocket_new(int64_t sync_client_config_ptr, jo
 // *** END - WebSocket Client (Platform Networking) *** //
 
 void set_log_callback(jobject log_callback) {
-auto jenv = get_env(true);
-realm_set_log_callback([](void *userdata, const char* category, realm_log_level_e level, const char *message) {
+auto jenv = get_env(false);
+realm_set_log_callback([](void *userdata, const char *category, realm_log_level_e level, const char *message) {
                                auto log_callback = static_cast<jobject>(userdata);
                                auto jenv = get_env(true);
 
@@ -970,7 +970,7 @@ realm_set_log_callback([](void *userdata, const char* category, realm_log_level_
                                static JavaMethod log_method(jenv,
                                                             JavaClassGlobalDef::log_callback(),
                                                             "log",
-                                                            "(SLjava/lang/String;Ljava/lang/String;)V");
+                                                    "(SLjava/lang/String;Ljava/lang/String;)V");
 
                                push_local_frame(jenv, 2);
                                jenv->CallVoidMethod(log_callback, log_method, java_level, to_jstring(jenv, category), to_jstring(jenv, message));
@@ -1370,3 +1370,23 @@ realm_class_info_t_cleanup(realm_class_info_t * value) {
     delete[] value->primary_key;
     delete[] value->name;
 }
+
+jobjectArray realm_get_log_category_names() {
+    JNIEnv* env = get_env(true);
+
+    size_t namesCount = realm_get_category_names(0, nullptr);
+
+    const char** category_names = new const char*[namesCount];
+    realm_get_category_names(namesCount, category_names);
+
+    auto array = env->NewObjectArray(namesCount, JavaClassGlobalDef::java_lang_string(), nullptr);
+
+    for(size_t i = 0; i < namesCount; i++) {
+        jstring string = env->NewStringUTF(category_names[i]);
+        env->SetObjectArrayElement(array, i, string);
+    }
+
+    delete[] category_names;
+
+    return array;
+}

packages/jni-swig-stub/src/main/jni/realm_api_helpers.h

@@ -51,7 +51,7 @@ realm_http_transport_t*
 realm_network_transport_new(jobject network_transport);
 
 void
-set_log_callback(jobject log_callbac);
+set_log_callback(jobject log_callback);
 
 realm_scheduler_t*
 realm_create_scheduler(jobject dispatchScheduler);
@@ -161,4 +161,6 @@ bool realm_sync_websocket_message(int64_t observer_ptr, jbyteArray data, size_t
 
 void realm_sync_websocket_closed(int64_t observer_ptr, bool was_clean, int error_code, const char* reason);
 
+jobjectArray realm_get_log_category_names();
+
 #endif //TEST_REALM_API_HELPERS_H

packages/library-base/src/androidMain/kotlin/io/realm/kotlin/internal/platform/LogCatLogger.kt

@@ -16,11 +16,14 @@
 package io.realm.kotlin.internal.platform
 
 import android.util.Log
+import io.realm.kotlin.internal.messageWithCategory
+import io.realm.kotlin.log.LogCategory
 import io.realm.kotlin.log.LogLevel
 import io.realm.kotlin.log.RealmLogger
 import java.io.PrintWriter
 import java.io.StringWriter
 import java.util.Locale
+import kotlin.math.min
 
 /**
  * Create a logger that outputs to Android LogCat.
@@ -29,13 +32,22 @@ import java.util.Locale
  * for message creation and formatting
  */
 internal class LogCatLogger(
-    override val tag: String = "REALM",
-    override val level: LogLevel
+    private val tag: String,
 ) : RealmLogger {
 
-    override fun log(level: LogLevel, throwable: Throwable?, message: String?, vararg args: Any?) {
+    override fun log(
+        category: LogCategory,
+        level: LogLevel,
+        throwable: Throwable?,
+        message: String?,
+        vararg args: Any?,
+    ) {
         val priority: Int = level.priority
-        val logMessage: String = prepareLogMessage(throwable, message, *args)
+        val logMessage: String = prepareLogMessage(
+            throwable = throwable,
+            message = messageWithCategory(category, message),
+            args = *args
+        )
 
         // Short circuit if message can fit into a single line in LogCat
         if (logMessage.length < MAX_LOG_LENGTH) {
@@ -50,7 +62,7 @@ internal class LogCatLogger(
             var newline = logMessage.indexOf('\n', i)
             newline = if (newline != -1) newline else length
             do {
-                val end = Math.min(newline, i + MAX_LOG_LENGTH)
+                val end = min(newline, i + MAX_LOG_LENGTH)
                 val part = logMessage.substring(i, end)
                 printMessage(priority, part)
                 i = end

packages/library-base/src/androidMain/kotlin/io/realm/kotlin/internal/platform/SystemUtilsAndroid.kt

@@ -5,7 +5,6 @@ import io.realm.kotlin.internal.RealmInitializer
 import io.realm.kotlin.internal.RealmInstantImpl
 import io.realm.kotlin.internal.interop.SyncConnectionParams
 import io.realm.kotlin.internal.util.Exceptions
-import io.realm.kotlin.log.LogLevel
 import io.realm.kotlin.log.RealmLogger
 import io.realm.kotlin.types.RealmInstant
 import java.io.FileNotFoundException
@@ -37,8 +36,8 @@ public actual fun assetFileAsStream(assetFilename: String): InputStream = try {
 }
 
 // Returns the default logger for the platform
-public actual fun createDefaultSystemLogger(tag: String, logLevel: LogLevel): RealmLogger =
-    LogCatLogger(tag, logLevel)
+public actual fun createDefaultSystemLogger(tag: String): RealmLogger =
+    LogCatLogger(tag)
 
 public actual fun currentTime(): RealmInstant {
     return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {

packages/library-base/src/commonMain/kotlin/io/realm/kotlin/RealmConfiguration.kt

@@ -150,7 +150,7 @@ public interface RealmConfiguration : Configuration {
 
         override fun build(): RealmConfiguration {
             verifyConfig()
-            val realmLogger = ContextLogger("Sdk")
+            val realmLogger = ContextLogger()
 
             // Sync configs might not set 'name' but local configs always do, therefore it will
             // never be null here

packages/library-base/src/commonMain/kotlin/io/realm/kotlin/internal/ContextLogger.kt

@@ -1,7 +1,9 @@
 package io.realm.kotlin.internal
 
+import io.realm.kotlin.log.LogCategory
 import io.realm.kotlin.log.LogLevel
 import io.realm.kotlin.log.RealmLog
+import io.realm.kotlin.log.SdkLogCategory
 
 /**
  * Internal logger class used to inject context aware information into log message
@@ -81,10 +83,17 @@ public class ContextLogger(public val context: String? = null) {
     }
 
     private inline fun doLog(level: LogLevel, throwable: Throwable?) {
-        RealmLog.doLog(level, throwable, null)
+        RealmLog.doLog(LogCategory.Realm.Sdk, level, throwable, null)
     }
 
-    private inline fun doLog(level: LogLevel, throwable: Throwable?, message: () -> String?, vararg args: Any?) {
-        RealmLog.doLog(level, throwable, message, *args)
+    private inline fun doLog(
+        level: LogLevel,
+        throwable: Throwable?,
+        message: () -> String?,
+        vararg args: Any?,
+    ) {
+        if (level >= RealmLog.getLevel(SdkLogCategory)) {
+            RealmLog.doLog(LogCategory.Realm.Sdk, level, throwable, message(), *args)
+        }
     }
 }

packages/library-base/src/commonMain/kotlin/io/realm/kotlin/internal/LogUtils.kt

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2024 Realm Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.realm.kotlin.internal
+
+import io.realm.kotlin.internal.interop.CoreLogLevel
+import io.realm.kotlin.log.LogCategory
+import io.realm.kotlin.log.LogCategoryImpl
+import io.realm.kotlin.log.LogLevel
+
+internal fun LogLevel.toCoreLogLevel(): CoreLogLevel {
+    return when (this) {
+        LogLevel.ALL -> CoreLogLevel.RLM_LOG_LEVEL_ALL
+        LogLevel.TRACE -> CoreLogLevel.RLM_LOG_LEVEL_TRACE
+        LogLevel.DEBUG -> CoreLogLevel.RLM_LOG_LEVEL_DEBUG
+        LogLevel.INFO -> CoreLogLevel.RLM_LOG_LEVEL_INFO
+        LogLevel.WARN -> CoreLogLevel.RLM_LOG_LEVEL_WARNING
+        LogLevel.ERROR -> CoreLogLevel.RLM_LOG_LEVEL_ERROR
+        LogLevel.WTF -> CoreLogLevel.RLM_LOG_LEVEL_FATAL
+        LogLevel.NONE -> CoreLogLevel.RLM_LOG_LEVEL_OFF
+    }
+}
+
+internal fun CoreLogLevel.fromCoreLogLevel(): LogLevel {
+    return when (this) {
+        CoreLogLevel.RLM_LOG_LEVEL_ALL -> LogLevel.ALL
+        CoreLogLevel.RLM_LOG_LEVEL_TRACE -> LogLevel.TRACE
+        CoreLogLevel.RLM_LOG_LEVEL_DEBUG,
+        CoreLogLevel.RLM_LOG_LEVEL_DETAIL -> LogLevel.DEBUG
+        CoreLogLevel.RLM_LOG_LEVEL_INFO -> LogLevel.INFO
+        CoreLogLevel.RLM_LOG_LEVEL_WARNING -> LogLevel.WARN
+        CoreLogLevel.RLM_LOG_LEVEL_ERROR -> LogLevel.ERROR
+        CoreLogLevel.RLM_LOG_LEVEL_FATAL -> LogLevel.WTF
+        CoreLogLevel.RLM_LOG_LEVEL_OFF -> LogLevel.NONE
+        else -> throw IllegalArgumentException("Invalid core log level: $this")
+    }
+}
+
+internal fun newCategory(
+    name: String,
+    parent: LogCategory? = null,
+): LogCategory = LogCategoryImpl(name, parent).also { category ->
+    categoriesByPath["$category"] = category
+}
+
+// at package level as a workaround to ensure compatibility with darwin and jvm
+internal val categoriesByPath: MutableMap<String, LogCategory> = mutableMapOf()
+
+internal fun messageWithCategory(
+    category: LogCategory,
+    message: String?,
+): String? = if (message.isNullOrBlank()) { null } else {
+    "[${category.name}] $message"
+}

packages/library-base/src/commonMain/kotlin/io/realm/kotlin/internal/platform/SystemUtils.kt

@@ -2,7 +2,6 @@
 package io.realm.kotlin.internal.platform
 
 import io.realm.kotlin.internal.interop.SyncConnectionParams
-import io.realm.kotlin.log.LogLevel
 import io.realm.kotlin.log.RealmLogger
 import io.realm.kotlin.types.RealmInstant
 import kotlin.jvm.JvmName
@@ -123,7 +122,7 @@ public expect fun prepareRealmFilePath(directoryPath: String, filename: String):
 /**
  * Returns the default logger for the platform.
  */
-public expect fun createDefaultSystemLogger(tag: String, logLevel: LogLevel = LogLevel.NONE): RealmLogger
+public expect fun createDefaultSystemLogger(tag: String): RealmLogger
 
 /**
  * Return the current thread id.