Use method instead of property for LogField.keyForLoggingContext

We want to encourage calling this just once for a scope, storing it in
a local variable, to reduce calls to the abstract method.

Author: hermannm

src/commonMain/kotlin/dev/hermannm/devlog/LogField.kt

@@ -82,7 +82,7 @@ public sealed class LogField(
    * context to identify the value as raw JSON (so we can write the JSON unescaped in
    * `LoggingContextJsonFieldWriter`).
    */
-  internal abstract val keyForLoggingContext: String
+  internal abstract fun getKeyForLoggingContext(): String
 
   /**
    * Returns false if the field should not be included in the log (used by
@@ -102,21 +102,22 @@ public sealed class LogField(
 
 @PublishedApi
 internal open class StringLogField(key: String, value: String) : LogField(key, value) {
-  final override val keyForLoggingContext: String
-    get() = key
+  final override fun getKeyForLoggingContext(): String = key
 }
 
 @PublishedApi
 internal open class JsonLogField(
     key: String,
     value: String,
-    final override val keyForLoggingContext: String =
+    private val keyForLoggingContext: String =
         if (ADD_JSON_SUFFIX_TO_LOGGING_CONTEXT_KEYS) {
           key + LOGGING_CONTEXT_JSON_KEY_SUFFIX
         } else {
           key
         }
 ) : LogField(key, value) {
+  final override fun getKeyForLoggingContext(): String = keyForLoggingContext
+
   @PublishedApi
   internal companion object {
     /**

src/commonTest/kotlin/dev/hermannm/devlog/testutils/LoggingContextUtils.kt

@@ -12,7 +12,7 @@ internal infix fun LoggingContext.shouldContainExactly(map: Map<String, String>)
   contextFields.size shouldBe map.size
   for ((key, value) in map) {
     withClue({ "key='${key}', value='${value}'" }) {
-      val field = contextFields.find { field -> field.keyForLoggingContext == key }
+      val field = contextFields.find { field -> field.getKeyForLoggingContext() == key }
       field.shouldNotBeNull()
       field.value shouldBe value
     }

src/jvmMain/kotlin/dev/hermannm/devlog/LoggingContext.jvm.kt

@@ -27,6 +27,7 @@ internal actual object LoggingContext {
 
     for (index in fields.indices) {
       val field = fields[index]
+      val keyForLoggingContext = field.getKeyForLoggingContext()
 
       // Skip duplicate keys in the field array
       if (isDuplicateField(field, index, fields)) {
@@ -51,30 +52,30 @@ internal actual object LoggingContext {
            * here. The previous field will then be restored by [removeFields] after the context
            * exits.
            */
-          if (field.key != field.keyForLoggingContext) {
+          if (field.key != keyForLoggingContext) {
             MDC.remove(field.key)
           }
         }
       }
 
       /**
-       * [JsonLogField] adds a suffix to [LogField.keyForLoggingContext], i.e. it will be different
-       * from [LogField.key]. In this case, we want to check existing context field values for both
-       * [LogField.key] _and_ [LogField.keyForLoggingContext].
+       * [JsonLogField] adds a suffix to `keyForLoggingContext`, i.e. it will be different from
+       * [LogField.key]. In this case, we want to check existing context field values for both `key`
+       * _and_ `keyForLoggingContext`.
        */
-      if (field.key != field.keyForLoggingContext && existingValue == null) {
-        existingValue = MDC.get(field.keyForLoggingContext)
+      if (field.key != keyForLoggingContext && existingValue == null) {
+        existingValue = MDC.get(keyForLoggingContext)
         when (existingValue) {
           null -> {}
           field.value -> continue
           else -> {
             overwrittenFields =
-                overwrittenFields.set(index, field.keyForLoggingContext, existingValue, fields.size)
+                overwrittenFields.set(index, keyForLoggingContext, existingValue, fields.size)
           }
         }
       }
 
-      MDC.put(field.keyForLoggingContext, field.value)
+      MDC.put(keyForLoggingContext, field.value)
     }
 
     return overwrittenFields
@@ -92,6 +93,7 @@ internal actual object LoggingContext {
   ) {
     for (index in fields.indices) {
       val field = fields[index]
+      val keyForLoggingContext = field.getKeyForLoggingContext()
 
       // Skip duplicate keys, like we do in addFields
       if (isDuplicateField(field, index, fields)) {
@@ -106,12 +108,12 @@ internal actual object LoggingContext {
          * to call `MDC.remove` below (these may not always match for [JsonLogField] - see docstring
          * over `MDC.remove` in [addFields]).
          */
-        if (overwrittenKey == field.keyForLoggingContext) {
+        if (overwrittenKey == keyForLoggingContext) {
           continue
         }
       }
 
-      MDC.remove(field.keyForLoggingContext)
+      MDC.remove(keyForLoggingContext)
     }
   }