From 2d2017bef2567a9ec1ed2c1b6b125526df6055a6 Mon Sep 17 00:00:00 2001 From: Alexander Yevsyukov Date: Thu, 2 Jul 2026 12:52:45 +0100 Subject: [PATCH 1/6] Fix 25 latent test failures surfaced by enabling JUnit Platform on KMP jvmTest The kmp-module convention never enabled the JUnit Platform on the KMP jvmTest task, so :logging:jvmTest silently discovered zero tests while behavior drifted from the Flogger contract during the Kotlin migration. Enable the platform (mirroring module-testing, without an engine filter since Kotest provides its own engine) and fix the failures it surfaced. Production fixes: - MetadataKey.cast() throws ClassCastException on type mismatch again instead of silently returning null. - checkCannotRepeat() throws IllegalArgumentException per the documented contract of findValue()/getSingleValue(), with a corrected message. - MetadataHandler.Builder.addRepeatedHandler() requires a repeatable key (the check was inverted). - SimpleProcessor guards repeated values with an unmodifiable iterator (the unmodifiable-list wrapping was lost in the Java-to-Kotlin port). - LogContext evaluates the lazy message lambda inside AbstractLogger.write(), so a throwing or reentrant toString() is handled by the recursion guard and robust error handling instead of propagating (or overflowing the stack). A null message now reaches the backend unmodified. - AbstractLogger.atConfig() maps to Level.CONFIG, not Level.INFO. - Logging-error timestamps include milliseconds and the UTC offset. - LogPerBucketingStrategy.byClass()/byClassName() use the Java class, restoring identity semantics and fixing an NPE for local and anonymous classes. - ScopedLoggingContext.Builder.run(Runnable) is restored; without it, `.run { }` silently bound to the Kotlin stdlib extension and never installed the context. Test fixes: eager invocation counters outside lazy log lambdas, the spread operator for vararg arrays, Kotlin qualified names in LogLevelMapSpec, and message-format alignments. The module-local jvmTest workaround in otel-backend is superseded by the convention change and removed. Co-Authored-By: Claude Fable 5 --- .agents/tasks/logging-jvmtest-triage.md | 69 +++++++++++++++++++ backends/otel-backend/build.gradle.kts | 9 --- .../src/main/kotlin/kmp-module.gradle.kts | 12 ++++ .../kotlin/io/spine/logging/AbstractLogger.kt | 52 +++++++++++--- .../kotlin/io/spine/logging/LogContext.kt | 23 ++++--- .../spine/logging/LogPerBucketingStrategy.kt | 6 +- .../kotlin/io/spine/logging/MetadataKey.kt | 18 +++-- .../spine/logging/backend/MetadataHandler.kt | 5 +- .../logging/backend/MetadataProcessor.kt | 31 ++++++--- .../logging/context/ScopedLoggingContext.kt | 17 ++++- .../io/spine/logging/AbstractLoggerSpec.kt | 5 +- .../spine/logging/context/LogLevelMapSpec.kt | 8 ++- .../kotlin/io/spine/logging/JvmLoggerSpec.kt | 21 ++++-- .../kotlin/io/spine/logging/LogContextSpec.kt | 12 ++-- .../spine/logging/backend/AnyExtsJvmSpec.kt | 4 +- .../logging/test/LoggingCompatibilityTest.kt | 6 +- 16 files changed, 226 insertions(+), 72 deletions(-) create mode 100644 .agents/tasks/logging-jvmtest-triage.md diff --git a/.agents/tasks/logging-jvmtest-triage.md b/.agents/tasks/logging-jvmtest-triage.md new file mode 100644 index 000000000..ffbdf60c4 --- /dev/null +++ b/.agents/tasks/logging-jvmtest-triage.md @@ -0,0 +1,69 @@ +# Triage and fix the 25 latent `:logging:jvmTest` failures + +## Problem + +Enabling the JUnit Platform on the KMP `jvmTest` task (see +`kmp-jvmtest-junit-platform.md`, branch `claude/angry-hugle-d62cfe`) surfaced +25 latent test failures in `:logging:jvmTest` (232 run, 207 pass) which +accumulated while the task silently discovered zero tests. + +Reproduce with JDK 17: +`./gradlew :logging:jvmTest --rerun` (requires the `kmp-module.gradle.kts` +fix from that branch; a copy is applied in this worktree). + +## Triage results + +Production fixes (behavior drifted from the Flogger contract during the +Kotlin migration): + +1. `MetadataKey.cast` — returned `null` on type mismatch; now throws + `ClassCastException` (Flogger parity; `null` input still passes through). +2. `checkCannotRepeat` — used `check` (ISE) with an inverted message; now + `require` (IAE) per the documented contract of `findValue`/`getSingleValue`. +3. `MetadataHandler.Builder.addRepeatedHandler` — called `checkCannotRepeat`, + the exact opposite of Flogger's `checkArgument(key.canRepeat())`; inverted. +4. `SimpleProcessor` — lost `Collections.unmodifiableList` in translation + (`e.setValue(e.value as List<*>)` is a no-op cast); repeated-value + iterators are now wrapped in a read-only `UnmodifiableIterator`. +5. `LogContext.log {}` — evaluated the message lambda *before* + `AbstractLogger.write`, escaping the recursion guard and error handling; + evaluation now happens inside `write(data, prepare)`. + Also, a `null` message now reaches the backend unmodified + (was string-concatenated into `"null"`). +6. `AbstractLogger` error-report timestamps — used `LocalDateTime.Formats.ISO` + (no offset, variable millis); now `yyyy-MM-dd'T'HH:mm:ss.SSSZ` equivalent. +7. `AbstractLogger.atConfig()` — mapped to `Level.INFO` (copy-paste); + now `Level.CONFIG`. +8. `LogPerBucketingStrategy.byClass()/byClassName()` — used + `key::class`/`qualifiedName!!` (identity not guaranteed; NPE for local and + anonymous classes); now `key.javaClass`/`key.javaClass.name`. +9. `ScopedLoggingContext.Builder.run(Runnable)` — missing member (silently + shadowed by stdlib `kotlin.run`, which never installs the context); added. + +Test fixes (tests carried stale or Java-specific expectations): + +- `AbstractLoggerSpec` — case-insensitive match for the recursion message. +- `LogContextSpec` — `log { null }` expects a `null` literal (rendered as + `"null"` by `SimpleMessageFormatter`), not `""`. +- `JvmLoggerSpec` — invocation counters moved out of lazy message lambdas + (lambdas only run for statements which log); the log-site method name is + the sanitized synthetic lambda method. +- `LogLevelMapSpec` — `String::class` registers as `kotlin.String` + (consistent with `LoggingFactory` logger names), not `java.lang.String`. +- `LoggingCompatibilityTest` — Kotlin requires `*` spread to pass an array + as `vararg`. +- `AnyExtsJvmSpec` — expect Spine's backtick diagnostic style. + +## Status + +- [x] All 25 failures reproduced and triaged +- [x] Production fixes applied +- [x] Test fixes applied +- [x] `:logging:jvmTest` green (232/232) +- [x] Full `./gradlew build --continue` green (all modules, detekt, Kover) + +## Notes + +- The `update-copyright` PostToolUse hook strips `The Flogger Authors; ` + from headers; restored in all touched files (keep watching this). +- Delete this file on merge to master. diff --git a/backends/otel-backend/build.gradle.kts b/backends/otel-backend/build.gradle.kts index d9e25b9e7..9955f30b8 100644 --- a/backends/otel-backend/build.gradle.kts +++ b/backends/otel-backend/build.gradle.kts @@ -95,12 +95,3 @@ dependencies { // Registers the `fastTest`/`slowTest` tasks and the `*Spec`/`*Test` filter, // matching the core `logging` module. tasks.registerTestTasks() - -// The `kmp-module` convention does not put the JUnit Platform on the JVM test -// task (it configures only the `jvm-module` `test` task), so enable it here. -tasks.named("jvmTest") { - useJUnitPlatform() - testLogging { - events("passed", "skipped", "failed") - } -} diff --git a/buildSrc/src/main/kotlin/kmp-module.gradle.kts b/buildSrc/src/main/kotlin/kmp-module.gradle.kts index 636a84d22..cb790b79b 100644 --- a/buildSrc/src/main/kotlin/kmp-module.gradle.kts +++ b/buildSrc/src/main/kotlin/kmp-module.gradle.kts @@ -38,6 +38,7 @@ import io.spine.gradle.javac.configureJavac import io.spine.gradle.kotlin.setFreeCompilerArgs import io.spine.gradle.publish.IncrementGuard import io.spine.gradle.report.license.LicenseReporter +import io.spine.gradle.testing.configureLogging /** * Configures this [Project] as a Kotlin Multiplatform module. @@ -162,11 +163,22 @@ java { * * Also, Kotlin and Java share the same test executor (JUnit), so tests * configuration is for both. + * + * The `jvmTest` task mirrors the setup made by `module-testing` for + * the `test` task of a `jvm-module` (`module-testing` itself cannot be + * applied here because it brings `java-library`, which conflicts with + * the Kotlin Multiplatform plugin). Unlike `module-testing`, no engine + * filter is imposed: `jvmTest` dependencies include the Kotest runner, + * which is a JUnit Platform engine of its own. */ tasks { withType().configureEach { configureJavac() } + named("jvmTest") { + useJUnitPlatform() + configureLogging() + } } /** diff --git a/logging/src/commonMain/kotlin/io/spine/logging/AbstractLogger.kt b/logging/src/commonMain/kotlin/io/spine/logging/AbstractLogger.kt index 31fd7d6b3..60f47a285 100644 --- a/logging/src/commonMain/kotlin/io/spine/logging/AbstractLogger.kt +++ b/logging/src/commonMain/kotlin/io/spine/logging/AbstractLogger.kt @@ -1,5 +1,5 @@ /* - * Copyright 2023, The Flogger Authors; 2025, TeamDev. All rights reserved. + * Copyright 2023, The Flogger Authors; 2026, TeamDev. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -33,8 +33,12 @@ import io.spine.logging.util.RecursionDepth import kotlin.time.Duration.Companion.nanoseconds import kotlin.time.ExperimentalTime import kotlin.time.Instant +import kotlinx.datetime.LocalDate import kotlinx.datetime.LocalDateTime import kotlinx.datetime.TimeZone +import kotlinx.datetime.UtcOffset +import kotlinx.datetime.format.char +import kotlinx.datetime.offsetAt import kotlinx.datetime.toLocalDateTime /** @@ -66,10 +70,32 @@ public abstract class AbstractLogger> protected constructo private const val MAX_ALLOWED_RECURSION_DEPTH = 100 /** - * The format for date-time values in log data. + * The format for the local date-time part of timestamps in log data. + * + * Produces an ISO 8601 date-time with milliseconds, e.g., `2026-07-02T00:29:31.123`. */ @JvmField - val dateTimeFormat = LocalDateTime.Formats.ISO + val dateTimeFormat = LocalDateTime.Format { + date(LocalDate.Formats.ISO) + char('T') + hour() + char(':') + minute() + char(':') + second() + char('.') + secondFraction(3) + } + + /** + * The format for the four-digit UTC offset part of timestamps in log data, + * e.g., `+0100`. + */ + @JvmField + val offsetFormat = UtcOffset.Format { + offsetHours() + offsetMinutesOfHour() + } } /** @@ -114,9 +140,9 @@ public abstract class AbstractLogger> protected constructo public fun atInfo(): API = at(Level.INFO) /** - * A convenience method for at([Level.INFO]). + * A convenience method for at([Level.CONFIG]). */ - public fun atConfig(): API = at(Level.INFO) + public fun atConfig(): API = at(Level.CONFIG) /** * A convenience method for at([Level.FINE]). @@ -188,15 +214,23 @@ public abstract class AbstractLogger> protected constructo * * This method also guards against unbounded reentrant logging, and will suppress further * logging if it detects significant recursion has occurred. + * + * @param data The log statement data. + * @param prepare Completes [data] within the recursion guard right before the backend call. + * Use it for evaluation which may invoke user code, such as computing a lazy log message, + * so that exceptions and reentrant logging it causes are handled the same way as those + * coming from the backend. */ + @JvmOverloads @Suppress("TooGenericExceptionCaught") - public fun write(data: LogData) { + public fun write(data: LogData, prepare: () -> Unit = {}) { // Note: Recursion checking should not be in the `LoggerBackend`. // There are many backends and they can call into other backends. // We only want the counter incremented per log statement. try { RecursionDepth.enterLogStatement().use { depth -> if (depth.getValue() <= MAX_ALLOWED_RECURSION_DEPTH) { + prepare() backend.log(data) } else { reportError( @@ -262,8 +296,10 @@ public abstract class AbstractLogger> protected constructo val instant = Instant.fromEpochMilliseconds( data.timestampNanos.nanoseconds.inWholeMilliseconds ) - val dateTime = instant.toLocalDateTime(TimeZone.currentSystemDefault()) - return dateTimeFormat.format(dateTime) + val zone = TimeZone.currentSystemDefault() + val dateTime = instant.toLocalDateTime(zone) + val offset = zone.offsetAt(instant) + return dateTimeFormat.format(dateTime) + offsetFormat.format(offset) } } diff --git a/logging/src/commonMain/kotlin/io/spine/logging/LogContext.kt b/logging/src/commonMain/kotlin/io/spine/logging/LogContext.kt index b21562c7d..48c393f1c 100644 --- a/logging/src/commonMain/kotlin/io/spine/logging/LogContext.kt +++ b/logging/src/commonMain/kotlin/io/spine/logging/LogContext.kt @@ -1,5 +1,5 @@ /* - * Copyright 2023, The Flogger Authors; 2025, TeamDev. All rights reserved. + * Copyright 2023, The Flogger Authors; 2026, TeamDev. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -410,12 +410,11 @@ protected constructor( /** * Make the backend logging call. * - * This method takes a single string parameter as it's always called with one string argument. + * The given [message] is evaluated within the recursion guard of the logger, + * so that a throwing or reentrant `toString()` of a logged value cannot escape + * the error handling of [AbstractLogger.write]. */ - private fun logImpl(arg: String?) { - val prefix = loggingDomain?.messagePrefix ?: "" - this.literalArg = prefix + arg - + private fun logImpl(message: () -> String?) { // Right at the end of processing add any tags injected by the platform. // Any tags supplied at the log site are merged with the injected tags // (though this should be very rare). @@ -429,8 +428,11 @@ protected constructor( } addMetadata(Key.TAGS, finalTags) } - // Pass the completed log data to the backend (it should not be modified after this point). - getLogger().write(this) + // Pass the log data to the backend (it should not be modified after this point). + getLogger().write(this) { + // A `null` message is passed to the backend unmodified. + literalArg = message()?.let { (loggingDomain?.messagePrefix ?: "") + it } + } } // ---- Log site injection (used by pre-processors and special cases) ---- @@ -558,17 +560,16 @@ protected constructor( public final override fun log() { if (shouldLog()) { - logImpl("") + logImpl { "" } } } public final override fun log(message: () -> String?) { if (shouldLog()) { - logImpl(message()) + logImpl(message) } } - /** * The predefined metadata keys used by the default logging API. * diff --git a/logging/src/commonMain/kotlin/io/spine/logging/LogPerBucketingStrategy.kt b/logging/src/commonMain/kotlin/io/spine/logging/LogPerBucketingStrategy.kt index e298be5ef..575f03287 100644 --- a/logging/src/commonMain/kotlin/io/spine/logging/LogPerBucketingStrategy.kt +++ b/logging/src/commonMain/kotlin/io/spine/logging/LogPerBucketingStrategy.kt @@ -1,5 +1,5 @@ /* - * Copyright 2023, The Flogger Authors; 2025, TeamDev. All rights reserved. + * Copyright 2023, The Flogger Authors; 2026, TeamDev. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -122,7 +122,7 @@ public abstract class LogPerBucketingStrategy protected constructor( * are effectively singletons. */ private val BY_CLASS = object : LogPerBucketingStrategy("ByClass") { - override fun apply(key: Any): Any = key::class + override fun apply(key: Any): Any = key.javaClass } /** @@ -131,7 +131,7 @@ public abstract class LogPerBucketingStrategy protected constructor( * are effectively singletons. */ private val BY_CLASS_NAME = object : LogPerBucketingStrategy("ByClassName") { - override fun apply(key: Any): Any = key::class.qualifiedName!! + override fun apply(key: Any): Any = key.javaClass.name /* This is a naturally interned value, so no need to call `intern()`. */ } diff --git a/logging/src/commonMain/kotlin/io/spine/logging/MetadataKey.kt b/logging/src/commonMain/kotlin/io/spine/logging/MetadataKey.kt index 5c6347fe8..f13f67eaf 100644 --- a/logging/src/commonMain/kotlin/io/spine/logging/MetadataKey.kt +++ b/logging/src/commonMain/kotlin/io/spine/logging/MetadataKey.kt @@ -143,18 +143,22 @@ public open class MetadataKey( this(label, clazz, canRepeat, true) /** - * Cast an arbitrary value to the type of this key. + * Casts an arbitrary value to the type of this key. + * + * @throws ClassCastException if the given value is not an instance of the key type. */ public fun cast(value: Any?): T? { if (value == null) { return null } - return if (clazz.isInstance(value)) { + if (clazz.isInstance(value)) { @Suppress("UNCHECKED_CAST") - value as T - } else { - null + return value as T } + throw ClassCastException( + "The value `$value` cannot be cast to `${clazz.qualifiedName}`" + + " required by the key `$this`." + ) } /** @@ -376,8 +380,8 @@ private fun createBloomFilterMaskFromSystemHashcode(instance: Any): Long { * Checks that a metadata key cannot be used for repeated values. * * @param key The metadata key to check. - * @throws IllegalStateException if the key supports repeated values. + * @throws IllegalArgumentException if the key supports repeated values. */ internal fun checkCannotRepeat(key: MetadataKey<*>) { - check(!key.canRepeat) { "The key `$key` does not support repeated values." } + require(!key.canRepeat) { "The key `$key` must be single-valued." } } diff --git a/logging/src/commonMain/kotlin/io/spine/logging/backend/MetadataHandler.kt b/logging/src/commonMain/kotlin/io/spine/logging/backend/MetadataHandler.kt index 34cd86493..91f0a3eb6 100644 --- a/logging/src/commonMain/kotlin/io/spine/logging/backend/MetadataHandler.kt +++ b/logging/src/commonMain/kotlin/io/spine/logging/backend/MetadataHandler.kt @@ -1,5 +1,5 @@ /* - * Copyright 2023, The Flogger Authors; 2025, TeamDev. All rights reserved. + * Copyright 2023, The Flogger Authors; 2026, TeamDev. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -28,7 +28,6 @@ package io.spine.logging.backend import com.google.errorprone.annotations.CanIgnoreReturnValue import io.spine.logging.MetadataKey -import io.spine.logging.checkCannotRepeat /** * Callback API for logger backend implementations to handle metadata keys/values. @@ -152,7 +151,7 @@ public abstract class MetadataHandler { key: MetadataKey, handler: RepeatedValueHandler ): Builder { - checkCannotRepeat(key) + require(key.canRepeat()) { "The key `$key` must support repeated values." } singleValueHandlers.remove(key) @Suppress("UNCHECKED_CAST") repeatedValueHandlers[key] = handler as RepeatedValueHandler<*, in C> diff --git a/logging/src/commonMain/kotlin/io/spine/logging/backend/MetadataProcessor.kt b/logging/src/commonMain/kotlin/io/spine/logging/backend/MetadataProcessor.kt index c3d471fa3..28d41d94a 100644 --- a/logging/src/commonMain/kotlin/io/spine/logging/backend/MetadataProcessor.kt +++ b/logging/src/commonMain/kotlin/io/spine/logging/backend/MetadataProcessor.kt @@ -1,5 +1,5 @@ /* - * Copyright 2023, The Flogger Authors; 2025, TeamDev. All rights reserved. + * Copyright 2023, The Flogger Authors; 2026, TeamDev. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -483,13 +483,6 @@ private class SimpleProcessor(scope: Metadata, logged: Metadata) : MetadataProce val map = LinkedHashMap, Any>() map.addTo(scope) map.addTo(logged) - // Wrap any repeated value lists to make them unmodifiable (required for correctness). - for (e in map.entries) { - if (e.key.canRepeat()) { - @Suppress("UNCHECKED_CAST") - e.setValue(e.value as List<*>) - } - } this.map = map } @@ -574,9 +567,29 @@ private fun MetadataHandler.dispatch( ) { if (key.canRepeat()) { @Suppress("UNCHECKED_CAST") - handleRepeated(key, (value as MutableList).iterator(), context) + handleRepeated(key, UnmodifiableIterator((value as List).iterator()), context) } else { @Suppress("UNCHECKED_CAST") handle(key, (value as T), context) } } + +/** + * Guards values of repeated keys from modification by handlers (required for correctness). + * + * The lists built by [MutableMap.addTo] are mutable, and exposing their iterators directly + * would allow a handler to remove values. Like [LightweightProcessor.ValueIterator], this + * wrapper satisfies casting to a mutable iterator but throws from [remove]. + */ +private class UnmodifiableIterator( + private val delegate: Iterator +) : MutableIterator { + + override fun hasNext(): Boolean = delegate.hasNext() + + override fun next(): T = delegate.next() + + override fun remove() { + throw UnsupportedOperationException() + } +} diff --git a/logging/src/commonMain/kotlin/io/spine/logging/context/ScopedLoggingContext.kt b/logging/src/commonMain/kotlin/io/spine/logging/context/ScopedLoggingContext.kt index 4d52e1774..06dd5a97e 100644 --- a/logging/src/commonMain/kotlin/io/spine/logging/context/ScopedLoggingContext.kt +++ b/logging/src/commonMain/kotlin/io/spine/logging/context/ScopedLoggingContext.kt @@ -1,5 +1,5 @@ /* - * Copyright 2023, The Flogger Authors; 2025, TeamDev. All rights reserved. + * Copyright 2023, The Flogger Authors; 2026, TeamDev. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -192,6 +192,21 @@ public abstract class ScopedLoggingContext protected constructor() { } } + /** + * Runs a runnable directly within a new context installed from this builder. + * + * Being a member, this method takes precedence over the [run][kotlin.run] + * extension from the standard library, which would otherwise execute + * the block without installing the context. + * + * @throws InvalidLoggingContextStateException + * if the context created during this method cannot + * be closed correctly (e.g., if a nested context has also been opened, + * but not closed). + */ + public fun run(r: Runnable): Unit = + wrap(r).run() + /** * Calls a function directly within a new context installed from this builder. */ diff --git a/logging/src/commonTest/kotlin/io/spine/logging/AbstractLoggerSpec.kt b/logging/src/commonTest/kotlin/io/spine/logging/AbstractLoggerSpec.kt index ba755c4c9..95cc7171c 100644 --- a/logging/src/commonTest/kotlin/io/spine/logging/AbstractLoggerSpec.kt +++ b/logging/src/commonTest/kotlin/io/spine/logging/AbstractLoggerSpec.kt @@ -1,5 +1,5 @@ /* - * Copyright 2019, The Flogger Authors; 2025, TeamDev. All rights reserved. + * Copyright 2019, The Flogger Authors; 2026, TeamDev. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -31,6 +31,7 @@ import io.kotest.matchers.collections.shouldBeEmpty import io.kotest.matchers.collections.shouldHaveSize import io.kotest.matchers.string.shouldBeEmpty import io.kotest.matchers.string.shouldContain +import io.kotest.matchers.string.shouldContainIgnoringCase import io.kotest.matchers.string.shouldMatch import io.kotest.matchers.string.shouldNotContain import io.spine.logging.backend.LogData @@ -141,7 +142,7 @@ internal class AbstractLoggerSpec { output shouldMatch TIMESTAMP_PREFIX output shouldContain LOGGING_ERROR output shouldContain this::class.simpleName!! - output shouldContain "unbounded recursion in log statement" + output shouldContainIgnoringCase "unbounded recursion in log statement" } @Test diff --git a/logging/src/commonTest/kotlin/io/spine/logging/context/LogLevelMapSpec.kt b/logging/src/commonTest/kotlin/io/spine/logging/context/LogLevelMapSpec.kt index 832a3b158..aae1b607b 100644 --- a/logging/src/commonTest/kotlin/io/spine/logging/context/LogLevelMapSpec.kt +++ b/logging/src/commonTest/kotlin/io/spine/logging/context/LogLevelMapSpec.kt @@ -1,5 +1,5 @@ /* - * Copyright 2019, The Flogger Authors; 2025, TeamDev. All rights reserved. + * Copyright 2019, The Flogger Authors; 2026, TeamDev. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -101,7 +101,11 @@ internal class LogLevelMapSpec { .build() levelMap["com.google"] shouldBe INFO levelMap["java.lang"] shouldBe WARNING - levelMap["java.lang.String"] shouldBe FINE + // Classes are registered under their Kotlin qualified names, matching + // the logger names produced by `LoggingFactory`. For the mapped type + // `String::class` this is `kotlin.String`, not `java.lang.String`. + levelMap["kotlin.String"] shouldBe FINE + levelMap["java.lang.String"] shouldBe WARNING } } diff --git a/logging/src/jvmTest/kotlin/io/spine/logging/JvmLoggerSpec.kt b/logging/src/jvmTest/kotlin/io/spine/logging/JvmLoggerSpec.kt index a1ed9fe0a..ac8016657 100644 --- a/logging/src/jvmTest/kotlin/io/spine/logging/JvmLoggerSpec.kt +++ b/logging/src/jvmTest/kotlin/io/spine/logging/JvmLoggerSpec.kt @@ -1,5 +1,5 @@ /* - * Copyright 2023, TeamDev. All rights reserved. + * Copyright 2026, TeamDev. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -76,8 +76,11 @@ internal class JvmLoggerSpec { System.err.println(consoleCheck) } consoleOutput shouldContain consoleCheck - val expectedMethodReference = "produce the output with the name of" + - " the logging class and calling method" + // The log statement above sits in the `tapConsole` lambda, so the calling + // method is reported as the synthetic lambda method, which carries + // the sanitized name of this test method. + val expectedMethodReference = "produce_the_output_with_the_name_of" + + "_the_logging_class_and_calling_method" consoleOutput shouldContain this::class.java.name consoleOutput shouldContain expectedMsg consoleOutput shouldContain expectedMethodReference @@ -293,11 +296,14 @@ internal class JvmLoggerSpec { val totalDuration = (invocations - 1) * intervalMillis val consoleOutput = tapConsole { var i = 1 - (0..totalDuration step intervalMillis).forEach { millis -> + (0..totalDuration step intervalMillis).forEach { _ -> + // Count invocations eagerly: the message lambda is only + // evaluated for statements which actually log. + val invocation = i++ logger.atInfo() .every(invocationLimit) .atMostEvery(timeLimitMillis, MILLISECONDS) - .log { numberedMessage(i++) } + .log { numberedMessage(invocation) } sleep(intervalMillis) } } @@ -363,10 +369,13 @@ internal class JvmLoggerSpec { var invoked = 0 val consoleOutput = tapConsole { for (millis in 0..totalDuration step intervalMillis) { + // Count invocations eagerly: the message lambda is only + // evaluated for statements which actually log. + val invocation = ++invoked logger.atInfo() .every(invocationLimit) .atMostEvery(timeLimitMillis, MILLISECONDS) - .log { timeAndSerialStamp(++invoked, millis) } + .log { timeAndSerialStamp(invocation, millis) } sleep(intervalMillis) } } diff --git a/logging/src/jvmTest/kotlin/io/spine/logging/LogContextSpec.kt b/logging/src/jvmTest/kotlin/io/spine/logging/LogContextSpec.kt index 18f6ec7b2..1f5fd10af 100644 --- a/logging/src/jvmTest/kotlin/io/spine/logging/LogContextSpec.kt +++ b/logging/src/jvmTest/kotlin/io/spine/logging/LogContextSpec.kt @@ -1,5 +1,5 @@ /* - * Copyright 2025, TeamDev. All rights reserved. + * Copyright 2026, TeamDev. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -39,6 +39,7 @@ import io.spine.logging.Level.Companion.WARNING import io.spine.logging.LogContext.Companion.specializeLogSiteKeyFromMetadata import io.spine.logging.LogContext.Key import io.spine.logging.LogSiteLookup.logSite +import io.spine.logging.backend.SimpleMessageFormatter import io.spine.logging.backend.given.FakeMetadata import io.spine.logging.backend.given.shouldContain import io.spine.logging.backend.given.shouldContainInOrder @@ -113,9 +114,6 @@ internal class LogContextSpec { backend.lastLogged shouldHaveMessage MESSAGE_LITERAL } - - - @Test fun `accept a literal message`() { logger.at(INFO).log { MESSAGE_LITERAL } @@ -576,8 +574,6 @@ internal class LogContextSpec { backend.lastLogged.shouldHaveMessage("") } - - /** * Tests that a `null` literal is passed unmodified to the backend * without throwing an exception. @@ -593,7 +589,9 @@ internal class LogContextSpec { fun `log 'null' if given message is 'null'`() { logger.atInfo().log { null } backend.lastLogged.let { - it shouldHaveMessage ("") + it shouldHaveMessage null + // The literal is rendered as the text `null` when formatted. + SimpleMessageFormatter.getLiteralLogMessage(it) shouldBe "null" } } diff --git a/logging/src/jvmTest/kotlin/io/spine/logging/backend/AnyExtsJvmSpec.kt b/logging/src/jvmTest/kotlin/io/spine/logging/backend/AnyExtsJvmSpec.kt index 9f2da7349..e4556e095 100644 --- a/logging/src/jvmTest/kotlin/io/spine/logging/backend/AnyExtsJvmSpec.kt +++ b/logging/src/jvmTest/kotlin/io/spine/logging/backend/AnyExtsJvmSpec.kt @@ -1,5 +1,5 @@ /* - * Copyright 2025, TeamDev. All rights reserved. + * Copyright 2026, TeamDev. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -42,7 +42,7 @@ internal class AnyExtsJvmSpec { fun `objects that return 'null' on 'toString()'`() { val badToString = BadToString() badToString.safeToString() shouldContain badToString::class.simpleName!! - badToString.safeToString() shouldContain "toString() returned null" + badToString.safeToString() shouldContain "`toString()` returned `null`" } } } diff --git a/logging/src/jvmTest/kotlin/io/spine/logging/test/LoggingCompatibilityTest.kt b/logging/src/jvmTest/kotlin/io/spine/logging/test/LoggingCompatibilityTest.kt index d08f15134..d0334829a 100644 --- a/logging/src/jvmTest/kotlin/io/spine/logging/test/LoggingCompatibilityTest.kt +++ b/logging/src/jvmTest/kotlin/io/spine/logging/test/LoggingCompatibilityTest.kt @@ -1,5 +1,5 @@ /* - * Copyright 2025, TeamDev. All rights reserved. + * Copyright 2026, TeamDev. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -70,7 +70,9 @@ internal class LoggingCompatibilityTest { fun `accepting array as 'varargs'`() { val output = tapConsole { val args = arrayOf("arg1", "arg2") - logger.atInfo().logVarargs("Message with array: %s %s", args) + // Unlike Java, Kotlin requires the spread operator to pass + // an array as `vararg` arguments. + logger.atInfo().logVarargs("Message with array: %s %s", *args) } output shouldContain "Message with array: arg1 arg2" } From 98309be2618f3a58a9a468739a7f9ae7ef9b11ff Mon Sep 17 00:00:00 2001 From: Alexander Yevsyukov Date: Thu, 2 Jul 2026 13:25:05 +0100 Subject: [PATCH 2/6] Bump version -> `2.0.0-SNAPSHOT.422` --- version.gradle.kts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/version.gradle.kts b/version.gradle.kts index 7bb15faf0..42a0dc25b 100644 --- a/version.gradle.kts +++ b/version.gradle.kts @@ -24,4 +24,4 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -extra.set("versionToPublish", "2.0.0-SNAPSHOT.421") +val versionToPublish: String by extra("2.0.0-SNAPSHOT.422") From ac2896b36771ab8ef8a152d8c3f27e565d25f81a Mon Sep 17 00:00:00 2001 From: Alexander Yevsyukov Date: Thu, 2 Jul 2026 13:38:01 +0100 Subject: [PATCH 3/6] Update dependency reports --- docs/dependencies/dependencies.md | 72 +++++++++++++++---------------- docs/dependencies/pom.xml | 2 +- 2 files changed, 37 insertions(+), 37 deletions(-) diff --git a/docs/dependencies/dependencies.md b/docs/dependencies/dependencies.md index 5906b3a00..03143968c 100644 --- a/docs/dependencies/dependencies.md +++ b/docs/dependencies/dependencies.md @@ -1,6 +1,6 @@ -# Dependencies of `io.spine:spine-logging-context-tests:2.0.0-SNAPSHOT.421` +# Dependencies of `io.spine:spine-logging-context-tests:2.0.0-SNAPSHOT.422` ## Runtime 1. **Group** : org.jetbrains. **Name** : annotations. **Version** : 26.1.0. @@ -441,14 +441,14 @@ The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using +This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-fixtures:2.0.0-SNAPSHOT.421` +# Dependencies of `io.spine:spine-logging-fixtures:2.0.0-SNAPSHOT.422` ## Runtime ## Compile, tests, and tooling @@ -1240,14 +1240,14 @@ This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using +This report was generated on **Thu Jul 02 12:40:53 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-grpc-context:2.0.0-SNAPSHOT.421` +# Dependencies of `io.spine:spine-logging-grpc-context:2.0.0-SNAPSHOT.422` ## Runtime 1. **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2. @@ -2094,14 +2094,14 @@ This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using +This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-jul-backend:2.0.0-SNAPSHOT.421` +# Dependencies of `io.spine:spine-logging-jul-backend:2.0.0-SNAPSHOT.422` ## Runtime 1. **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2. @@ -2932,14 +2932,14 @@ This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using +This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-jvm-default-platform:2.0.0-SNAPSHOT.421` +# Dependencies of `io.spine:spine-logging-jvm-default-platform:2.0.0-SNAPSHOT.422` ## Runtime 1. **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2. @@ -3786,14 +3786,14 @@ This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using +This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-jvm-jul-backend-grpc-context:2.0.0-SNAPSHOT.421` +# Dependencies of `io.spine:spine-logging-jvm-jul-backend-grpc-context:2.0.0-SNAPSHOT.422` ## Runtime 1. **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2. @@ -4692,14 +4692,14 @@ This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using +This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-jvm-jul-backend-std-context:2.0.0-SNAPSHOT.421` +# Dependencies of `io.spine:spine-logging-jvm-jul-backend-std-context:2.0.0-SNAPSHOT.422` ## Runtime 1. **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2. @@ -5590,14 +5590,14 @@ This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using +This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-jvm-log4j2-backend-std-context:2.0.0-SNAPSHOT.421` +# Dependencies of `io.spine:spine-logging-jvm-log4j2-backend-std-context:2.0.0-SNAPSHOT.422` ## Runtime 1. **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2. @@ -6508,14 +6508,14 @@ This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using +This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-jvm-slf4j-jdk14-backend-std-context:2.0.0-SNAPSHOT.421` +# Dependencies of `io.spine:spine-logging-jvm-slf4j-jdk14-backend-std-context:2.0.0-SNAPSHOT.422` ## Runtime 1. **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2. @@ -7414,14 +7414,14 @@ This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using +This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-jvm-slf4j-reload4j-backend-std-context:2.0.0-SNAPSHOT.421` +# Dependencies of `io.spine:spine-logging-jvm-slf4j-reload4j-backend-std-context:2.0.0-SNAPSHOT.422` ## Runtime 1. **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2. @@ -8324,14 +8324,14 @@ This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using +This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-log4j2-backend:2.0.0-SNAPSHOT.421` +# Dependencies of `io.spine:spine-logging-log4j2-backend:2.0.0-SNAPSHOT.422` ## Runtime 1. **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2. @@ -9206,14 +9206,14 @@ This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using +This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging:2.0.0-SNAPSHOT.421` +# Dependencies of `io.spine:spine-logging:2.0.0-SNAPSHOT.422` ## Runtime ## Compile, tests, and tooling @@ -10013,14 +10013,14 @@ This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using +This report was generated on **Thu Jul 02 12:40:53 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine.tools:logging-testlib:2.0.0-SNAPSHOT.421` +# Dependencies of `io.spine.tools:logging-testlib:2.0.0-SNAPSHOT.422` ## Runtime ## Compile, tests, and tooling @@ -10832,14 +10832,14 @@ This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using +This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-otel-backend:2.0.0-SNAPSHOT.421` +# Dependencies of `io.spine:spine-logging-otel-backend:2.0.0-SNAPSHOT.422` ## Runtime ## Compile, tests, and tooling @@ -11739,14 +11739,14 @@ This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using +This report was generated on **Thu Jul 02 12:40:53 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-otel-backend-bootstrap:2.0.0-SNAPSHOT.421` +# Dependencies of `io.spine:spine-logging-otel-backend-bootstrap:2.0.0-SNAPSHOT.422` ## Runtime 1. **Group** : com.google.auto.service. **Name** : auto-service-annotations. **Version** : 1.1.1. @@ -13157,14 +13157,14 @@ This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using +This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-probe-backend:2.0.0-SNAPSHOT.421` +# Dependencies of `io.spine:spine-logging-probe-backend:2.0.0-SNAPSHOT.422` ## Runtime 1. **Group** : com.google.auto.service. **Name** : auto-service-annotations. **Version** : 1.1.1. @@ -14015,14 +14015,14 @@ This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using +This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-smoke-test:2.0.0-SNAPSHOT.421` +# Dependencies of `io.spine:spine-logging-smoke-test:2.0.0-SNAPSHOT.422` ## Runtime 1. **Group** : com.fasterxml.jackson. **Name** : jackson-bom. **Version** : 2.22.0. @@ -14921,14 +14921,14 @@ This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using +This report was generated on **Thu Jul 02 12:40:53 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-std-context:2.0.0-SNAPSHOT.421` +# Dependencies of `io.spine:spine-logging-std-context:2.0.0-SNAPSHOT.422` ## Runtime 1. **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2. @@ -15759,6 +15759,6 @@ This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 00:29:12 WEST 2026** using +This report was generated on **Thu Jul 02 12:40:53 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). \ No newline at end of file diff --git a/docs/dependencies/pom.xml b/docs/dependencies/pom.xml index e02e4ed5d..91fc404e2 100644 --- a/docs/dependencies/pom.xml +++ b/docs/dependencies/pom.xml @@ -10,7 +10,7 @@ all modules and does not describe the project structure per-subproject. --> io.spine logging -2.0.0-SNAPSHOT.421 +2.0.0-SNAPSHOT.422 2015 From 210c1e869d53daebbdd43c18af4e0ee3458af17b Mon Sep 17 00:00:00 2001 From: Alexander Yevsyukov Date: Thu, 2 Jul 2026 14:32:59 +0100 Subject: [PATCH 4/6] Address review findings - Do not invoke a user-supplied toString() when composing the ClassCastException message in MetadataKey.cast(); report the value class instead. - Document the IllegalArgumentException thrown by addRepeatedHandler(). - Document the null pass-through of MetadataKey.cast(). - Clarify comments around the deferred message evaluation in LogContext. - Restore the Flogger attribution in the MetadataKey.kt header. Co-Authored-By: Claude Fable 5 --- .../src/commonMain/kotlin/io/spine/logging/LogContext.kt | 5 +++-- .../commonMain/kotlin/io/spine/logging/MetadataKey.kt | 9 ++++++--- .../kotlin/io/spine/logging/backend/MetadataHandler.kt | 1 + .../kotlin/io/spine/logging/backend/MetadataProcessor.kt | 2 +- 4 files changed, 11 insertions(+), 6 deletions(-) diff --git a/logging/src/commonMain/kotlin/io/spine/logging/LogContext.kt b/logging/src/commonMain/kotlin/io/spine/logging/LogContext.kt index 48c393f1c..a30de0149 100644 --- a/logging/src/commonMain/kotlin/io/spine/logging/LogContext.kt +++ b/logging/src/commonMain/kotlin/io/spine/logging/LogContext.kt @@ -408,7 +408,7 @@ protected constructor( } /** - * Make the backend logging call. + * Makes the backend logging call. * * The given [message] is evaluated within the recursion guard of the logger, * so that a throwing or reentrant `toString()` of a logged value cannot escape @@ -428,7 +428,8 @@ protected constructor( } addMetadata(Key.TAGS, finalTags) } - // Pass the log data to the backend (it should not be modified after this point). + // Pass the log data to the backend. The message is completed within the + // recursion guard of `write()`; the data must not be modified after that. getLogger().write(this) { // A `null` message is passed to the backend unmodified. literalArg = message()?.let { (loggingDomain?.messagePrefix ?: "") + it } diff --git a/logging/src/commonMain/kotlin/io/spine/logging/MetadataKey.kt b/logging/src/commonMain/kotlin/io/spine/logging/MetadataKey.kt index f13f67eaf..6edf75aca 100644 --- a/logging/src/commonMain/kotlin/io/spine/logging/MetadataKey.kt +++ b/logging/src/commonMain/kotlin/io/spine/logging/MetadataKey.kt @@ -1,5 +1,5 @@ /* - * Copyright 2026, TeamDev. All rights reserved. + * Copyright 2023, The Flogger Authors; 2026, TeamDev. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -145,6 +145,7 @@ public open class MetadataKey( /** * Casts an arbitrary value to the type of this key. * + * @return The value cast to the key type, or `null` if the given value is `null`. * @throws ClassCastException if the given value is not an instance of the key type. */ public fun cast(value: Any?): T? { @@ -155,9 +156,11 @@ public open class MetadataKey( @Suppress("UNCHECKED_CAST") return value as T } + // Do not interpolate the value itself: its `toString()` is user code + // and must not be invoked on this error path. throw ClassCastException( - "The value `$value` cannot be cast to `${clazz.qualifiedName}`" + - " required by the key `$this`." + "A value of the type `${value.javaClass.name}` cannot be cast to" + + " `${clazz.qualifiedName}` required by the key `$this`." ) } diff --git a/logging/src/commonMain/kotlin/io/spine/logging/backend/MetadataHandler.kt b/logging/src/commonMain/kotlin/io/spine/logging/backend/MetadataHandler.kt index 91f0a3eb6..e06e859d4 100644 --- a/logging/src/commonMain/kotlin/io/spine/logging/backend/MetadataHandler.kt +++ b/logging/src/commonMain/kotlin/io/spine/logging/backend/MetadataHandler.kt @@ -145,6 +145,7 @@ public abstract class MetadataHandler { * @param handler The repeated value handler to be invoked once for all associated values. * @param T The key/value type. * @return The builder instance for chaining. + * @throws IllegalArgumentException if the given key does not support repeated values. */ @CanIgnoreReturnValue public fun addRepeatedHandler( diff --git a/logging/src/commonMain/kotlin/io/spine/logging/backend/MetadataProcessor.kt b/logging/src/commonMain/kotlin/io/spine/logging/backend/MetadataProcessor.kt index 28d41d94a..051861f80 100644 --- a/logging/src/commonMain/kotlin/io/spine/logging/backend/MetadataProcessor.kt +++ b/logging/src/commonMain/kotlin/io/spine/logging/backend/MetadataProcessor.kt @@ -579,7 +579,7 @@ private fun MetadataHandler.dispatch( * * The lists built by [MutableMap.addTo] are mutable, and exposing their iterators directly * would allow a handler to remove values. Like [LightweightProcessor.ValueIterator], this - * wrapper satisfies casting to a mutable iterator but throws from [remove]. + * wrapper can be cast to a mutable iterator, but throws from [remove]. */ private class UnmodifiableIterator( private val delegate: Iterator From 514a4b04fa421c146e65099f1c4c18ff338f5b83 Mon Sep 17 00:00:00 2001 From: Alexander Yevsyukov Date: Thu, 2 Jul 2026 14:56:40 +0100 Subject: [PATCH 5/6] Align `LogLevelMap` class entries with JVM logger names On the JVM, `LoggingFactory.loggerFor()` names loggers by the Java class name (`Platform.getBackend(cls.java.name)`), while `LogLevelMap.Builder` registered classes under their Kotlin qualified names. For classes whose Kotlin and Java names differ (mapped types such as `String`, and nested classes), a map entry created via `add(level, SomeClass::class)` could never affect the logger created for that very class. `KClass.toLoggerName()` now returns the Java class name, and the builder uses it, so map entries always match the loggers they target. This also removes the `IllegalArgumentException` for local and anonymous classes, which have no Kotlin qualified name but always have a Java name. Reported by Codex review on PR #147. Co-Authored-By: Claude Fable 5 --- .../kotlin/io/spine/logging/LoggingFactory.kt | 11 +++++----- .../io/spine/logging/context/LogLevelMap.kt | 20 ++++++++----------- .../io/spine/logging/LogLevelMapSpec.kt | 9 ++++++--- .../spine/logging/context/LogLevelMapSpec.kt | 9 ++++----- 4 files changed, 23 insertions(+), 26 deletions(-) diff --git a/logging/src/commonMain/kotlin/io/spine/logging/LoggingFactory.kt b/logging/src/commonMain/kotlin/io/spine/logging/LoggingFactory.kt index c4a1a3622..fcfd813eb 100644 --- a/logging/src/commonMain/kotlin/io/spine/logging/LoggingFactory.kt +++ b/logging/src/commonMain/kotlin/io/spine/logging/LoggingFactory.kt @@ -1,5 +1,5 @@ /* - * Copyright 2023, TeamDev. All rights reserved. + * Copyright 2026, TeamDev. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -85,9 +85,8 @@ public expect object LoggingFactory { /** * Obtains a name of a logger to be used for this class. * - * For a fully-qualified class, its name will be used. - * Otherwise, if a class has a simple name, it will be used. - * If a class does not have a simple name, the string representation - * of the class will be returned. + * The name matches the name of the logger created by [LoggingFactory.loggerFor] + * for this class: it is the name of the Java class, which may differ from + * the Kotlin qualified name (e.g., `java.lang.String` for `String::class`). */ -internal fun KClass<*>.toLoggerName(): String = qualifiedName?:simpleName?:toString() +internal fun KClass<*>.toLoggerName(): String = java.name diff --git a/logging/src/commonMain/kotlin/io/spine/logging/context/LogLevelMap.kt b/logging/src/commonMain/kotlin/io/spine/logging/context/LogLevelMap.kt index 7ce2a342f..2e070fbd2 100644 --- a/logging/src/commonMain/kotlin/io/spine/logging/context/LogLevelMap.kt +++ b/logging/src/commonMain/kotlin/io/spine/logging/context/LogLevelMap.kt @@ -1,5 +1,5 @@ /* - * Copyright 2023, The Flogger Authors; 2025, TeamDev. All rights reserved. + * Copyright 2023, The Flogger Authors; 2026, TeamDev. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -109,21 +109,17 @@ public class LogLevelMap private constructor(map: Map, defaultLev /** * Adds the given classes at the specified log level. * - * @param level The logging level to assign for the given [classes] - * @param classes The classes to assign the logging [level]. Each class must have - * a [qualified name][KClass.qualifiedName]. - * @throws IllegalArgumentException if one of the [classes] does not have - * a [qualified name][KClass.qualifiedName]. + * Each class is registered under the name of the logger which + * [LoggingFactory][io.spine.logging.LoggingFactory] creates for it, + * so the level applies to the logging done by that class. + * + * @param level The logging level to assign for the given [classes]. + * @param classes The classes to assign the logging [level]. */ @CanIgnoreReturnValue public fun add(level: Level, vararg classes: KClass<*>): Builder { for (cls in classes) { - val name = cls.qualifiedName - require(name != null) { - "Cannot add the class `${cls}` because it does not have" + - " a qualified name (it may be local or anonymous)." - } - put(name, level) + put(cls.toLoggerName(), level) } return this } diff --git a/logging/src/commonTest/kotlin/io/spine/logging/LogLevelMapSpec.kt b/logging/src/commonTest/kotlin/io/spine/logging/LogLevelMapSpec.kt index 988e6246c..e570ab80a 100644 --- a/logging/src/commonTest/kotlin/io/spine/logging/LogLevelMapSpec.kt +++ b/logging/src/commonTest/kotlin/io/spine/logging/LogLevelMapSpec.kt @@ -1,5 +1,5 @@ /* - * Copyright 2023, TeamDev. All rights reserved. + * Copyright 2026, TeamDev. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -105,7 +105,9 @@ internal class LogLevelMapSpec { setDefault(INFO) } map.run { - levelOf(String::class.qualifiedName!!) shouldBe DEBUG + // Classes are registered under the names of their JVM loggers, + // which use Java class names, e.g. `java.lang.String`. + levelOf(String::class.java.name) shouldBe DEBUG levelOf(String::class) shouldBe DEBUG levelOf("java.lang") shouldBe WARNING levelOf("io.spine") shouldBe INFO @@ -119,7 +121,8 @@ internal class LogLevelMapSpec { add(WARNING, Int::class) } val map2 = logLevelMap { - add(DEBUG, "kotlin.collections") + // `List::class` maps to `java.util.List` on the JVM. + add(DEBUG, "java.util") } val merged = map1.merge(map2) diff --git a/logging/src/commonTest/kotlin/io/spine/logging/context/LogLevelMapSpec.kt b/logging/src/commonTest/kotlin/io/spine/logging/context/LogLevelMapSpec.kt index aae1b607b..c2710d9a3 100644 --- a/logging/src/commonTest/kotlin/io/spine/logging/context/LogLevelMapSpec.kt +++ b/logging/src/commonTest/kotlin/io/spine/logging/context/LogLevelMapSpec.kt @@ -101,11 +101,10 @@ internal class LogLevelMapSpec { .build() levelMap["com.google"] shouldBe INFO levelMap["java.lang"] shouldBe WARNING - // Classes are registered under their Kotlin qualified names, matching - // the logger names produced by `LoggingFactory`. For the mapped type - // `String::class` this is `kotlin.String`, not `java.lang.String`. - levelMap["kotlin.String"] shouldBe FINE - levelMap["java.lang.String"] shouldBe WARNING + // Classes are registered under the names of the loggers created for + // them, which on the JVM are Java class names: `java.lang.String` + // rather than the Kotlin name `kotlin.String`. + levelMap["java.lang.String"] shouldBe FINE } } From 567517e126f78f20c69bdde70471477a374bd4ee Mon Sep 17 00:00:00 2001 From: Alexander Yevsyukov Date: Thu, 2 Jul 2026 19:17:50 +0100 Subject: [PATCH 6/6] Update dependency reports --- docs/dependencies/dependencies.md | 72 +++++++++++++++---------------- docs/dependencies/pom.xml | 2 +- 2 files changed, 37 insertions(+), 37 deletions(-) diff --git a/docs/dependencies/dependencies.md b/docs/dependencies/dependencies.md index 03143968c..a29a73ecd 100644 --- a/docs/dependencies/dependencies.md +++ b/docs/dependencies/dependencies.md @@ -1,6 +1,6 @@ -# Dependencies of `io.spine:spine-logging-context-tests:2.0.0-SNAPSHOT.422` +# Dependencies of `io.spine:spine-logging-context-tests:2.0.0-SNAPSHOT.423` ## Runtime 1. **Group** : org.jetbrains. **Name** : annotations. **Version** : 26.1.0. @@ -441,14 +441,14 @@ The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using +This report was generated on **Thu Jul 02 19:17:26 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-fixtures:2.0.0-SNAPSHOT.422` +# Dependencies of `io.spine:spine-logging-fixtures:2.0.0-SNAPSHOT.423` ## Runtime ## Compile, tests, and tooling @@ -1240,14 +1240,14 @@ This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 12:40:53 WEST 2026** using +This report was generated on **Thu Jul 02 19:17:27 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-grpc-context:2.0.0-SNAPSHOT.422` +# Dependencies of `io.spine:spine-logging-grpc-context:2.0.0-SNAPSHOT.423` ## Runtime 1. **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2. @@ -2094,14 +2094,14 @@ This report was generated on **Thu Jul 02 12:40:53 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using +This report was generated on **Thu Jul 02 19:17:26 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-jul-backend:2.0.0-SNAPSHOT.422` +# Dependencies of `io.spine:spine-logging-jul-backend:2.0.0-SNAPSHOT.423` ## Runtime 1. **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2. @@ -2932,14 +2932,14 @@ This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using +This report was generated on **Thu Jul 02 19:17:26 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-jvm-default-platform:2.0.0-SNAPSHOT.422` +# Dependencies of `io.spine:spine-logging-jvm-default-platform:2.0.0-SNAPSHOT.423` ## Runtime 1. **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2. @@ -3786,14 +3786,14 @@ This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using +This report was generated on **Thu Jul 02 19:17:26 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-jvm-jul-backend-grpc-context:2.0.0-SNAPSHOT.422` +# Dependencies of `io.spine:spine-logging-jvm-jul-backend-grpc-context:2.0.0-SNAPSHOT.423` ## Runtime 1. **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2. @@ -4692,14 +4692,14 @@ This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using +This report was generated on **Thu Jul 02 19:17:26 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-jvm-jul-backend-std-context:2.0.0-SNAPSHOT.422` +# Dependencies of `io.spine:spine-logging-jvm-jul-backend-std-context:2.0.0-SNAPSHOT.423` ## Runtime 1. **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2. @@ -5590,14 +5590,14 @@ This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using +This report was generated on **Thu Jul 02 19:17:27 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-jvm-log4j2-backend-std-context:2.0.0-SNAPSHOT.422` +# Dependencies of `io.spine:spine-logging-jvm-log4j2-backend-std-context:2.0.0-SNAPSHOT.423` ## Runtime 1. **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2. @@ -6508,14 +6508,14 @@ This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using +This report was generated on **Thu Jul 02 19:17:27 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-jvm-slf4j-jdk14-backend-std-context:2.0.0-SNAPSHOT.422` +# Dependencies of `io.spine:spine-logging-jvm-slf4j-jdk14-backend-std-context:2.0.0-SNAPSHOT.423` ## Runtime 1. **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2. @@ -7414,14 +7414,14 @@ This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using +This report was generated on **Thu Jul 02 19:17:26 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-jvm-slf4j-reload4j-backend-std-context:2.0.0-SNAPSHOT.422` +# Dependencies of `io.spine:spine-logging-jvm-slf4j-reload4j-backend-std-context:2.0.0-SNAPSHOT.423` ## Runtime 1. **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2. @@ -8324,14 +8324,14 @@ This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using +This report was generated on **Thu Jul 02 19:17:27 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-log4j2-backend:2.0.0-SNAPSHOT.422` +# Dependencies of `io.spine:spine-logging-log4j2-backend:2.0.0-SNAPSHOT.423` ## Runtime 1. **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2. @@ -9206,14 +9206,14 @@ This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using +This report was generated on **Thu Jul 02 19:17:26 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging:2.0.0-SNAPSHOT.422` +# Dependencies of `io.spine:spine-logging:2.0.0-SNAPSHOT.423` ## Runtime ## Compile, tests, and tooling @@ -10013,14 +10013,14 @@ This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 12:40:53 WEST 2026** using +This report was generated on **Thu Jul 02 19:17:27 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine.tools:logging-testlib:2.0.0-SNAPSHOT.422` +# Dependencies of `io.spine.tools:logging-testlib:2.0.0-SNAPSHOT.423` ## Runtime ## Compile, tests, and tooling @@ -10832,14 +10832,14 @@ This report was generated on **Thu Jul 02 12:40:53 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using +This report was generated on **Thu Jul 02 19:17:27 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-otel-backend:2.0.0-SNAPSHOT.422` +# Dependencies of `io.spine:spine-logging-otel-backend:2.0.0-SNAPSHOT.423` ## Runtime ## Compile, tests, and tooling @@ -11739,14 +11739,14 @@ This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 12:40:53 WEST 2026** using +This report was generated on **Thu Jul 02 19:17:27 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-otel-backend-bootstrap:2.0.0-SNAPSHOT.422` +# Dependencies of `io.spine:spine-logging-otel-backend-bootstrap:2.0.0-SNAPSHOT.423` ## Runtime 1. **Group** : com.google.auto.service. **Name** : auto-service-annotations. **Version** : 1.1.1. @@ -13157,14 +13157,14 @@ This report was generated on **Thu Jul 02 12:40:53 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using +This report was generated on **Thu Jul 02 19:17:27 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-probe-backend:2.0.0-SNAPSHOT.422` +# Dependencies of `io.spine:spine-logging-probe-backend:2.0.0-SNAPSHOT.423` ## Runtime 1. **Group** : com.google.auto.service. **Name** : auto-service-annotations. **Version** : 1.1.1. @@ -14015,14 +14015,14 @@ This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using +This report was generated on **Thu Jul 02 19:17:26 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-smoke-test:2.0.0-SNAPSHOT.422` +# Dependencies of `io.spine:spine-logging-smoke-test:2.0.0-SNAPSHOT.423` ## Runtime 1. **Group** : com.fasterxml.jackson. **Name** : jackson-bom. **Version** : 2.22.0. @@ -14921,14 +14921,14 @@ This report was generated on **Thu Jul 02 12:40:52 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 12:40:53 WEST 2026** using +This report was generated on **Thu Jul 02 19:17:27 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). -# Dependencies of `io.spine:spine-logging-std-context:2.0.0-SNAPSHOT.422` +# Dependencies of `io.spine:spine-logging-std-context:2.0.0-SNAPSHOT.423` ## Runtime 1. **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2. @@ -15759,6 +15759,6 @@ This report was generated on **Thu Jul 02 12:40:53 WEST 2026** using The dependencies distributed under several licenses, are used according their commercial-use-friendly license. -This report was generated on **Thu Jul 02 12:40:53 WEST 2026** using +This report was generated on **Thu Jul 02 19:17:27 WEST 2026** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE). \ No newline at end of file diff --git a/docs/dependencies/pom.xml b/docs/dependencies/pom.xml index 91fc404e2..58493d11f 100644 --- a/docs/dependencies/pom.xml +++ b/docs/dependencies/pom.xml @@ -10,7 +10,7 @@ all modules and does not describe the project structure per-subproject. --> io.spine logging -2.0.0-SNAPSHOT.422 +2.0.0-SNAPSHOT.423 2015