From 1c5e4265ed1482b61a68444a3200a30660b81984 Mon Sep 17 00:00:00 2001
From: Alexander Yevsyukov <alexander.yevsyukov@teamdev.com>
Date: Sat, 27 Jun 2026 21:16:42 +0100
Subject: [PATCH 01/20] Add the report from Claude Chat and implementation plan
 from Claude Ultracode

---
 .agents/tasks/otel-backend-implementation.md | 239 +++++++
 .agents/tasks/otel-backend-report.md         | 642 +++++++++++++++++++
 2 files changed, 881 insertions(+)
 create mode 100644 .agents/tasks/otel-backend-implementation.md
 create mode 100644 .agents/tasks/otel-backend-report.md

diff --git a/.agents/tasks/otel-backend-implementation.md b/.agents/tasks/otel-backend-implementation.md
new file mode 100644
index 00000000..9f388370
--- /dev/null
+++ b/.agents/tasks/otel-backend-implementation.md
@@ -0,0 +1,239 @@
+---
+slug: otel-backend-implementation
+branch: otel
+owner: claude
+status: draft
+started: 2026-06-27
+related-memories: []
+---
+
+## Goal
+
+Ship an OpenTelemetry logger backend for Spine Logging that maps `LogData` to OTel
+log records (`Logger.emit(...)`) and, on top of the same call path, a log-based
+*events* surface. Success = an app can route Spine logs to an OTel pipeline by
+adding one backend artifact and pointing it at an `OpenTelemetry` instance; the
+record carries severity, message, log-site, throwable, Spine scope/log-site
+metadata as attributes, and active-span trace correlation; all proven with tests.
+
+The companion research spec is [`otel-backend-report.md`](otel-backend-report.md)
+(referred to below as "the report"). **This plan corrects several factual errors
+in the report** (see *Context → Corrections*); where the two disagree, this plan
+wins.
+
+## Context
+
+The plan is grounded in three sources, all read on 2026-06-27:
+
+1. **The Spine SPI** (verified `confirmed` against source) — the report describes it
+   accurately:
+   - [`BackendFactory.kt:81`](logging/src/commonMain/kotlin/io/spine/logging/backend/BackendFactory.kt) — `abstract fun create(loggingClass: String): LoggerBackend`
+   - [`LoggerBackend.kt`](logging/src/commonMain/kotlin/io/spine/logging/backend/LoggerBackend.kt) — `loggerName: String?` (65), `isLoggable(Level)` (72), `log(LogData)` (80), `handleError(RuntimeException, LogData)` (118)
+   - [`LogData.kt`](logging/src/commonMain/kotlin/io/spine/logging/backend/LogData.kt) — `level`, `timestampNanos: Long`, `loggerName`, `logSite`, `metadata`, `wasForced()`, `literalArgument`
+   - [`Level.kt:56`](logging/src/commonMain/kotlin/io/spine/logging/Level.kt) — `data class Level(name, value)`; FATAL=2000, ERROR/SEVERE=1000, WARNING=900, INFO=800, CONFIG=700, DEBUG/FINE=500, FINER/TRACE=400, FINEST=300
+   - [`MetadataProcessor.kt`](logging/src/commonMain/kotlin/io/spine/logging/backend/MetadataProcessor.kt) — `forScopeAndLogSite(scope, logged)` (83), `process(handler, ctx)` (133), `getSingleValue(key)` (151), `keySet()` (168)
+   - [`MetadataHandler.kt`](logging/src/commonMain/kotlin/io/spine/logging/backend/MetadataHandler.kt) — `handle(key, value, ctx)` (62) and the repeated-key hook **`handleRepeated(key, values: Iterator<T>, ctx)`** (78); build via `MetadataHandler.builder()`
+   - [`SimpleMessageFormatter.kt:167`](logging/src/commonMain/kotlin/io/spine/logging/backend/SimpleMessageFormatter.kt) — `getLiteralLogMessage(logData): String` (message text without the `[CONTEXT …]` suffix)
+   - [`Platform.kt:182`](logging/src/commonMain/kotlin/io/spine/logging/backend/Platform.kt) — `getInjectedMetadata(): Metadata`
+   - [`LogContext.kt:585`](logging/src/commonMain/kotlin/io/spine/logging/LogContext.kt) — `Key.LOG_CAUSE: MetadataKey<Throwable>`
+
+2. **The reference backends to mirror**:
+   - [`log4j2-backend`](backends/log4j2-backend) — the mapping template ([`LogEvents.kt`](backends/log4j2-backend/src/main/kotlin/io/spine/logging/backend/log4j2/LogEvents.kt): `MetadataProcessor.forScopeAndLogSite` → format → `getSingleValue(LOG_CAUSE)` → `MetadataHandler.builder()`, with `Tags` special-cased and `ValueQueue` for repeated keys).
+   - [`probe-backend`](backends/probe-backend) — the `@AutoService` + KSP registration pattern ([`build.gradle.kts`](backends/probe-backend/build.gradle.kts): `plugins { ksp }`, `implementation(AutoService.annotations)`, `ksp(AutoServiceKsp.processor)`) and the memoizing test backend.
+   - [`logging/build.gradle.kts`](logging/build.gradle.kts) — the **`kmp-module`** shape: `kotlin { sourceSets { commonMain {…}; jvmMain { runtimeOnly(project(":jvm-default-platform")) }; jvmTest {…} } }`, JVM target only.
+
+3. **The proven OTel-Kotlin precedent — the `core-jvm` repo's `server-otel` module**
+   (sibling checkout at `/Users/sanders/Projects/Spine/core-jvm`). It already uses
+   the native Kotlin SDK successfully and gives us copy-ready artifacts:
+   - `core-jvm/buildSrc/src/main/kotlin/io/spine/dependency/lib/OpenTelemetryKotlin.kt` — a `Dependency()` object pinning **0.4.0**, group `io.opentelemetry.kotlin`, exposing `api`, `noop`, `core`, `implementation`, `compat`. **Copy it verbatim into this repo's `buildSrc/.../lib/`.**
+   - `core-jvm/server-otel/build.gradle.kts` — production depends on **`api` only**; tests add `core` + `implementation` (the native SDK).
+   - `core-jvm/.../given/TestOtel.kt` — the SDK is built with `createOpenTelemetry { tracerProvider { export { processor } } }` and a hand-rolled recording processor. **The logs test path mirrors this with a recording `LogRecordProcessor` — no in-memory-exporter artifact required.**
+
+   The actual **0.4.0 Logs API** was read from the api-discovery cache
+   (`io.opentelemetry.kotlin:api:0.4.0`) and matches the report's skeletons:
+   `Logger.emit(body, eventName, timestamp: Long?, observedTimestamp, context, severityNumber, severityText, exception, attributes)`,
+   `Logger.enabled(context, severityNumber, eventName)`,
+   `LoggerProvider.getLogger(name, version, schemaUrl, attributes)`,
+   `OpenTelemetry.loggerProvider`, and the `SeverityNumber` enum (1–24; `DEBUG4=8`).
+
+### Corrections to the report (verified 2026-06-27)
+
+| # | Report says | Reality | Consequence |
+|---|-------------|---------|-------------|
+| C1 | `opentelemetry-kotlin` **0.5.0** | Latest is **0.4.0** (2026-05-20); 0.5.0 does not exist | Pin `0.4.0` (matches `core-jvm`). |
+| C2 | Version catalog `gradle/libs.versions.toml` | Repo uses **buildSrc Kotlin objects** | Copy `core-jvm`'s `OpenTelemetryKotlin` object into `buildSrc/.../lib/`, not a TOML entry. |
+| C3 | Service file in `jvmMain/resources`, hand-written | Repo standard is **`@AutoService` + KSP** (probe-backend) | Annotate the JVM factory `@AutoService(BackendFactory::class)`; KSP generates the service file. |
+| C4 | Test with `exporters-in-memory` (Kotlin); compat bridge for the SDK | Kotlin in-memory exporter artifact unconfirmed; `core-jvm` uses the **native Kotlin SDK** + a hand-rolled recording processor | Use the **native SDK** (`core`+`implementation`); tests capture records with a recording `LogRecordProcessor`. No compat, no in-memory artifact. |
+| C5 | A `std` backend exists | Only `log4j2`, `jul`, `probe` exist | Ignore; mirror `log4j2`. |
+| C6 | `OtelBackendSettings.use(...)` reuses an existing pattern | No backend has programmatic injection today; JVM precedent is the `spine.logging.backend_factory` system-property override ([`DefaultPlatform.kt`](platforms/jvm-default-platform/src/main/kotlin/io/spine/logging/backend/system/DefaultPlatform.kt)) | `OtelBackendSettings` is a **new** convention; model its `@Volatile`/no-op-default shape on `DefaultPlatform`'s loader and document it. |
+
+Two API refinements (vs the report's prose):
+- `AttributesMutator` has **no `Int`/`Float` setters** — only `setLongAttribute`/`setDoubleAttribute` (+ `*List*`, `setByteArrayAttribute`, `setAnyValueAttribute`). The attribute handler must widen `Int`/`Short`/`Byte` → `Long` and `Float` → `Double`.
+- `Logger.emit(timestamp: Long?)` — the param exists, but **the unit (epoch nanos vs millis) is not documented in the API**; it is resolved by the SDK. Confirm against `:implementation` 0.4.0 in Phase 0 before wiring `data.timestampNanos`.
+
+### Decisions (resolved)
+
+| Topic | Decision |
+|-------|----------|
+| **JVM SDK strategy** | **Native Kotlin SDK** (`core`+`implementation`) from the start — proven in `core-jvm/server-otel`. No compat bridge. |
+| **Module platform** | **`kmp-module`** with the JVM target only (mirrors core `logging`). Mapping in `commonMain` (only touches OTel `:api` + Spine commonMain SPI); JVM-only registration in `jvmMain`. Aims at KMP up front to cut future migration, even though only JVM is wired today. |
+| **Registration** | **`@AutoService(BackendFactory::class)` + KSP** (`kspJvm`), as probe-backend does. |
+| **Events / OTEP 4430** | Events emit through the Logs API (`emit(eventName = …)`); never `Span.AddEvent`. |
+| **Body vs attributes** | Body = `getLiteralLogMessage(...)` (no `[CONTEXT]` suffix); metadata → attributes (no double-encoding). |
+| **CONFIG severity** | `DEBUG4` (judgment call, documented in KDoc) — open to `INFO` if preferred. |
+
+## Architecture
+
+```
+backends/otel-backend/                         ← kmp-module, JVM target only (for now)
+  src/commonMain/kotlin/io/spine/logging/backend/otel/
+    OtelLoggerBackend.kt         ← LoggerBackend; LogData → Logger.emit(...)   [api only]
+    OtelBackendSettings.kt       ← @Volatile holder; default NoopOpenTelemetry; use(otel)
+    SeverityMapping.kt           ← Level.toSeverityNumber()
+    AttributeMapping.kt          ← MetadataHandler<AttributesMutator> + LogSite → code.* semconv
+  src/jvmMain/kotlin/io/spine/logging/backend/otel/
+    OtelBackendFactory.kt        ← @AutoService(BackendFactory::class); resolves OpenTelemetry from settings
+  src/jvmTest/kotlin/...         ← native SDK + recording LogRecordProcessor + Kotest/JUnit5 specs
+
+backends/otel-backend-bootstrap/   ← OPTIONAL, Phase 2 (jvmMain SDK init, turnkey wiring)
+```
+
+- `commonMain` depends on `OpenTelemetryKotlin.api` + `.noop` + `project(":logging")`.
+- `jvmMain` adds `AutoService.annotations` (+ `kspJvm(AutoServiceKsp.processor)`), and
+  the factory carries `@AutoService` directly — it is a no-arg `class`, so unlike
+  probe-backend's `object` it needs no adapter shim.
+- `jvmTest` adds `OpenTelemetryKotlin.core` + `.implementation`, `logging-testlib`, and
+  `runtimeOnly(project(":jvm-default-platform"))` so `DefaultPlatform` discovers the
+  `@AutoService` factory end-to-end.
+- **Build wrinkle to validate (Phase 0):** KSP on a `kmp-module` uses `kspJvm(...)`,
+  not the plain `ksp(...)` probe-backend uses on its `jvm-module`. If KSP-on-KMP
+  misbehaves with the `kmp-module` convention plugin, fall back to a hand-written
+  `src/jvmMain/resources/META-INF/services/io.spine.logging.backend.BackendFactory`.
+
+## Open decisions
+
+1. **CONFIG severity** — `DEBUG4` (default) vs `INFO`. Cosmetic; documented either way.
+2. **Bootstrap module SDK config surface** (Phase 2) — env-var driven vs explicit DSL.
+   Defer until Phase 1 lands.
+
+## Plan
+
+### Phase 0 — spike: native SDK end-to-end on JVM (de-risk)
+- [ ] Copy `core-jvm`'s `OpenTelemetryKotlin.kt` into
+      `buildSrc/src/main/kotlin/io/spine/dependency/lib/`; confirm the shape against
+      the `dependency-audit` skill. Add `AutoService`/`AutoServiceKsp` usage check —
+      both already exist ([`Auto.kt`](buildSrc/src/main/kotlin/io/spine/dependency/lib/Auto.kt), [`Ksp.kt`](buildSrc/src/main/kotlin/io/spine/dependency/build/Ksp.kt)).
+- [ ] Register the module: add `"otel-backend"` to `includeBackend(...)` in
+      [`settings.gradle.kts`](settings.gradle.kts).
+- [ ] Create `backends/otel-backend/build.gradle.kts`: `plugins { kmp-module; ksp }`;
+      `commonMain` → `api(OpenTelemetryKotlin.api)` + `noop` + `project(":logging")`;
+      `jvmMain` → `AutoService.annotations`; `kspJvm(AutoServiceKsp.processor)`;
+      `jvmTest` → `OpenTelemetryKotlin.core` + `.implementation` + `logging-testlib` +
+      `runtimeOnly(project(":jvm-default-platform"))`. Add `@OptIn(ExperimentalApi::class)`.
+- [ ] **Verify the logs SDK DSL with `api-discovery` on `:implementation` 0.4.0** —
+      confirm the `createOpenTelemetry { loggerProvider { export { … } } }` shape and the
+      `LogRecordProcessor`/exporter type (the api cache only has `:api`, not the SDK).
+      Also confirm the **`emit(timestamp)` unit** (epoch nanos vs millis).
+- [ ] Build a `RecordingLogRecordProcessor` (mirror `core-jvm`'s `RecordingSpanProcessor`),
+      wire `createOpenTelemetry { loggerProvider { export { it } } }`, call
+      `OtelBackendSettings.use(...)`, log once through Spine, assert the record round-trips
+      (severity + body). This throwaway proof becomes the first real test.
+
+### Phase 1 — production backend
+- [ ] `commonMain/OtelBackendSettings.kt`: `@Volatile private var instance = NoopOpenTelemetry`;
+      `fun use(openTelemetry: OpenTelemetry)`; `internal fun current()`. No-op default,
+      drop-before-`use`. KDoc it as a new convention (correction C6).
+- [ ] `commonMain/SeverityMapping.kt`: numeric-threshold `Level.toSeverityNumber()`
+      (report §5.1) → `FATAL/ERROR/WARN/INFO/DEBUG4(CONFIG)/DEBUG/TRACE2/TRACE`.
+- [ ] `commonMain/OtelLoggerBackend.kt`:
+      - `isLoggable(level)` → `logger.enabled(severityNumber = level.toSeverityNumber())`.
+      - `log(data)` → `MetadataProcessor.forScopeAndLogSite(Platform.getInjectedMetadata(), data.metadata)`;
+        `body = getLiteralLogMessage(data)`; `severityNumber`/`severityText = data.level.name`;
+        `exception = metadata.getSingleValue(LogContext.Key.LOG_CAUSE)`;
+        `timestamp = data.timestampNanos` (**unit confirmed in Phase 0**);
+        `context = null` (⇒ implicit/active context, per the `emit` KDoc);
+        `attributes = { applyAttributes(data, metadata) }`.
+      - `handleError(error, badData)` → emit an ERROR record carrying `badData.toString()`.
+- [ ] `commonMain/AttributeMapping.kt`: a `MetadataHandler<AttributesMutator>` via
+      `MetadataHandler.builder()`:
+      - LogSite → `code.namespace`/`code.function`/`code.filepath`/`code.lineno`.
+      - `handle(...)`: skip `LOG_CAUSE`; namespace keys `spine.<label>`; type-switch with
+        widening — `Boolean→setBooleanAttribute`, `Int/Short/Byte/Long→setLongAttribute`,
+        `Float/Double→setDoubleAttribute`, `String→setStringAttribute`, else `toString()`.
+      - `handleRepeated(key, values, ctx)`: accumulate into the matching `*ListAttribute`.
+      - `Tags` (from `ScopedLoggingContext`): surface as `spine.tag.<name>` (mirror `LogEvents.kt`).
+- [ ] `jvmMain/OtelBackendFactory.kt`: `@AutoService(BackendFactory::class) class … : BackendFactory()`;
+      `name = loggingClass.replace('$', '.')`,
+      `OtelBackendSettings.current().loggerProvider.getLogger(name)`, return
+      `OtelLoggerBackend(logger, loggerName = name)`; override `toString()`.
+- [ ] Tests (`jvmTest`, Kotest + JUnit5, `internal` `*Spec`, `@DisplayName`): severity
+      mapping; body has **no** `[CONTEXT …]`; attributes namespaced + repeated→list +
+      widened numerics; throwable recorded; logger-name routing; `isLoggable` gating;
+      `@AutoService` discovery (record captured through the full Spine→DefaultPlatform path).
+
+### Phase 2 — bootstrap module + correlation hardening
+- [ ] `backends/otel-backend-bootstrap` (kmp-module, jvmMain SDK init): read config,
+      `createOpenTelemetry { loggerProvider { export { … } } }`, `OtelBackendSettings.use(...)`,
+      own shutdown.
+- [ ] Coroutine trace-correlation test: log inside a span-scoped coroutine; assert
+      trace/span ids land on the record; wire the OTel context element if they don't
+      survive dispatch (report §5.5 / §10.4); document the requirement.
+- [ ] Optional early-record ring buffer in `OtelBackendSettings`, replayed on `use(...)`
+      (report §4) — only if bootstrap-order logs matter.
+
+### Phase 3 — log-based events API + domain-event integration
+- [ ] Low-level: a `MetadataKey<String>` (`otel.event.name`) the backend pulls out and
+      passes as `emit(eventName = …)` (report §6.1).
+- [ ] Ergonomic `logEvent(name, severity, build)` guarded by `enabled(eventName = name)`
+      (report §6.2).
+- [ ] Domain-event → observability-event bridge: proto message type name → `event.name`
+      (low cardinality), selected fields + scope → attributes, active span → correlation;
+      document the domain-event-vs-observability-event boundary (report §6.3).
+
+### Phase 4 — non-JVM targets (deferred; separate initiative)
+- [ ] Only when Spine grows non-JVM backend registration (today only
+      `jvm-default-platform` + ServiceLoader exist; `actual fun loadPlatform()` is
+      JVM-only). The `commonMain` mapping already built here is the reusable part;
+      each target needs its own discovery mechanism + an OTLP exporter (iOS/native OTLP
+      is **not** available upstream yet — correction C4).
+
+## Risks & open questions (status after verification)
+
+1. **`opentelemetry-kotlin` maturity** — 0.4.0, `@ExperimentalApi`, logs in *Development*.
+   `@OptIn` everywhere; pin exactly; expect breaking changes. *(Open — accepted.)*
+2. **`emit(timestamp)` unit** — param is `Long?`, unit undocumented in `:api`. Confirm
+   against `:implementation` in Phase 0. *(Open — verify.)*
+3. **Logs SDK DSL** — `loggerProvider { export { … } }` inferred by analogy to the
+   tracer DSL in `core-jvm`; confirm against `:implementation` 0.4.0 in Phase 0. *(Open — verify.)*
+4. **KSP on `kmp-module`** — `kspJvm` path is unexercised in this repo; validate in
+   Phase 0, fallback = hand-written service file. *(Open — verify.)*
+5. **Coroutine context propagation** — correlation across suspension unproven; Phase 2
+   test. *(Open.)*
+6. **Test exporter** — resolved: hand-rolled recording `LogRecordProcessor` like
+   `core-jvm`, no in-memory artifact. *(Resolved.)*
+7. **Non-JVM registration** — genuinely unpaved in Spine; keeps KMP export out of
+   near-term scope. *(Resolved → Phase 4.)*
+
+## Testing
+
+- JVM, native Kotlin SDK (`core`+`implementation`) configured via
+  `createOpenTelemetry { loggerProvider { export { recordingProcessor } } }`, mirroring
+  `core-jvm/server-otel`'s `TestOtel`/`RecordingSpanProcessor`.
+- Assert: severity number, body without context suffix, namespaced + widened + repeated→list
+  attributes, exception recorded, `event.name` when set, trace/span id under an active
+  span, and the coroutine-correlation case.
+- `runtimeOnly(:jvm-default-platform)` in `jvmTest` for the `@AutoService` discovery path.
+
+## Log
+
+- 2026-06-27 — Drafted from `otel-backend-report.md` after a 6-agent verification pass
+  (SPI signatures, log4j2 template, build conventions, platform selection, task-doc
+  format, upstream `opentelemetry-kotlin` status). Recorded corrections C1–C6.
+- 2026-06-27 — Scope confirmed by maintainer: JVM-first, Phases 0–3, KMP (Phase 4)
+  deferred.
+- 2026-06-27 — Two implementation decisions taken: **native Kotlin SDK** from the start
+  (proven in `core-jvm/server-otel`) and **`@AutoService` + KSP** registration. Module
+  retargeted to **`kmp-module`** (JVM only) with the mapping in `commonMain` to minimise
+  future KMP migration. Verified the real 0.4.0 Logs API from the api-discovery cache
+  and the `core-jvm` `OpenTelemetryKotlin` dep object / native-SDK test pattern; updated
+  the dependency, build, and testing steps accordingly. Awaiting approval to execute.
diff --git a/.agents/tasks/otel-backend-report.md b/.agents/tasks/otel-backend-report.md
new file mode 100644
index 00000000..7cc72ef1
--- /dev/null
+++ b/.agents/tasks/otel-backend-report.md
@@ -0,0 +1,642 @@
+# Implementing an OpenTelemetry Logger Backend for Spine Logging (KMP)
+
+**Status:** Research / implementation spec — ready to drive Claude Code sessions
+**Target library:** `SpineEventEngine/logging`
+**OTel client:** `open-telemetry/opentelemetry-kotlin` (KMP), `io.opentelemetry.kotlin:*` v0.5.0 (
+`@ExperimentalApi`)
+**Scope:** Logger backend (Spine `LogData` → OTel log records) **plus** a log-based events surface
+**SDK lifecycle:** support both *inject an existing instance* and *bootstrap from config*
+
+---
+
+## 0. How to use this document in Claude Code
+
+This is a self-contained spec. A Claude Code session does not have the conversation that produced
+it, so everything needed is inline: the exact Spine SPI signatures, the exact `opentelemetry-kotlin`
+API surface, the mapping rules, code skeletons, and the open risks. Treat the code blocks as
+*starting skeletons to verify against the pinned dependency versions*, not as copy-paste-final —
+`opentelemetry-kotlin` is pre-1.0 and `@ExperimentalApi`, so signatures can shift between releases.
+
+Recommended working order is the phased plan in §11. Start with the Phase 0 JVM-via-compat spike
+before committing to the native KMP path.
+
+---
+
+## 1. Decision record
+
+| Decision        | Choice                                    | Rationale                                                                                                                                                     |
+|-----------------|-------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| OTel client     | `opentelemetry-kotlin` (KMP)              | Multiplatform reach matching Spine's `commonMain` ethos; idiomatic Kotlin API. Trade-off: logs are in *Development* status and the API is `@ExperimentalApi`. |
+| Platform target | KMP, JVM-first                            | JVM via the `compat` bridge over `opentelemetry-java` de-risks maturity; native/JS follow.                                                                    |
+| Scope           | Backend + log-based events                | `Logger.emit(eventName = …)` makes events the *same* call path as logs — minimal extra surface.                                                               |
+| SDK lifecycle   | Both (inject default, optional bootstrap) | Core backend stays `:api`-only; a separate optional module bootstraps a real SDK.                                                                             |
+| Span events     | Log-based only (no `Span.AddEvent`)       | Aligns with OTEP 4430 (Span Event API deprecation).                                                                                                           |
+
+---
+
+## 2. Background — the two sides
+
+### 2.1 Spine Logging backend SPI (ground truth from the repo)
+
+The SPI lives in `logging/src/commonMain/kotlin/io/spine/logging/backend/`. It is Flogger-derived
+but slimmed down. The four types you implement against:
+
+```kotlin
+// BackendFactory.kt — discovered + instantiated by the platform
+public abstract class BackendFactory {
+    public abstract fun create(loggingClass: String): LoggerBackend
+}
+
+// LoggerBackend.kt — the thing you build
+public abstract class LoggerBackend {
+    public abstract val loggerName: String?
+    public abstract fun isLoggable(level: Level): Boolean
+    public abstract fun log(data: LogData)
+    public abstract fun handleError(error: RuntimeException, badData: LogData)
+}
+
+// LogData.kt — the record handed to log()
+public interface LogData {
+    public val level: Level
+    public val timestampNanos: Long
+    public val loggerName: String?
+    public val logSite: LogSite          // className, methodName, fileName, lineNumber
+    public val metadata: Metadata
+    public fun wasForced(): Boolean
+    public val literalArgument: Any?
+}
+```
+
+`Level` is a plain data class (not `java.util.logging.Level`), so it is multiplatform-safe:
+
+```kotlin
+public data class Level(val name: String, val value: Int)
+// OFF=MAX, FATAL=2000, ERROR/SEVERE=1000, WARNING=900, INFO=800,
+// CONFIG=700, DEBUG/FINE=500, FINER/TRACE=400, FINEST=300, ALL=MIN
+```
+
+`Metadata` is an indexed collection of typed keys; `MetadataKey<T>` carries a `label`, a `canRepeat`
+flag, and `cast()`:
+
+```kotlin
+public abstract class Metadata {
+    public abstract fun size(): Int
+    public abstract fun getKey(n: Int): MetadataKey<Any>
+    public abstract fun getValue(n: Int): Any
+    public abstract fun <T : Any> findValue(key: MetadataKey<T>): T?
+}
+```
+
+Two helper types you will use rather than hand-rolling iteration:
+
+- `MetadataProcessor` — merges *scope* metadata (`ScopedLoggingContext`) with *log-site* metadata
+  and iterates them: `forScopeAndLogSite(scope, logged)`, then `process(handler, context)`, plus
+  `getSingleValue(key)`, `keySet()`.
+- `MetadataHandler<C>` — visitor:
+  `abstract fun <T : Any> handle(key: MetadataKey<T>, value: T, context: C)` (with separate handling
+  hooks for repeated keys).
+- `SimpleMessageFormatter` — renders the message. Critically it exposes
+  `getLiteralLogMessage(logData): String` (message text **without** the `[CONTEXT …]` suffix) in
+  addition to the full `format(logData, metadata)`. The default formatter already ignores
+  `LogContext.Key.LOG_CAUSE` when appending context.
+
+The cause/throwable is carried as metadata under `LogContext.Key.LOG_CAUSE`, extracted via
+`metadata.getSingleValue(LogContext.Key.LOG_CAUSE)`.
+
+### 2.2 Reference implementation — the Log4j2 backend
+
+The shipped `backends/log4j2-backend` is the template to mirror. Its shape, condensed:
+
+```kotlin
+public class Log4j2BackendFactory : BackendFactory() {
+    override fun create(loggingClass: String): LoggerBackend {
+        val name = loggingClass.replace('$', '.')
+        val logger = LogManager.getLogger(name) as Logger
+        return Log4j2LoggerBackend(logger)
+    }
+}
+
+internal class Log4j2LoggerBackend(private val logger: Logger) : LoggerBackend() {
+    override val loggerName get() = logger.name
+    override fun isLoggable(level: Level) = logger.isEnabled(level.toLog4j())
+    override fun log(data: LogData) = logger.get().log(toLog4jLogEvent(logger.name, data))
+    override fun handleError(error: RuntimeException, badData: LogData) =
+        logger.get().log(toLog4jLogEvent(logger.name, error, badData))
+}
+```
+
+Registered via
+`backends/log4j2-backend/src/main/resources/META-INF/services/io.spine.logging.backend.BackendFactory`
+containing one line: the factory FQN. Note this is **JVM `ServiceLoader`** — see §9 for why that
+matters for KMP.
+
+Inside `toLog4jLogEvent` the pattern you will replicate is:
+
+1. `MetadataProcessor.forScopeAndLogSite(Platform.getInjectedMetadata(), logData.metadata)`
+2. format the message,
+3. pull the cause via `getSingleValue(LOG_CAUSE)`,
+4. project log-site + metadata into the target representation.
+
+### 2.3 opentelemetry-kotlin Logs/Events API (ground truth from the repo)
+
+Repo: `open-telemetry/opentelemetry-kotlin` (donated by Embrace). Version **0.5.0**. The logs API is
+annotated `@ExperimentalApi`.
+
+Module map (relevant subset):
+
+| Artifact                                           | Use                                                                    |
+|----------------------------------------------------|------------------------------------------------------------------------|
+| `io.opentelemetry.kotlin:api`                      | Instrumentation API — **the only dependency the backend itself needs** |
+| `io.opentelemetry.kotlin:noop`                     | `NoopOpenTelemetry` default instance                                   |
+| `io.opentelemetry.kotlin:core` + `:implementation` | The native Kotlin SDK (only where you initialize)                      |
+| `io.opentelemetry.kotlin:compat`                   | JVM/Android bridge over `opentelemetry-java`                           |
+| `io.opentelemetry.kotlin:exporters-otlp`           | OTLP exporters                                                         |
+| `io.opentelemetry.kotlin:exporters-in-memory`      | Test exporter                                                          |
+
+The API entry point and logs surface:
+
+```kotlin
+public interface OpenTelemetry {
+    public val loggerProvider: LoggerProvider
+    public val tracerProvider: TracerProvider
+    public val context: ContextFactory
+    public val span: SpanFactory
+    public val baggage: BaggageFactory
+    // … meterProvider, propagator, etc.
+}
+
+public interface LoggerProvider {
+    public fun getLogger(
+        name: String, version: String? = null, schemaUrl: String? = null,
+        attributes: (AttributesMutator.() -> Unit)? = null,
+    ): Logger
+}
+
+public interface Logger {
+    public fun enabled(
+        context: Context? = null,
+        severityNumber: SeverityNumber? = null,
+        eventName: String? = null,
+    ): Boolean
+
+    public fun emit(
+        body: Any? = null,
+        eventName: String? = null,            // ← log-based EVENTS are just this param
+        timestamp: Long? = null,
+        observedTimestamp: Long? = null,
+        context: Context? = null,
+        severityNumber: SeverityNumber? = null,
+        severityText: String? = null,
+        exception: Throwable? = null,
+        attributes: (AttributesMutator.() -> Unit)? = null,
+    )
+}
+```
+
+`SeverityNumber` is the standard 1–24 OTel scale (
+`TRACE=1 … DEBUG=5 … INFO=9 … WARN=13 … ERROR=17 … FATAL=21`, each with `2/3/4` sub-levels).
+`AttributesMutator` is a typed builder:
+
+```kotlin
+public interface AttributesMutator {
+    public fun setBooleanAttribute(key: String, value: Boolean)
+    public fun setStringAttribute(key: String, value: String)
+    public fun setLongAttribute(key: String, value: Long)
+    public fun setDoubleAttribute(key: String, value: Double)
+    public fun setStringListAttribute(
+        key: String,
+        value: List<String>
+    )   // + Boolean/Long/Double list
+    public fun setByteArrayAttribute(key: String, value: ByteArray)
+    public fun setAnyValueAttribute(key: String, value: AnyValue)
+}
+```
+
+**Compat bridge (JVM/Android only, `compat` module):**
+
+```kotlin
+// wrap an existing opentelemetry-java instance
+val otelKotlin: OpenTelemetry = otelJava.toOtelKotlinApi()
+// or create a Kotlin API backed by the Java SDK
+val otelKotlin: OpenTelemetry = createCompatOpenTelemetry { /* configure */ }
+```
+
+This is the key maturity hedge: on the JVM you get the Kotlin API surface while the **Stable**
+`opentelemetry-java` logs SDK does the actual work.
+
+---
+
+## 3. Architecture
+
+```
+backends/otel-backend/                 ← KMP module, commonMain depends ONLY on :api (+ :noop)
+  commonMain/
+    OtelBackendFactory.kt              ← BackendFactory; resolves OpenTelemetry from holder
+    OtelLoggerBackend.kt               ← LoggerBackend; maps LogData → Logger.emit(...)
+    SeverityMapping.kt                 ← Level → SeverityNumber
+    AttributeMapping.kt                ← Metadata/LogSite → AttributesMutator
+    OtelBackendSettings.kt             ← holder for the OpenTelemetry instance (inject mode)
+    events/                            ← log-based events surface (Phase 3)
+  jvmMain/
+    resources/META-INF/services/io.spine.logging.backend.BackendFactory
+
+backends/otel-backend-bootstrap/       ← OPTIONAL, separate artifact (bootstrap mode)
+  depends on :core/:implementation/:exporters-otlp OR :compat + opentelemetry-java BOM
+  builds a real SDK from env/config and calls OtelBackendSettings.use(...)
+```
+
+**Why the split:** the OTel docs are explicit that `core`/`compat`/`implementation` should not be a
+dependency of any module that isn't initializing the SDK. Keeping the backend `:api`-only means
+consumers who already run an OTel SDK just point the backend at it; consumers who want turnkey
+wiring add the bootstrap artifact.
+
+---
+
+## 4. SDK lifecycle — supporting both modes
+
+The SPI constraint: `BackendFactory` is no-arg-constructed by the platform (via `ServiceLoader` on
+JVM), so the factory **cannot take the `OpenTelemetry` instance through its constructor**. It must
+resolve it from a settable holder, defaulting to no-op.
+
+```kotlin
+// OtelBackendSettings.kt  (commonMain, :api only)
+public object OtelBackendSettings {
+    @Volatile
+    private var instance: OpenTelemetry = NoopOpenTelemetry
+
+    /** Inject mode: app calls this once at startup. */
+    public fun use(openTelemetry: OpenTelemetry) {
+        instance = openTelemetry
+    }
+
+    internal fun current(): OpenTelemetry = instance
+}
+```
+
+- **Inject mode (recommended default):** the app sets the instance at bootstrap. On JVM this can be
+  a native Kotlin SDK *or* `javaOtel.toOtelKotlinApi()`:
+  ```kotlin
+  OtelBackendSettings.use(GlobalOpenTelemetry.get().toOtelKotlinApi())   // JVM + compat
+  // or
+  OtelBackendSettings.use(createOpenTelemetry { loggerProvider { export { … } } })  // native
+  ```
+- **Bootstrap mode:** the optional `otel-backend-bootstrap` module reads config (e.g.
+  `OTEL_EXPORTER_OTLP_ENDPOINT`), builds an SDK, and calls `OtelBackendSettings.use(...)`. It owns
+  the SDK lifecycle and shutdown.
+
+**Early-record caveat (mirror the OTel appender behavior):** anything logged before `use(...)` runs
+goes to `NoopOpenTelemetry` and is dropped. If bootstrap-order logs matter, add a small bounded ring
+buffer in the holder that replays into the real instance on `use(...)`. Treat as a Phase 2
+enhancement.
+
+---
+
+## 5. The mapping — `LogData` → `Logger.emit(...)`
+
+This is the core of the backend. The `OtelLoggerBackend`:
+
+```kotlin
+internal class OtelLoggerBackend(
+    private val logger: Logger,          // io.opentelemetry.kotlin.logging.Logger
+    override val loggerName: String?,
+) : LoggerBackend() {
+
+    override fun isLoggable(level: Level): Boolean =
+        logger.enabled(severityNumber = level.toSeverityNumber())
+
+    override fun log(data: LogData) {
+        val metadata = MetadataProcessor.forScopeAndLogSite(
+            Platform.getInjectedMetadata(), data.metadata
+        )
+        val cause = metadata.getSingleValue(LogContext.Key.LOG_CAUSE)
+        logger.emit(
+            body = SimpleMessageFormatter.getLiteralLogMessage(data),  // text only, no [CONTEXT]
+            timestamp = data.timestampNanos,                           // VERIFY unit (see §10)
+            severityNumber = data.level.toSeverityNumber(),
+            severityText = data.level.name,
+            exception = cause,
+            context = null,                                            // null ⇒ active context (see §5.5)
+            attributes = { applyAttributes(data, metadata) },
+        )
+    }
+
+    override fun handleError(error: RuntimeException, badData: LogData) {
+        logger.emit(
+            body = "Spine logging backend error: ${error.message}",
+            severityNumber = SeverityNumber.ERROR,
+            severityText = "ERROR",
+            exception = error,
+            attributes = { setStringAttribute("spine.logging.bad_data", badData.toString()) },
+        )
+    }
+}
+```
+
+### 5.1 Severity — `Level` → `SeverityNumber`
+
+Use a numeric-threshold mapping rather than name-matching, so custom Spine levels degrade sensibly:
+
+```kotlin
+fun Level.toSeverityNumber(): SeverityNumber = when {
+    value >= Level.FATAL.value -> SeverityNumber.FATAL    // 2000 → 21
+    value >= Level.ERROR.value -> SeverityNumber.ERROR    // 1000 → 17
+    value >= Level.WARNING.value -> SeverityNumber.WARN     //  900 → 13
+    value >= Level.INFO.value -> SeverityNumber.INFO     //  800 →  9
+    value >= Level.CONFIG.value -> SeverityNumber.DEBUG4   //  700 →  8  (judgment call)
+    value >= Level.DEBUG.value -> SeverityNumber.DEBUG    //  500 →  5
+    value >= Level.FINER.value -> SeverityNumber.TRACE2   //  400 →  2
+    else -> SeverityNumber.TRACE    //  300 →  1
+}
+```
+
+`CONFIG` has no clean OTel equivalent (it sits between INFO and DEBUG in JUL semantics); `DEBUG4`
+keeps it just above plain DEBUG. Mapping it to `INFO` is also defensible — pick one and document it.
+
+### 5.2 Body / message
+
+Use `SimpleMessageFormatter.getLiteralLogMessage(data)` to get the rendered message **without** the
+appended `[CONTEXT …]` block. Metadata goes to attributes (§5.4), so using the full `format(...)`
+here would double-encode it (once as text, once as structured attributes). This is a deliberate
+divergence from the Log4j2 backend, which appends context into the text because Log4j2's
+structured-data story is weaker.
+
+### 5.3 Timestamp & exception
+
+- `data.timestampNanos` → `emit(timestamp = …)`. **Confirm the unit** `opentelemetry-kotlin`
+  expects (epoch nanos vs millis) against the pinned version; OTLP is epoch nanos, but verify the
+  Kotlin API contract.
+- Cause via `metadata.getSingleValue(LogContext.Key.LOG_CAUSE)` → `emit(exception = …)`. The Kotlin
+  SDK records it per the exception semantic conventions.
+
+### 5.4 Metadata + LogSite → attributes
+
+```kotlin
+private fun AttributesMutator.applyAttributes(data: LogData, metadata: MetadataProcessor) {
+    // log-site → OTel code.* semconv
+    val s = data.logSite
+    setStringAttribute("code.namespace", s.className)
+    setStringAttribute("code.function", s.methodName)
+    s.fileName?.let { setStringAttribute("code.filepath", it) }
+    if (s.lineNumber >= 0) setLongAttribute("code.lineno", s.lineNumber.toLong())
+
+    // scope + log-site metadata → attributes (LOG_CAUSE already consumed as exception)
+    metadata.process(AttributeHandler, this)
+}
+
+private object AttributeHandler : MetadataHandler<AttributesMutator>() {
+    override fun <T : Any> handle(key: MetadataKey<T>, value: T, ctx: AttributesMutator) {
+        if (key == LogContext.Key.LOG_CAUSE) return       // handled as exception
+        val name = "spine.${key.label}"                   // namespace to avoid semconv clashes
+        when (value) {
+            is Boolean -> ctx.setBooleanAttribute(name, value)
+            is Int -> ctx.setLongAttribute(name, value.toLong())
+            is Long -> ctx.setLongAttribute(name, value)
+            is Float -> ctx.setDoubleAttribute(name, value.toDouble())
+            is Double -> ctx.setDoubleAttribute(name, value)
+            is String -> ctx.setStringAttribute(name, value)
+            else -> ctx.setStringAttribute(name, value.toString())
+        }
+    }
+    // Override the repeated-key hook to accumulate into setStringListAttribute / setLongListAttribute, etc.
+}
+```
+
+Notes:
+
+- **Namespace metadata keys** (`spine.<label>`) so Spine's keys never collide with OTel
+  semantic-convention attribute names.
+- **Repeated keys** (`MetadataKey.canRepeat == true`): the `MetadataHandler` base provides a
+  repeated-value hook; collect those into the `*ListAttribute` setters rather than emitting the
+  last-wins single value.
+- `ScopedLoggingContext` data flows in automatically because `Platform.getInjectedMetadata()` is
+  merged by `MetadataProcessor.forScopeAndLogSite`. This is where Spine's context (bounded-context,
+  aggregate id, user) becomes structured OTel attributes — the differentiation that a plain
+  Log4j2-appender hop would flatten into text.
+- `Tags` (from `ScopedLoggingContext`) are a distinct concept from metadata keys; decide whether to
+  surface them as attributes too (recommended: yes, namespaced `spine.tag.<name>`).
+
+### 5.5 Trace correlation
+
+Passing `context = null` lets the Kotlin SDK stamp the active span's trace/span IDs onto the record.
+**Verify how the active `Context` is obtained per platform** — on the JVM it's typically
+thread-local/`ContextStorage`, but across coroutine suspension you need the OpenTelemetry context
+element wired in (see `api-ext` and the broader KMP context-propagation caveat in §10). If Spine
+logs from coroutines, correlation silently breaks without it.
+
+---
+
+## 6. Log-based events surface
+
+Because `eventName` is a parameter on `emit`, an event is a log record with a name. Two layers:
+
+### 6.1 Low level — already available
+
+Anyone can emit an event through the backend by attaching the event name as metadata that the
+backend maps to `emit(eventName = …)`. Define a Spine metadata key:
+
+```kotlin
+val EVENT_NAME: MetadataKey<String> = MetadataKey.single("otel.event.name", String::class)
+```
+
+…and in the backend, pull it out before the generic attribute loop and pass it as `eventName` (
+mirroring how OTel's own Logback appender recognizes an `otel.event.name` key).
+
+### 6.2 Ergonomic — a typed event API (Phase 3)
+
+```kotlin
+public fun WithLogging.logEvent(
+    name: String,
+    severity: Level = Level.INFO,
+    build: EventScope.() -> Unit = {},
+)
+```
+
+where `EventScope` collects typed attributes and ends in a single `emit(eventName = name, …)`. Keep
+`enabled(eventName = name)` guarding so disabled events cost nothing.
+
+### 6.3 Domain events ↔ observability events (draw this line explicitly)
+
+For an event-sourced system the word "event" is overloaded. **A Spine domain event** (persisted,
+replayable, the source of truth) **is not** an OTel observability event (lossy telemetry). Never use
+the OTel pipeline as an event store.
+
+The high-value, safe pattern is to emit an observability event *about* a domain event as it is
+handled/applied:
+
+- `event.name` ← the Protobuf message type name (e.g. `acme.orders.OrderPlaced`), which is naturally
+  low-cardinality and satisfies the OTel rule that names must not contain dynamic values.
+- attributes ← selected proto fields + `ScopedLoggingContext` (aggregate id, bounded context, user).
+- correlation ← the active span, automatically.
+
+This turns the existing domain-event flow into well-formed, trace-correlated telemetry with
+near-zero ceremony — the differentiation a generic appender can't provide because it has no
+knowledge of Spine's typed events.
+
+---
+
+## 7. Registration
+
+**JVM:** add `jvmMain/resources/META-INF/services/io.spine.logging.backend.BackendFactory`
+containing:
+
+```
+io.spine.logging.backend.otel.OtelBackendFactory
+```
+
+Exactly one `BackendFactory` should be on the classpath; if both the OTel and another backend are
+present, the platform's selection is undefined/last-wins. Document that consumers pick one backend
+artifact.
+
+```kotlin
+public class OtelBackendFactory : BackendFactory() {
+    override fun create(loggingClass: String): LoggerBackend {
+        val name = loggingClass.replace('$', '.')
+        val logger = OtelBackendSettings.current().loggerProvider.getLogger(name)
+        return OtelLoggerBackend(logger, loggerName = name)
+    }
+    override fun toString() = this::class.qualifiedName ?: "OtelBackendFactory"
+}
+```
+
+**Non-JVM:** see §9 — `ServiceLoader` does not exist; this is an open path in Spine itself.
+
+---
+
+## 8. Build setup (Gradle, KMP)
+
+Version catalog:
+
+```toml
+[versions]
+otelKotlin = "0.5.0"          # PIN exactly — pre-1.0, @ExperimentalApi
+
+[libraries]
+otel-kotlin-api = { module = "io.opentelemetry.kotlin:api", version.ref = "otelKotlin" }
+otel-kotlin-noop = { module = "io.opentelemetry.kotlin:noop", version.ref = "otelKotlin" }
+otel-kotlin-core = { module = "io.opentelemetry.kotlin:core", version.ref = "otelKotlin" }
+otel-kotlin-impl = { module = "io.opentelemetry.kotlin:implementation", version.ref = "otelKotlin" }
+otel-kotlin-compat = { module = "io.opentelemetry.kotlin:compat", version.ref = "otelKotlin" }
+otel-kotlin-otlp = { module = "io.opentelemetry.kotlin:exporters-otlp", version.ref = "otelKotlin" }
+otel-kotlin-inmem = { module = "io.opentelemetry.kotlin:exporters-in-memory", version.ref = "otelKotlin" }
+```
+
+Backend module (`:api` + `:noop` only):
+
+```kotlin
+kotlin {
+    jvm()
+    // androidTarget(); iosX64(); iosArm64(); iosSimulatorArm64(); js(); … per target-coverage check (§10)
+    sourceSets {
+        commonMain.dependencies {
+            api(projects.logging)                 // Spine backend SPI
+            implementation(libs.otel.kotlin.api)
+            implementation(libs.otel.kotlin.noop)
+        }
+        commonTest.dependencies { implementation(libs.otel.kotlin.inmem) }
+    }
+}
+```
+
+Bootstrap module (JVM, where the SDK is initialized) adds `core`+`implementation`+`exporters-otlp`,
+or `compat` + the `opentelemetry-java` BOM if you go the compat route.
+
+---
+
+## 9. Critical finding — KMP registration is unpaved in Spine
+
+The backend SPI (`BackendFactory`, `LoggerBackend`, `LogData`, `Metadata`) is in `commonMain`, **but
+every shipped backend (jul, log4j2) is JVM-only and is discovered via JVM `ServiceLoader`** (
+`META-INF/services`). The default JVM platform is `platforms/jvm-default-platform` (
+`DefaultPlatform`).
+
+Implications:
+
+- On **JVM**, registration is solved — copy the log4j2 pattern.
+- On **non-JVM targets** there is no `ServiceLoader`. How Spine selects a `BackendFactory` on
+  native/JS is **not demonstrated by any existing backend**. Before promising true multiplatform,
+  audit Spine's per-platform `Platform`/backend-selection wiring (look at how `Platform.getBackend`
+  /the platform default is resolved off-JVM) and expect to contribute that path. This is the single
+  biggest unknown in the KMP plan and the reason for the JVM-first phasing.
+
+---
+
+## 10. Risks & open questions
+
+1. **opentelemetry-kotlin maturity.** v0.5.0, `@ExperimentalApi`, logs in *Development*. Pin the
+   exact version; expect breaking changes; gate the backend behind its own opt-in artifact.
+2. **KMP backend registration (see §9).** Non-JVM selection path unproven in Spine.
+3. **Multiplatform exporter coverage.** Confirm `io.opentelemetry.kotlin:exporters-otlp` actually
+   supports your intended targets. Community KMP efforts had to hand-roll an iOS OTLP/HTTP
+   exporter (Ktor) because native OTLP coverage lagged — verify before promising iOS/native export.
+4. **Coroutine context propagation.** Trace correlation depends on the active `Context` being
+   present at `emit`. Across coroutine suspension/dispatch this is lost unless the OTel context
+   element is wired (thread-local approaches don't survive dispatcher hops). Validate explicitly.
+5. **Timestamp unit.** Confirm `emit(timestamp = …)` expects epoch nanos.
+6. **`AttributesMutator`/`Logger` signature drift.** Re-check against the pinned version before
+   finalizing the skeletons.
+7. **CONFIG severity mapping** is a documented judgment call (DEBUG4 vs INFO).
+8. **Double-encoding metadata.** Enforced by using `getLiteralLogMessage` + attributes; add a test
+   asserting the body contains no `[CONTEXT …]`.
+9. **Performance.** Build attributes only when `isLoggable`/`enabled`; the SPI already guards via
+   `isLoggable`, but the events API must guard with `enabled(eventName = …)` too.
+
+---
+
+## 11. Phased plan
+
+- **Phase 0 — JVM-via-compat spike.** Backend on JVM only, `OpenTelemetry` provided as
+  `javaOtel.toOtelKotlinApi()`. Validate the full path (Spine log → OTLP → backend of choice)against
+  the mature Java SDK. Lowest risk; proves the mapping before touching KMP.
+- **Phase 1 — KMP commonMain backend (`:api`).** Move the mapping into `commonMain`, JVM target
+  registered via `ServiceLoader`, SDK injected by the app. Severity, body, metadata→attributes,
+  cause, correlation all covered with tests on the in-memory exporter.
+- **Phase 2 — bootstrap module + native/JS.** Add `otel-backend-bootstrap`, tackle §9 (non-JVM
+  registration) and §10.3 (exporter coverage). Add the early-record buffer if needed.
+- **Phase 3 — ergonomic events API + domain-event integration.** `logEvent { … }`, proto-type →
+  `event.name`, the domain-event-vs-observability-event boundary (§6.3).
+
+---
+
+## 12. Testing
+
+- Use `io.opentelemetry.kotlin:exporters-in-memory` to capture emitted records and assert: severity
+  number, body text (no context suffix), attribute set (namespaced, repeated→list), exception
+  recorded, event name when set, and trace/span id when a span is active.
+- Mirror the existing `probe-backend` testing approach for backend-selection tests.
+- Add a coroutine correlation test (log inside a span-scoped coroutine, assert ids propagate).
+
+---
+
+## 13. OTEP 4430 alignment
+
+This design emits events through the **Logs API** (`emit(eventName = …)`), which is exactly the
+direction OTEP 4430 (Span Event API deprecation, March 2026) endorses; it never calls
+`Span.AddEvent`/`Span.RecordException`. `opentelemetry-kotlin` ships a `SpanEventCreator` in its
+tracing package — the optional compatibility shim that can surface log-based events back onto spans
+for backends that still expect them. You do not need it for this backend, but it's the escape hatch
+if a downstream trace view requires events-on-spans.
+
+---
+
+## 14. References
+
+- opentelemetry-kotlin (repo): https://github.com/open-telemetry/opentelemetry-kotlin
+- opentelemetry-kotlin getting started (coordinates, compat
+  mode): https://opentelemetry.io/docs/languages/kotlin/getting-started/
+- Embrace donation / KMP
+  rationale: https://opentelemetry.io/blog/2025/kotlin-multiplatform-opentelemetry/
+- Logs API spec (bridge vs ergonomic
+  API): https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/logs/api.md
+- Logs data model (event = log with
+  `event.name`): https://opentelemetry.io/docs/specs/otel/logs/data-model/
+- Event semantic conventions: https://opentelemetry.io/docs/specs/semconv/general/events/
+- Span Event API deprecation (blog): https://opentelemetry.io/blog/2026/deprecating-span-events/
+- OTEP 4430 (deprecation
+  plan): https://github.com/open-telemetry/opentelemetry-specification/blob/main/oteps/4430-span-event-api-deprecation-plan.md
+- Spine Logging (repo): https://github.com/SpineEventEngine/logging
+
+---
+
+*Generated as an implementation research spec. Verify all `opentelemetry-kotlin` signatures against
+the pinned v0.5.0 artifacts before finalizing code — the API is `@ExperimentalApi` and subject to
+change.*

From cb401fbc9edae34caf7bd240b55b80afe14324cf Mon Sep 17 00:00:00 2001
From: Alexander Yevsyukov <alexander.yevsyukov@teamdev.com>
Date: Sat, 27 Jun 2026 22:12:47 +0100
Subject: [PATCH 02/20] Add `otel-backend` Phase 0 implementation

---
 .agents/tasks/otel-backend-implementation.md  | 100 +++++------
 backends/otel-backend/build.gradle.kts        |  94 ++++++++++
 .../logging/backend/otel/AttributeMapping.kt  | 126 +++++++++++++
 .../backend/otel/OtelBackendSettings.kt       |  72 ++++++++
 .../logging/backend/otel/OtelLoggerBackend.kt | 100 +++++++++++
 .../logging/backend/otel/SeverityMapping.kt   |  56 ++++++
 .../backend/otel/OtelBackendFactory.kt        |  60 +++++++
 .../backend/otel/OtelLoggerBackendSpec.kt     | 169 ++++++++++++++++++
 .../otel/given/RecordingLogRecordProcessor.kt |  60 +++++++
 .../logging/backend/otel/given/StubLogData.kt |  89 +++++++++
 .../logging/backend/otel/given/StubLogSite.kt |  55 ++++++
 .../backend/otel/given/StubMetadata.kt        |  62 +++++++
 .../dependency/lib/OpenTelemetryKotlin.kt     |  92 ++++++++++
 settings.gradle.kts                           |   5 +-
 14 files changed, 1084 insertions(+), 56 deletions(-)
 create mode 100644 backends/otel-backend/build.gradle.kts
 create mode 100644 backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/AttributeMapping.kt
 create mode 100644 backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelBackendSettings.kt
 create mode 100644 backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelLoggerBackend.kt
 create mode 100644 backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/SeverityMapping.kt
 create mode 100644 backends/otel-backend/src/jvmMain/kotlin/io/spine/logging/backend/otel/OtelBackendFactory.kt
 create mode 100644 backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
 create mode 100644 backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/RecordingLogRecordProcessor.kt
 create mode 100644 backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/StubLogData.kt
 create mode 100644 backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/StubLogSite.kt
 create mode 100644 backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/StubMetadata.kt
 create mode 100644 buildSrc/src/main/kotlin/io/spine/dependency/lib/OpenTelemetryKotlin.kt

diff --git a/.agents/tasks/otel-backend-implementation.md b/.agents/tasks/otel-backend-implementation.md
index 9f388370..1d18eb02 100644
--- a/.agents/tasks/otel-backend-implementation.md
+++ b/.agents/tasks/otel-backend-implementation.md
@@ -2,7 +2,7 @@
 slug: otel-backend-implementation
 branch: otel
 owner: claude
-status: draft
+status: in-progress
 started: 2026-06-27
 related-memories: []
 ---
@@ -118,58 +118,46 @@ backends/otel-backend-bootstrap/   ← OPTIONAL, Phase 2 (jvmMain SDK init, turn
 
 ## Plan
 
-### Phase 0 — spike: native SDK end-to-end on JVM (de-risk)
-- [ ] Copy `core-jvm`'s `OpenTelemetryKotlin.kt` into
-      `buildSrc/src/main/kotlin/io/spine/dependency/lib/`; confirm the shape against
-      the `dependency-audit` skill. Add `AutoService`/`AutoServiceKsp` usage check —
-      both already exist ([`Auto.kt`](buildSrc/src/main/kotlin/io/spine/dependency/lib/Auto.kt), [`Ksp.kt`](buildSrc/src/main/kotlin/io/spine/dependency/build/Ksp.kt)).
-- [ ] Register the module: add `"otel-backend"` to `includeBackend(...)` in
+### Phase 0 — spike: native SDK end-to-end on JVM (de-risk) ✅
+- [x] Copy `core-jvm`'s `OpenTelemetryKotlin.kt` into
+      [`buildSrc/.../lib/OpenTelemetryKotlin.kt`](buildSrc/src/main/kotlin/io/spine/dependency/lib/OpenTelemetryKotlin.kt)
+      (0.4.0; api/noop/core/implementation/compat). `AutoService`/`AutoServiceKsp` already exist.
+- [x] Register the module: `"otel-backend"` added to `includeBackend(...)` in
       [`settings.gradle.kts`](settings.gradle.kts).
-- [ ] Create `backends/otel-backend/build.gradle.kts`: `plugins { kmp-module; ksp }`;
-      `commonMain` → `api(OpenTelemetryKotlin.api)` + `noop` + `project(":logging")`;
-      `jvmMain` → `AutoService.annotations`; `kspJvm(AutoServiceKsp.processor)`;
-      `jvmTest` → `OpenTelemetryKotlin.core` + `.implementation` + `logging-testlib` +
-      `runtimeOnly(project(":jvm-default-platform"))`. Add `@OptIn(ExperimentalApi::class)`.
-- [ ] **Verify the logs SDK DSL with `api-discovery` on `:implementation` 0.4.0** —
-      confirm the `createOpenTelemetry { loggerProvider { export { … } } }` shape and the
-      `LogRecordProcessor`/exporter type (the api cache only has `:api`, not the SDK).
-      Also confirm the **`emit(timestamp)` unit** (epoch nanos vs millis).
-- [ ] Build a `RecordingLogRecordProcessor` (mirror `core-jvm`'s `RecordingSpanProcessor`),
-      wire `createOpenTelemetry { loggerProvider { export { it } } }`, call
-      `OtelBackendSettings.use(...)`, log once through Spine, assert the record round-trips
-      (severity + body). This throwaway proof becomes the first real test.
-
-### Phase 1 — production backend
-- [ ] `commonMain/OtelBackendSettings.kt`: `@Volatile private var instance = NoopOpenTelemetry`;
-      `fun use(openTelemetry: OpenTelemetry)`; `internal fun current()`. No-op default,
-      drop-before-`use`. KDoc it as a new convention (correction C6).
-- [ ] `commonMain/SeverityMapping.kt`: numeric-threshold `Level.toSeverityNumber()`
-      (report §5.1) → `FATAL/ERROR/WARN/INFO/DEBUG4(CONFIG)/DEBUG/TRACE2/TRACE`.
-- [ ] `commonMain/OtelLoggerBackend.kt`:
-      - `isLoggable(level)` → `logger.enabled(severityNumber = level.toSeverityNumber())`.
-      - `log(data)` → `MetadataProcessor.forScopeAndLogSite(Platform.getInjectedMetadata(), data.metadata)`;
-        `body = getLiteralLogMessage(data)`; `severityNumber`/`severityText = data.level.name`;
-        `exception = metadata.getSingleValue(LogContext.Key.LOG_CAUSE)`;
-        `timestamp = data.timestampNanos` (**unit confirmed in Phase 0**);
-        `context = null` (⇒ implicit/active context, per the `emit` KDoc);
-        `attributes = { applyAttributes(data, metadata) }`.
-      - `handleError(error, badData)` → emit an ERROR record carrying `badData.toString()`.
-- [ ] `commonMain/AttributeMapping.kt`: a `MetadataHandler<AttributesMutator>` via
-      `MetadataHandler.builder()`:
-      - LogSite → `code.namespace`/`code.function`/`code.filepath`/`code.lineno`.
-      - `handle(...)`: skip `LOG_CAUSE`; namespace keys `spine.<label>`; type-switch with
-        widening — `Boolean→setBooleanAttribute`, `Int/Short/Byte/Long→setLongAttribute`,
-        `Float/Double→setDoubleAttribute`, `String→setStringAttribute`, else `toString()`.
-      - `handleRepeated(key, values, ctx)`: accumulate into the matching `*ListAttribute`.
-      - `Tags` (from `ScopedLoggingContext`): surface as `spine.tag.<name>` (mirror `LogEvents.kt`).
-- [ ] `jvmMain/OtelBackendFactory.kt`: `@AutoService(BackendFactory::class) class … : BackendFactory()`;
-      `name = loggingClass.replace('$', '.')`,
-      `OtelBackendSettings.current().loggerProvider.getLogger(name)`, return
-      `OtelLoggerBackend(logger, loggerName = name)`; override `toString()`.
-- [ ] Tests (`jvmTest`, Kotest + JUnit5, `internal` `*Spec`, `@DisplayName`): severity
-      mapping; body has **no** `[CONTEXT …]`; attributes namespaced + repeated→list +
-      widened numerics; throwable recorded; logger-name routing; `isLoggable` gating;
-      `@AutoService` discovery (record captured through the full Spine→DefaultPlatform path).
+- [x] [`build.gradle.kts`](backends/otel-backend/build.gradle.kts): `plugins { kmp-module; ksp }`;
+      `commonMain` → `api(OpenTelemetryKotlin.api)` + `noop` + `:logging`; `jvmMain` →
+      `AutoService.annotations` + `kspJvm(AutoServiceKsp.processor)`; `jvmTest` → `core` +
+      `implementation` + `logging-testlib` + `runtimeOnly(:jvm-default-platform)`.
+      **Two build wrinkles found & fixed:** (1) KSP-on-KMP works via `kspJvm` (no fallback
+      needed); (2) `kmp-module` does NOT put the JUnit Platform on `jvmTest` (only
+      `jvm-module` configures the `test` task), so added an explicit
+      `tasks.named<Test>("jvmTest") { useJUnitPlatform() }`.
+- [x] **Logs SDK DSL + timestamp unit confirmed** (upstream `v0.4.0` source):
+      `createOpenTelemetry { loggerProvider { export { processor } } }`,
+      `LogRecordProcessor.onEmit(ReadWriteLogRecord, Context)`, `ReadableLogRecord`
+      getters, and `emit(timestamp)` = **epoch nanoseconds** (passes through unchanged).
+- [x] [`RecordingLogRecordProcessor`](backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/RecordingLogRecordProcessor.kt)
+      (mirrors `core-jvm`'s `RecordingSpanProcessor`) drives the end-to-end test — no
+      in-memory-exporter artifact needed.
+
+### Phase 1 — production backend ✅
+- [x] [`OtelBackendSettings.kt`](backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelBackendSettings.kt):
+      `@Volatile` holder, `NoopOpenTelemetry` default, `use()`/`current()`. Documented as new convention.
+- [x] [`SeverityMapping.kt`](backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/SeverityMapping.kt):
+      numeric-threshold `Level.toSeverityNumber()`; CONFIG → `DEBUG4`.
+- [x] [`OtelLoggerBackend.kt`](backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelLoggerBackend.kt):
+      `isLoggable` via `enabled`; `log` maps body (`getLiteralLogMessage`), severity, nanos
+      timestamp, cause→exception, attributes; implicit context for correlation; `handleError`.
+- [x] [`AttributeMapping.kt`](backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/AttributeMapping.kt):
+      `MetadataHandler.builder()` with default single + `setDefaultRepeatedHandler`
+      (repeated→`*ListAttribute`), `.ignoring(LOG_CAUSE)`, `value is Tags` → `spine.tag.<name>`;
+      LogSite → `code.*`; numeric widening (no `Int`/`Float` setters in `AttributesMutator`).
+- [x] [`OtelBackendFactory.kt`](backends/otel-backend/src/jvmMain/kotlin/io/spine/logging/backend/otel/OtelBackendFactory.kt):
+      `@AutoService(BackendFactory::class)`; resolves the logger from `OtelBackendSettings`.
+- [x] [`OtelLoggerBackendSpec`](backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt) —
+      **10 tests, all passing**: body, no `[CONTEXT]`, severity number+text, `code.*`,
+      `spine.*` single + repeated→list, cause→`exception.*` (not `spine.cause`), timestamp
+      passthrough, and factory resolution via `OtelBackendSettings`.
 
 ### Phase 2 — bootstrap module + correlation hardening
 - [ ] `backends/otel-backend-bootstrap` (kmp-module, jvmMain SDK init): read config,
@@ -235,5 +223,9 @@ backends/otel-backend-bootstrap/   ← OPTIONAL, Phase 2 (jvmMain SDK init, turn
   (proven in `core-jvm/server-otel`) and **`@AutoService` + KSP** registration. Module
   retargeted to **`kmp-module`** (JVM only) with the mapping in `commonMain` to minimise
   future KMP migration. Verified the real 0.4.0 Logs API from the api-discovery cache
-  and the `core-jvm` `OpenTelemetryKotlin` dep object / native-SDK test pattern; updated
-  the dependency, build, and testing steps accordingly. Awaiting approval to execute.
+  and the `core-jvm` `OpenTelemetryKotlin` dep object / native-SDK test pattern.
+- 2026-06-27 — **Phases 0 & 1 implemented and verified.** `./gradlew :otel-backend:build`
+  is green (compile + detekt + kover + license); `:otel-backend:jvmTest` runs **10/10
+  passing** (had to JDK-17 the build and add `useJUnitPlatform()` to the kmp `jvmTest`).
+  KSP emits the `@AutoService` service file naming `OtelBackendFactory`. Timestamp unit
+  and logs SDK DSL confirmed against upstream `v0.4.0`. Phases 2–3 remain.
diff --git a/backends/otel-backend/build.gradle.kts b/backends/otel-backend/build.gradle.kts
new file mode 100644
index 00000000..dd013d8e
--- /dev/null
+++ b/backends/otel-backend/build.gradle.kts
@@ -0,0 +1,94 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+import io.spine.dependency.lib.AutoService
+import io.spine.dependency.lib.AutoServiceKsp
+import io.spine.dependency.lib.OpenTelemetryKotlin
+import io.spine.gradle.testing.registerTestTasks
+import org.gradle.api.tasks.testing.Test
+
+plugins {
+    `kmp-module`
+    ksp
+}
+
+kotlin {
+    @Suppress("unused") // Source set `val`s are used implicitly.
+    sourceSets {
+        val commonMain by getting {
+            dependencies {
+                // The Spine logging backend SPI.
+                api(project(":logging"))
+
+                // The OpenTelemetry Kotlin API. Exposed in the public API of
+                // `OtelBackendSettings.use(...)`, hence `api` rather than `implementation`.
+                api(OpenTelemetryKotlin.api)
+
+                // The no-op `OpenTelemetry` used as the default until an instance is injected.
+                implementation(OpenTelemetryKotlin.noop)
+            }
+        }
+        val jvmMain by getting {
+            dependencies {
+                // `@AutoService` registers the JVM `BackendFactory` for `ServiceLoader`.
+                implementation(AutoService.annotations)
+            }
+        }
+        val jvmTest by getting {
+            dependencies {
+                // The native Kotlin OpenTelemetry SDK, used only by tests to build an
+                // `OpenTelemetry` instance with a recording log-record processor.
+                implementation(OpenTelemetryKotlin.core)
+                implementation(OpenTelemetryKotlin.implementation)
+
+                implementation(project(":logging-testlib"))
+
+                // Provides `DefaultPlatform`, which discovers the `@AutoService` factory,
+                // so the full Spine → backend path can be exercised end-to-end.
+                runtimeOnly(project(":jvm-default-platform"))
+            }
+        }
+    }
+}
+
+dependencies {
+    // KSP generates the `META-INF/services` registration from `@AutoService` on the
+    // JVM target. In a KMP module the configuration is target-suffixed (`kspJvm`).
+    add("kspJvm", AutoServiceKsp.processor)
+}
+
+// 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<Test>("jvmTest") {
+    useJUnitPlatform()
+    testLogging {
+        events("passed", "skipped", "failed")
+    }
+}
diff --git a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/AttributeMapping.kt b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/AttributeMapping.kt
new file mode 100644
index 00000000..0e4b6bc8
--- /dev/null
+++ b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/AttributeMapping.kt
@@ -0,0 +1,126 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+@file:OptIn(ExperimentalApi::class)
+
+package io.spine.logging.backend.otel
+
+import io.opentelemetry.kotlin.ExperimentalApi
+import io.opentelemetry.kotlin.attributes.AttributesMutator
+import io.spine.logging.LogContext
+import io.spine.logging.backend.LogData
+import io.spine.logging.backend.MetadataHandler
+import io.spine.logging.backend.MetadataProcessor
+import io.spine.logging.context.Tags
+
+/**
+ * The prefix applied to Spine metadata keys so they never collide with
+ * OpenTelemetry semantic-convention attribute names.
+ */
+private const val SPINE_PREFIX = "spine."
+
+/**
+ * The prefix applied to individual [Tags] entries.
+ */
+private const val TAG_PREFIX = "spine.tag."
+
+/**
+ * Records the log site of the given [data] as OpenTelemetry `code.*`
+ * semantic-convention attributes.
+ */
+internal fun AttributesMutator.putLogSite(data: LogData) {
+    val site = data.logSite
+    setStringAttribute("code.namespace", site.className)
+    setStringAttribute("code.function", site.methodName)
+    site.fileName?.let { setStringAttribute("code.filepath", it) }
+    if (site.lineNumber > 0) {
+        setLongAttribute("code.lineno", site.lineNumber.toLong())
+    }
+}
+
+/**
+ * Records the scope and log-site [metadata] as attributes.
+ *
+ * The throwable carried under [LogContext.Key.LOG_CAUSE] is ignored here,
+ * as it is emitted as the log record's exception. [Tags] are expanded into
+ * individual `spine.tag.<name>` attributes; all other keys are namespaced
+ * under `spine.<label>`.
+ */
+internal fun AttributesMutator.putMetadata(metadata: MetadataProcessor) {
+    metadata.process(attributeHandler, this)
+}
+
+private val attributeHandler: MetadataHandler<AttributesMutator> =
+    MetadataHandler.builder<AttributesMutator> { key, value, mutator ->
+        mutator.putValue(SPINE_PREFIX + key.label, value)
+    }.setDefaultRepeatedHandler { key, values, mutator ->
+        mutator.putValues(SPINE_PREFIX + key.label, values)
+    }.addHandler(LogContext.Key.TAGS) { _, tags, mutator ->
+        mutator.putTags(tags)
+    }.ignoring(
+        // The cause is emitted as the record's exception, not as an attribute.
+        LogContext.Key.LOG_CAUSE
+    ).build()
+
+private fun AttributesMutator.putValue(name: String, value: Any) {
+    when (value) {
+        is Boolean -> setBooleanAttribute(name, value)
+        is Byte, is Short, is Int, is Long -> setLongAttribute(name, (value as Number).toLong())
+        is Float, is Double -> setDoubleAttribute(name, (value as Number).toDouble())
+        is String -> setStringAttribute(name, value)
+        else -> setStringAttribute(name, value.toString())
+    }
+}
+
+private fun AttributesMutator.putValues(name: String, values: Iterator<Any>) {
+    val list = values.asSequence().toList()
+    if (list.isEmpty()) {
+        return
+    }
+    when (list.first()) {
+        is Boolean -> setBooleanListAttribute(name, list.map { it as Boolean })
+        is Byte, is Short, is Int, is Long ->
+            setLongListAttribute(name, list.map { (it as Number).toLong() })
+        is Float, is Double ->
+            setDoubleListAttribute(name, list.map { (it as Number).toDouble() })
+        is String -> setStringListAttribute(name, list.map { it as String })
+        else -> setStringListAttribute(name, list.map { it.toString() })
+    }
+}
+
+private fun AttributesMutator.putTags(tags: Tags) {
+    for ((name, values) in tags.asMap()) {
+        val attributeKey = TAG_PREFIX + name
+        val present = values.filterNotNull()
+        when {
+            // A label-only tag carries no value; record its presence.
+            present.isEmpty() -> setBooleanAttribute(attributeKey, true)
+            present.size == 1 -> putValue(attributeKey, present.first())
+            // A tag may hold values of mixed types; render them as strings.
+            else -> setStringListAttribute(attributeKey, present.map { it.toString() })
+        }
+    }
+}
diff --git a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelBackendSettings.kt b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelBackendSettings.kt
new file mode 100644
index 00000000..ee7f5c78
--- /dev/null
+++ b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelBackendSettings.kt
@@ -0,0 +1,72 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+@file:OptIn(ExperimentalApi::class)
+
+package io.spine.logging.backend.otel
+
+import io.opentelemetry.kotlin.ExperimentalApi
+import io.opentelemetry.kotlin.NoopOpenTelemetry
+import io.opentelemetry.kotlin.OpenTelemetry
+
+/**
+ * Holds the [OpenTelemetry] instance the backend emits log records with.
+ *
+ * The Spine backend SPI constructs a [OtelBackendFactory] without arguments
+ * (via `ServiceLoader` on the JVM), so the instance cannot be supplied through
+ * the factory constructor. Instead, the application injects it here once, at
+ * startup, before any logging happens:
+ *
+ * ```
+ * OtelBackendSettings.use(createOpenTelemetry { loggerProvider { export { … } } })
+ * ```
+ *
+ * Until [use] is called, the backend emits to [NoopOpenTelemetry] and records
+ * are dropped. This is a new convention for Spine backends — no other shipped
+ * backend supports programmatic injection — and it mirrors the lazily-resolved,
+ * default-then-override shape of the platform's own backend-factory lookup.
+ */
+public object OtelBackendSettings {
+
+    @Volatile
+    private var instance: OpenTelemetry = NoopOpenTelemetry
+
+    /**
+     * Sets the [OpenTelemetry] instance the backend will use.
+     *
+     * Call this once during application startup. The supplied instance is owned
+     * by the caller, including its lifecycle and shutdown.
+     */
+    public fun use(openTelemetry: OpenTelemetry) {
+        instance = openTelemetry
+    }
+
+    /**
+     * Returns the currently configured [OpenTelemetry] instance,
+     * or [NoopOpenTelemetry] if none was injected.
+     */
+    internal fun current(): OpenTelemetry = instance
+}
diff --git a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelLoggerBackend.kt b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelLoggerBackend.kt
new file mode 100644
index 00000000..0cad618c
--- /dev/null
+++ b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelLoggerBackend.kt
@@ -0,0 +1,100 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+@file:OptIn(ExperimentalApi::class)
+
+package io.spine.logging.backend.otel
+
+import io.opentelemetry.kotlin.ExperimentalApi
+import io.opentelemetry.kotlin.logging.Logger
+import io.opentelemetry.kotlin.logging.SeverityNumber
+import io.spine.logging.Level
+import io.spine.logging.LogContext
+import io.spine.logging.backend.LogData
+import io.spine.logging.backend.LoggerBackend
+import io.spine.logging.backend.MetadataProcessor
+import io.spine.logging.backend.Platform
+import io.spine.logging.backend.SimpleMessageFormatter
+
+/**
+ * A [LoggerBackend] that emits Spine log statements as OpenTelemetry log records.
+ *
+ * Each [LogData] is mapped onto a single [Logger.emit] call:
+ *
+ * - the rendered message (without the `[CONTEXT …]` suffix) becomes the body;
+ * - the [Level] becomes the [SeverityNumber] (see [toSeverityNumber]) and the
+ *   severity text;
+ * - the throwable carried by [LogContext.Key.LOG_CAUSE] becomes the exception;
+ * - the timestamp is passed through as epoch nanoseconds;
+ * - the log site and the merged scope/log-site metadata become attributes
+ *   (see [putLogSite] and [putMetadata]).
+ *
+ * The active OpenTelemetry [Context][io.opentelemetry.kotlin.context.Context] is
+ * left implicit (`context = null`), so the SDK stamps the current span's
+ * trace and span identifiers onto the record.
+ *
+ * @param logger The OpenTelemetry logger to emit records with.
+ * @param loggerName The instrumentation scope name, used by the SPI.
+ */
+internal class OtelLoggerBackend(
+    private val logger: Logger,
+    override val loggerName: String?,
+) : LoggerBackend() {
+
+    override fun isLoggable(level: Level): Boolean =
+        logger.enabled(severityNumber = level.toSeverityNumber())
+
+    override fun log(data: LogData) {
+        val metadata = MetadataProcessor.forScopeAndLogSite(
+            Platform.getInjectedMetadata(),
+            data.metadata
+        )
+        val cause = metadata.getSingleValue(LogContext.Key.LOG_CAUSE)
+        logger.emit(
+            body = SimpleMessageFormatter.getLiteralLogMessage(data),
+            timestamp = data.timestampNanos,
+            severityNumber = data.level.toSeverityNumber(),
+            severityText = data.level.name,
+            exception = cause,
+            attributes = {
+                putLogSite(data)
+                putMetadata(metadata)
+            }
+        )
+    }
+
+    override fun handleError(error: RuntimeException, badData: LogData) {
+        logger.emit(
+            body = "Spine logging backend error: ${error.message}",
+            severityNumber = SeverityNumber.ERROR,
+            severityText = SeverityNumber.ERROR.name,
+            exception = error,
+            attributes = {
+                setStringAttribute("spine.logging.bad_data", badData.toString())
+            }
+        )
+    }
+}
diff --git a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/SeverityMapping.kt b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/SeverityMapping.kt
new file mode 100644
index 00000000..b9d9fc0e
--- /dev/null
+++ b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/SeverityMapping.kt
@@ -0,0 +1,56 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+@file:OptIn(ExperimentalApi::class)
+
+package io.spine.logging.backend.otel
+
+import io.opentelemetry.kotlin.ExperimentalApi
+import io.opentelemetry.kotlin.logging.SeverityNumber
+import io.spine.logging.Level
+
+/**
+ * Maps a Spine logging [Level] onto an OpenTelemetry [SeverityNumber].
+ *
+ * The mapping is by numeric threshold rather than by name, so that custom
+ * levels (and the standard aliases `SEVERE`, `FINE`, `TRACE`) degrade to the
+ * nearest standard severity instead of falling through to a default.
+ *
+ * `CONFIG` (700) has no exact OpenTelemetry counterpart — it sits between
+ * `INFO` and `DEBUG` in `java.util.logging` semantics — and is mapped to
+ * [SeverityNumber.DEBUG4], the most detailed `DEBUG` band, keeping it just
+ * above plain `DEBUG`.
+ */
+internal fun Level.toSeverityNumber(): SeverityNumber = when {
+    value >= Level.FATAL.value -> SeverityNumber.FATAL     // 2000 -> 21
+    value >= Level.ERROR.value -> SeverityNumber.ERROR     // 1000 -> 17
+    value >= Level.WARNING.value -> SeverityNumber.WARN    //  900 -> 13
+    value >= Level.INFO.value -> SeverityNumber.INFO       //  800 ->  9
+    value >= Level.CONFIG.value -> SeverityNumber.DEBUG4   //  700 ->  8
+    value >= Level.DEBUG.value -> SeverityNumber.DEBUG     //  500 ->  5
+    value >= Level.FINER.value -> SeverityNumber.TRACE2    //  400 ->  2
+    else -> SeverityNumber.TRACE                           //  300 ->  1
+}
diff --git a/backends/otel-backend/src/jvmMain/kotlin/io/spine/logging/backend/otel/OtelBackendFactory.kt b/backends/otel-backend/src/jvmMain/kotlin/io/spine/logging/backend/otel/OtelBackendFactory.kt
new file mode 100644
index 00000000..f6d6ef44
--- /dev/null
+++ b/backends/otel-backend/src/jvmMain/kotlin/io/spine/logging/backend/otel/OtelBackendFactory.kt
@@ -0,0 +1,60 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+@file:OptIn(ExperimentalApi::class)
+
+package io.spine.logging.backend.otel
+
+import com.google.auto.service.AutoService
+import io.opentelemetry.kotlin.ExperimentalApi
+import io.spine.logging.backend.BackendFactory
+import io.spine.logging.backend.LoggerBackend
+
+/**
+ * Creates [OtelLoggerBackend] instances backed by the [OpenTelemetry]
+ * [io.opentelemetry.kotlin.logging.Logger] resolved from [OtelBackendSettings].
+ *
+ * When using `io.spine.logging.backend.system.DefaultPlatform`, this factory is
+ * picked up automatically via `ServiceLoader` (registered by `@AutoService`) if
+ * it is the only [BackendFactory] on the classpath. To select it explicitly when
+ * several backends are present, set the `spine.logging.backend_factory` system
+ * property to this class' fully-qualified name.
+ *
+ * The instrumentation scope name passed to the logger provider is the logging
+ * class name with `$` replaced by `.`, matching the other Spine backends.
+ */
+@AutoService(BackendFactory::class)
+public class OtelBackendFactory : BackendFactory() {
+
+    override fun create(loggingClass: String): LoggerBackend {
+        val name = loggingClass.replace('$', '.')
+        val logger = OtelBackendSettings.current().loggerProvider.getLogger(name)
+        return OtelLoggerBackend(logger, loggerName = name)
+    }
+
+    /** Returns a fully-qualified name of this class. */
+    override fun toString(): String = javaClass.name
+}
diff --git a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
new file mode 100644
index 00000000..d9f42a89
--- /dev/null
+++ b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
@@ -0,0 +1,169 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+@file:OptIn(ExperimentalApi::class)
+
+package io.spine.logging.backend.otel
+
+import io.kotest.matchers.collections.shouldHaveSize
+import io.kotest.matchers.maps.shouldContainKey
+import io.kotest.matchers.maps.shouldNotContainKey
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.string.shouldNotContain
+import io.opentelemetry.kotlin.ExperimentalApi
+import io.opentelemetry.kotlin.createOpenTelemetry
+import io.opentelemetry.kotlin.logging.SeverityNumber
+import io.spine.logging.Level
+import io.spine.logging.LogContext
+import io.spine.logging.MetadataKey
+import io.spine.logging.backend.otel.given.RecordingLogRecordProcessor
+import io.spine.logging.backend.otel.given.StubLogData
+import io.spine.logging.backend.otel.given.StubLogSite
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+
+@DisplayName("`OtelLoggerBackend` should")
+internal class OtelLoggerBackendSpec {
+
+    private lateinit var processor: RecordingLogRecordProcessor
+    private lateinit var backend: OtelLoggerBackend
+    private val lastRecord get() = processor.records.last()
+
+    @BeforeEach
+    fun setUp() {
+        processor = RecordingLogRecordProcessor()
+        val otel = createOpenTelemetry {
+            loggerProvider {
+                export { processor }
+            }
+        }
+        val logger = otel.loggerProvider.getLogger(LOGGER_NAME)
+        backend = OtelLoggerBackend(logger, LOGGER_NAME)
+    }
+
+    @Test
+    fun `emit a literal message as the record body`() {
+        backend.log(StubLogData(LITERAL))
+        lastRecord.body shouldBe LITERAL
+    }
+
+    @Test
+    fun `not append the context block to the body`() {
+        backend.log(StubLogData(LITERAL).addMetadata(STR_KEY, "value"))
+        val body = lastRecord.body
+        body shouldBe LITERAL
+        (body as String) shouldNotContain "[CONTEXT"
+    }
+
+    @Test
+    fun `set the severity text from the level name`() {
+        backend.log(StubLogData(LITERAL).setLevel(Level.WARNING))
+        lastRecord.severityText shouldBe "WARNING"
+    }
+
+    @Test
+    fun `map a level to a severity number`() {
+        val expected = mapOf(
+            Level.FINEST to SeverityNumber.TRACE,
+            Level.FINER to SeverityNumber.TRACE2,
+            Level.DEBUG to SeverityNumber.DEBUG,
+            Level.CONFIG to SeverityNumber.DEBUG4,
+            Level.INFO to SeverityNumber.INFO,
+            Level.WARNING to SeverityNumber.WARN,
+            Level.ERROR to SeverityNumber.ERROR,
+            Level.FATAL to SeverityNumber.FATAL,
+        )
+        expected.forEach { (level, severity) ->
+            backend.log(StubLogData(level.name).setLevel(level))
+            lastRecord.severityNumber shouldBe severity
+        }
+    }
+
+    @Test
+    fun `record the log site as code attributes`() {
+        val site = StubLogSite("com.acme.Service", "handle", 42, "Service.kt")
+        backend.log(StubLogData(LITERAL).setLogSite(site))
+        with(lastRecord.attributes) {
+            this["code.namespace"] shouldBe "com.acme.Service"
+            this["code.function"] shouldBe "handle"
+            this["code.filepath"] shouldBe "Service.kt"
+            this["code.lineno"] shouldBe 42L
+        }
+    }
+
+    @Test
+    fun `namespace custom metadata under 'spine'`() {
+        backend.log(StubLogData(LITERAL).addMetadata(STR_KEY, "value"))
+        lastRecord.attributes["spine.str"] shouldBe "value"
+    }
+
+    @Test
+    fun `collect repeated metadata into a list`() {
+        backend.log(
+            StubLogData(LITERAL)
+                .addMetadata(INT_KEY, 1)
+                .addMetadata(INT_KEY, 2)
+        )
+        lastRecord.attributes["spine.int"] shouldBe listOf(1L, 2L)
+    }
+
+    @Test
+    fun `record the cause as an exception, not an attribute`() {
+        val cause = RuntimeException("Boom")
+        backend.log(StubLogData(LITERAL).addMetadata(LogContext.Key.LOG_CAUSE, cause))
+        with(lastRecord.attributes) {
+            this shouldContainKey "exception.message"
+            this["exception.message"] shouldBe "Boom"
+            this shouldNotContainKey "spine.cause"
+        }
+    }
+
+    @Test
+    fun `pass the timestamp through unchanged`() {
+        backend.log(StubLogData(LITERAL).setTimestampNanos(TIMESTAMP_NANOS))
+        lastRecord.timestamp shouldBe TIMESTAMP_NANOS
+    }
+
+    @Test
+    fun `resolve the injected OpenTelemetry instance via the factory`() {
+        OtelBackendSettings.use(
+            createOpenTelemetry { loggerProvider { export { processor } } }
+        )
+        val created = OtelBackendFactory().create("io.spine.Foo\$Bar")
+        created.loggerName shouldBe "io.spine.Foo.Bar"
+        created.log(StubLogData(LITERAL))
+        processor.records shouldHaveSize 1
+    }
+
+    companion object {
+        private const val LOGGER_NAME = "io.spine.LoggerName"
+        private const val LITERAL = "Hello world"
+        private const val TIMESTAMP_NANOS = 1_234_567_890L
+        private val STR_KEY = MetadataKey.single<String>("str")
+        private val INT_KEY = MetadataKey.repeated<Int>("int")
+    }
+}
diff --git a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/RecordingLogRecordProcessor.kt b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/RecordingLogRecordProcessor.kt
new file mode 100644
index 00000000..bfba263e
--- /dev/null
+++ b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/RecordingLogRecordProcessor.kt
@@ -0,0 +1,60 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+@file:OptIn(ExperimentalApi::class)
+
+package io.spine.logging.backend.otel.given
+
+import io.opentelemetry.kotlin.ExperimentalApi
+import io.opentelemetry.kotlin.context.Context
+import io.opentelemetry.kotlin.export.OperationResultCode
+import io.opentelemetry.kotlin.logging.export.LogRecordProcessor
+import io.opentelemetry.kotlin.logging.model.ReadWriteLogRecord
+import io.opentelemetry.kotlin.logging.model.ReadableLogRecord
+import java.util.Collections.synchronizedList
+
+/**
+ * A [LogRecordProcessor] that records every emitted log record in memory,
+ * for assertions in tests.
+ */
+internal class RecordingLogRecordProcessor : LogRecordProcessor {
+
+    private val recorded: MutableList<ReadableLogRecord> = synchronizedList(mutableListOf())
+
+    /**
+     * An immutable snapshot of the records emitted so far.
+     */
+    val records: List<ReadableLogRecord>
+        get() = synchronized(recorded) { recorded.toList() }
+
+    override fun onEmit(log: ReadWriteLogRecord, context: Context) {
+        recorded.add(log)
+    }
+
+    override suspend fun forceFlush(): OperationResultCode = OperationResultCode.Success
+
+    override suspend fun shutdown(): OperationResultCode = OperationResultCode.Success
+}
diff --git a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/StubLogData.kt b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/StubLogData.kt
new file mode 100644
index 00000000..8344964f
--- /dev/null
+++ b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/StubLogData.kt
@@ -0,0 +1,89 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package io.spine.logging.backend.otel.given
+
+import com.google.errorprone.annotations.CanIgnoreReturnValue
+import io.spine.logging.Level
+import io.spine.logging.LogContext
+import io.spine.logging.LogSite
+import io.spine.logging.MetadataKey
+import io.spine.logging.backend.LogData
+
+/**
+ * A mutable [LogData] for testing backends and other log-handling code.
+ */
+@Suppress("TooManyFunctions") // Many getters and setters.
+internal class StubLogData(literalArgument: Any?) : LogData {
+
+    override var level: Level = Level.INFO
+    private val _literalArgument: Any? = literalArgument
+    override var timestampNanos = 0L
+    override val metadata = StubMetadata()
+    override var logSite: LogSite = LOG_SITE
+
+    companion object {
+        private const val LOGGER_NAME = "io.spine.LoggerName"
+        private const val LOGGING_CLASS = "io.spine.FakeClass"
+        private const val LOGGING_METHOD = "doAct"
+        private const val LINE_NUMBER = 123
+        private const val SOURCE_FILE = "src/io/spine/FakeClass.java"
+        private val LOG_SITE = StubLogSite(LOGGING_CLASS, LOGGING_METHOD, LINE_NUMBER, SOURCE_FILE)
+    }
+
+    @CanIgnoreReturnValue
+    fun setLevel(level: Level): StubLogData {
+        this.level = level
+        return this
+    }
+
+    @CanIgnoreReturnValue
+    fun setLogSite(logSite: LogSite): StubLogData {
+        this.logSite = logSite
+        return this
+    }
+
+    @CanIgnoreReturnValue
+    fun setTimestampNanos(value: Long): StubLogData {
+        this.timestampNanos = value
+        return this
+    }
+
+    @CanIgnoreReturnValue
+    fun <T : Any> addMetadata(key: MetadataKey<T>, value: Any): StubLogData {
+        metadata.add(key, key.cast(value)!!)
+        return this
+    }
+
+    override val loggerName: String
+        get() = LOGGER_NAME
+
+    override fun wasForced(): Boolean =
+        metadata.findValue(LogContext.Key.WAS_FORCED) == true
+
+    override val literalArgument: Any?
+        get() = _literalArgument
+}
diff --git a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/StubLogSite.kt b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/StubLogSite.kt
new file mode 100644
index 00000000..48666b0d
--- /dev/null
+++ b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/StubLogSite.kt
@@ -0,0 +1,55 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package io.spine.logging.backend.otel.given
+
+import io.spine.logging.LogSite
+import java.util.Objects
+
+/**
+ * A simplified implementation of [LogSite] for testing.
+ */
+internal class StubLogSite(
+    override val className: String,
+    override val methodName: String,
+    override val lineNumber: Int,
+    private val sourcePath: String?
+) : LogSite() {
+
+    override val fileName: String? = sourcePath
+
+    override fun equals(other: Any?): Boolean {
+        if (other !is StubLogSite) {
+            return false
+        }
+        return className == other.className &&
+                methodName == other.methodName &&
+                lineNumber == other.lineNumber &&
+                sourcePath == other.sourcePath
+    }
+
+    override fun hashCode(): Int = Objects.hash(className, methodName, lineNumber, sourcePath)
+}
diff --git a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/StubMetadata.kt b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/StubMetadata.kt
new file mode 100644
index 00000000..f6f91f87
--- /dev/null
+++ b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/StubMetadata.kt
@@ -0,0 +1,62 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package io.spine.logging.backend.otel.given
+
+import com.google.errorprone.annotations.CanIgnoreReturnValue
+import io.spine.logging.MetadataKey
+import io.spine.logging.backend.Metadata
+
+/**
+ * A mutable [Metadata] implementation for testing logging backends.
+ */
+internal class StubMetadata : Metadata() {
+
+    private class KeyValuePair<T : Any>(val key: MetadataKey<T>, val value: T)
+
+    private val entries = mutableListOf<KeyValuePair<*>>()
+
+    /**
+     * Adds a key/value pair to this [Metadata].
+     */
+    @CanIgnoreReturnValue
+    fun <T : Any> add(key: MetadataKey<T>, value: T): StubMetadata {
+        entries.add(KeyValuePair(key, value))
+        return this
+    }
+
+    override fun size(): Int = entries.size
+
+    @Suppress("UNCHECKED_CAST")
+    override fun getKey(n: Int): MetadataKey<Any> = entries[n].key as MetadataKey<Any>
+
+    override fun getValue(n: Int): Any = entries[n].value
+
+    override fun <T : Any> findValue(key: MetadataKey<T>): T? {
+        val entry = entries.firstOrNull { it.key == key }
+        return key.cast(entry?.value)
+    }
+}
diff --git a/buildSrc/src/main/kotlin/io/spine/dependency/lib/OpenTelemetryKotlin.kt b/buildSrc/src/main/kotlin/io/spine/dependency/lib/OpenTelemetryKotlin.kt
new file mode 100644
index 00000000..ec709ea5
--- /dev/null
+++ b/buildSrc/src/main/kotlin/io/spine/dependency/lib/OpenTelemetryKotlin.kt
@@ -0,0 +1,92 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package io.spine.dependency.lib
+
+import io.spine.dependency.Dependency
+
+/**
+ * The Kotlin Multiplatform API and SDK for OpenTelemetry.
+ *
+ * The project is currently in the alpha stage, and its API is marked
+ * with `@io.opentelemetry.kotlin.ExperimentalApi`. Modules using these artifacts
+ * must opt in to that marker.
+ *
+ * The project does not publish a BOM, so the version is embedded in each
+ * artifact coordinate below.
+ *
+ * @see <a href="https://github.com/open-telemetry/opentelemetry-kotlin">opentelemetry-kotlin</a>
+ * @see <a href="https://opentelemetry.io/docs/languages/kotlin/">Kotlin docs</a>
+ */
+@Suppress("unused")
+object OpenTelemetryKotlin : Dependency() {
+
+    override val version = "0.4.0"
+    override val group = "io.opentelemetry.kotlin"
+
+    /**
+     * The Kotlin Multiplatform API surface (traces, metrics, logs).
+     *
+     * This is the only artifact required by production code that maps
+     * a domain onto OpenTelemetry log records or spans.
+     */
+    val api = "$group:api:$version"
+
+    /**
+     * A no-op implementation of the [api].
+     */
+    val noop = "$group:noop:$version"
+
+    /**
+     * The Kotlin SDK API: log-record and span processors, exporters, samplers,
+     * and the configuration DSL.
+     *
+     * This artifact exposes the SDK types on the compile classpath; the
+     * `createOpenTelemetry { }` entry point that instantiates them lives in
+     * [implementation]. Applications and tests configure an `OpenTelemetry`
+     * instance using these two artifacts; the production code needs only the [api].
+     */
+    val core = "$group:core:$version"
+
+    /**
+     * The Kotlin SDK implementation, including the `createOpenTelemetry { }`
+     * entry point. Use together with [core].
+     */
+    val implementation = "$group:implementation:$version"
+
+    /**
+     * The compatibility bridge to the OpenTelemetry Java SDK.
+     */
+    val compat = "$group:compat:$version"
+
+    override val modules: List<String> = listOf(
+        "$group:api",
+        "$group:noop",
+        "$group:core",
+        "$group:implementation",
+        "$group:compat",
+    )
+}
diff --git a/settings.gradle.kts b/settings.gradle.kts
index bba161bd..636898b7 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -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.
@@ -31,7 +31,7 @@ pluginManagement {
     }
 }
 
-rootProject.name = "spine-logging"
+rootProject.name = "logging"
 
 include(
     "logging",
@@ -42,6 +42,7 @@ includeBackend(
     "log4j2-backend",
     "jul-backend",
     "probe-backend",
+    "otel-backend",
 )
 
 includeContext(

From 9c7ce04920da91f432938ff69817a9875bc85aa9 Mon Sep 17 00:00:00 2001
From: Alexander Yevsyukov <alexander.yevsyukov@teamdev.com>
Date: Sat, 27 Jun 2026 23:17:50 +0100
Subject: [PATCH 03/20] Complete OpenTelemetry backend: events, bootstrap,
 correlation
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Build on the Phase 0/1 backend with the log-based events surface, an OTLP
bootstrap module, trace correlation, documentation, and review fixes.

- Events: the `EVENT_NAME` metadata key and `WithLogging.logEvent(...)`. The
  backend forwards the name via `Logger.emit(eventName = …)` and omits it from
  the `spine.*` attributes.
- `backends/otel-backend-bootstrap` (jvm-module): `OtelLogging.installOtlpHttp()`
  and `fromEnvironment()` build a native OTLP/HTTP SDK, install it through
  `OtelBackendSettings`, and return an `AutoCloseable` that uninstalls and shuts
  the SDK down. Adds the `exporters-core` and `exporters-otlp` coordinates.
- Add a trace-correlation test (the record carries the active span's ids) and the
  module `README.md` (usage, mapping, events, and the consumer-side domain-event
  recipe).
- Review fixes: restore the no-op holder after each test, safe-cast in `close()`,
  null-message guard in `handleError`, a widening KDoc note, README line length,
  and a resolved KDoc link.

Tests: otel-backend 13, bootstrap 2. detekt and Dokka clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .agents/tasks/otel-backend-implementation.md  |  64 ++++++---
 .../otel-backend-bootstrap/build.gradle.kts   |  48 +++++++
 .../backend/otel/bootstrap/OtelLogging.kt     |  94 +++++++++++++
 .../backend/otel/bootstrap/OtelLoggingSpec.kt |  55 ++++++++
 backends/otel-backend/README.md               | 129 ++++++++++++++++++
 .../logging/backend/otel/AttributeMapping.kt  |   7 +-
 .../backend/otel/OtelBackendSettings.kt       |   2 +-
 .../spine/logging/backend/otel/OtelEvents.kt  |  71 ++++++++++
 .../logging/backend/otel/OtelLoggerBackend.kt |   4 +-
 .../backend/otel/OtelLoggerBackendSpec.kt     |  51 +++++++
 .../backend/otel/given/NoOpSpanProcessor.kt   |  57 ++++++++
 .../dependency/lib/OpenTelemetryKotlin.kt     |  16 +++
 settings.gradle.kts                           |   1 +
 13 files changed, 580 insertions(+), 19 deletions(-)
 create mode 100644 backends/otel-backend-bootstrap/build.gradle.kts
 create mode 100644 backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt
 create mode 100644 backends/otel-backend-bootstrap/src/test/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLoggingSpec.kt
 create mode 100644 backends/otel-backend/README.md
 create mode 100644 backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelEvents.kt
 create mode 100644 backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/NoOpSpanProcessor.kt

diff --git a/.agents/tasks/otel-backend-implementation.md b/.agents/tasks/otel-backend-implementation.md
index 1d18eb02..5a34d4d0 100644
--- a/.agents/tasks/otel-backend-implementation.md
+++ b/.agents/tasks/otel-backend-implementation.md
@@ -2,7 +2,7 @@
 slug: otel-backend-implementation
 branch: otel
 owner: claude
-status: in-progress
+status: in-review
 started: 2026-06-27
 related-memories: []
 ---
@@ -160,23 +160,39 @@ backends/otel-backend-bootstrap/   ← OPTIONAL, Phase 2 (jvmMain SDK init, turn
       passthrough, and factory resolution via `OtelBackendSettings`.
 
 ### Phase 2 — bootstrap module + correlation hardening
-- [ ] `backends/otel-backend-bootstrap` (kmp-module, jvmMain SDK init): read config,
-      `createOpenTelemetry { loggerProvider { export { … } } }`, `OtelBackendSettings.use(...)`,
-      own shutdown.
-- [ ] Coroutine trace-correlation test: log inside a span-scoped coroutine; assert
-      trace/span ids land on the record; wire the OTel context element if they don't
-      survive dispatch (report §5.5 / §10.4); document the requirement.
+- [x] **Trace-correlation test** — [`OtelLoggerBackendSpec`](backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt)
+      `correlate the record with the active span`: a span is made current via
+      `otel.context.implicit().storeSpan(span).attach()`, then `log()` (with implicit
+      `context = null`) stamps the span's trace/span ids onto the record. **Passes** —
+      closes the report §5.5 / §10.4 correlation risk. (Coroutine-dispatch propagation
+      is a consumer concern; left for a consumer-side test.)
+- [x] [`backends/otel-backend-bootstrap`](backends/otel-backend-bootstrap) (`jvm-module`):
+      [`OtelLogging`](backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt)
+      `installOtlpHttp(endpoint)` / `fromEnvironment()` builds a native SDK via
+      `createOpenTelemetry { loggerProvider { export { batchLogRecordProcessor(otlpHttpLogRecordExporter(endpoint)) } } }`,
+      installs it through `OtelBackendSettings.use(...)`, and returns an `AutoCloseable`
+      that uninstalls + shuts the SDK down (`runBlocking { (otel as TelemetryCloseable).shutdown() }`).
+      Real 0.4.0 OTLP API confirmed from upstream source: `otlpHttpLogRecordExporter`
+      (`exporters-otlp`) + `batchLogRecordProcessor` (`exporters-core`), both extensions on
+      `LogExportConfigDsl` in `io.opentelemetry.kotlin.logging.export`. **Builds green;
+      smoke test passes.**
 - [ ] Optional early-record ring buffer in `OtelBackendSettings`, replayed on `use(...)`
-      (report §4) — only if bootstrap-order logs matter.
+      (report §4) — deferred; only if bootstrap-order logs prove to matter.
 
 ### Phase 3 — log-based events API + domain-event integration
-- [ ] Low-level: a `MetadataKey<String>` (`otel.event.name`) the backend pulls out and
-      passes as `emit(eventName = …)` (report §6.1).
-- [ ] Ergonomic `logEvent(name, severity, build)` guarded by `enabled(eventName = name)`
-      (report §6.2).
-- [ ] Domain-event → observability-event bridge: proto message type name → `event.name`
-      (low cardinality), selected fields + scope → attributes, active span → correlation;
-      document the domain-event-vs-observability-event boundary (report §6.3).
+- [x] Low-level: [`EVENT_NAME`](backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelEvents.kt)
+      `MetadataKey<String>` (label `otelEventName` — Spine labels disallow dots) the
+      backend pulls out and passes as `emit(eventName = …)`; ignored as an attribute.
+      Verified by `emit a named event when the event-name metadata is set`.
+- [x] Ergonomic [`WithLogging.logEvent(name, level, message)`](backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelEvents.kt) —
+      sugar over `at(level).with(EVENT_NAME, name).log { … }`. Verified end-to-end by
+      `emit a named event through the 'logEvent' API end-to-end`.
+- [x] Domain-event → observability-event bridge: **documented**, not coded — it needs Spine
+      proto/domain types from consumer repos (e.g. `core-jvm`, `io.spine:spine-server`), so it
+      belongs in the consumer, not this library. The recipe (proto type name → `event.name`,
+      selected fields + scope → attributes, active span → correlation) and the
+      domain-event-vs-observability-event boundary are in
+      [`README.md`](backends/otel-backend/README.md) (report §6.3).
 
 ### Phase 4 — non-JVM targets (deferred; separate initiative)
 - [ ] Only when Spine grows non-JVM backend registration (today only
@@ -228,4 +244,20 @@ backends/otel-backend-bootstrap/   ← OPTIONAL, Phase 2 (jvmMain SDK init, turn
   is green (compile + detekt + kover + license); `:otel-backend:jvmTest` runs **10/10
   passing** (had to JDK-17 the build and add `useJUnitPlatform()` to the kmp `jvmTest`).
   KSP emits the `@AutoService` service file naming `OtelBackendFactory`. Timestamp unit
-  and logs SDK DSL confirmed against upstream `v0.4.0`. Phases 2–3 remain.
+  and logs SDK DSL confirmed against upstream `v0.4.0`.
+- 2026-06-27 — **Phase 2 (correlation + bootstrap) and Phase 3 (events + docs) done.**
+  Added the correlation test, the `logEvent`/`EVENT_NAME` events surface, the README
+  (incl. the consumer-side domain-event recipe), and the `otel-backend-bootstrap` OTLP
+  module. otel-backend **13/13** tests; bootstrap **2/2**; both detekt-clean; Dokka clean.
+  The real 0.4.0 OTLP API (`otlpHttpLogRecordExporter` in `exporters-otlp`,
+  `batchLogRecordProcessor` in `exporters-core`) was confirmed from upstream source — the
+  getting-started docs' helpers postdate 0.4.0, so empirical compilation + upstream
+  reading were needed.
+- 2026-06-27 — **Reviewed.** `kotlin-engineer` → APPROVE (no MUST violations; `@Volatile`
+  holder, `runBlocking` in `close()`, numeric widening, severity thresholds, null-safety,
+  explicit-API all verified correct). `spine-code-review` → APPROVE WITH CHANGES (nits;
+  version gate satisfied at `2.0.0-SNAPSHOT.418`). Applied: endpoint constant in the smoke
+  test, a `fromEnvironment()` test, `@AfterEach` restoring the no-op holder, safe cast in
+  `close()`, null-message guard in `handleError`, a widening-KDoc note, and README
+  line-length/Dokka-link fixes. Status → `in-review`. **Not committed** — awaiting the
+  maintainer to review and open the PR.
diff --git a/backends/otel-backend-bootstrap/build.gradle.kts b/backends/otel-backend-bootstrap/build.gradle.kts
new file mode 100644
index 00000000..b4e1eef1
--- /dev/null
+++ b/backends/otel-backend-bootstrap/build.gradle.kts
@@ -0,0 +1,48 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+import io.spine.dependency.kotlinx.Coroutines
+import io.spine.dependency.lib.OpenTelemetryKotlin
+
+plugins {
+    `jvm-module`
+}
+
+dependencies {
+    // The backend whose `OpenTelemetry` instance this module installs.
+    implementation(project(":otel-backend"))
+
+    // The native Kotlin SDK entry point (`createOpenTelemetry { … }`), the export
+    // machinery (`batchLogRecordProcessor`), and the OTLP exporters. Only this
+    // bootstrap depends on them; the backend stays API-only.
+    implementation(OpenTelemetryKotlin.implementation)
+    implementation(OpenTelemetryKotlin.exportersCore)
+    implementation(OpenTelemetryKotlin.exportersOtlp)
+    implementation(OpenTelemetryKotlin.noop)
+
+    // `runBlocking`, to invoke the SDK's suspending `shutdown()` from `close()`.
+    implementation(Coroutines.core)
+}
diff --git a/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt b/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt
new file mode 100644
index 00000000..fa47d244
--- /dev/null
+++ b/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt
@@ -0,0 +1,94 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+@file:OptIn(ExperimentalApi::class)
+
+package io.spine.logging.backend.otel.bootstrap
+
+import io.opentelemetry.kotlin.ExperimentalApi
+import io.opentelemetry.kotlin.NoopOpenTelemetry
+import io.opentelemetry.kotlin.createOpenTelemetry
+import io.opentelemetry.kotlin.export.TelemetryCloseable
+import io.opentelemetry.kotlin.logging.export.batchLogRecordProcessor
+import io.opentelemetry.kotlin.logging.export.otlpHttpLogRecordExporter
+import io.spine.logging.backend.otel.OtelBackendSettings
+import kotlinx.coroutines.runBlocking
+
+/**
+ * Turnkey wiring of the OpenTelemetry logging backend.
+ *
+ * The core backend stays API-only and expects an `OpenTelemetry` instance to be
+ * injected via [OtelBackendSettings]. This optional module builds a real native
+ * Kotlin SDK with an OTLP/HTTP export pipeline and installs it.
+ *
+ * The returned [AutoCloseable] uninstalls the backend (restoring the no-op
+ * instance) and shuts down the SDK it created when closed.
+ */
+public object OtelLogging {
+
+    /**
+     * The default OTLP/HTTP endpoint of a local OpenTelemetry Collector.
+     */
+    public const val DEFAULT_OTLP_HTTP_ENDPOINT: String = "http://localhost:4318"
+
+    /**
+     * Builds a native Kotlin OpenTelemetry SDK that exports log records over
+     * OTLP/HTTP to [endpoint] and installs it into [OtelBackendSettings].
+     *
+     * @param endpoint The OTLP/HTTP endpoint. Defaults to [DEFAULT_OTLP_HTTP_ENDPOINT].
+     * @return a handle that uninstalls the backend when closed.
+     */
+    public fun installOtlpHttp(endpoint: String = DEFAULT_OTLP_HTTP_ENDPOINT): AutoCloseable {
+        val openTelemetry = createOpenTelemetry {
+            loggerProvider {
+                export {
+                    batchLogRecordProcessor(
+                        otlpHttpLogRecordExporter(endpoint)
+                    )
+                }
+            }
+        }
+        OtelBackendSettings.use(openTelemetry)
+        return AutoCloseable {
+            // Stop routing new records to this SDK, then flush and shut it down.
+            // The SDK instance created by `createOpenTelemetry` is a `TelemetryCloseable`;
+            // the safe cast future-proofs against the factory ever returning otherwise.
+            OtelBackendSettings.use(NoopOpenTelemetry)
+            runBlocking { (openTelemetry as? TelemetryCloseable)?.shutdown() }
+        }
+    }
+
+    /**
+     * Installs an OTLP/HTTP pipeline using the endpoint from the
+     * `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable, falling back to
+     * [DEFAULT_OTLP_HTTP_ENDPOINT] when it is not set.
+     */
+    public fun fromEnvironment(): AutoCloseable {
+        val endpoint = System.getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
+            ?: DEFAULT_OTLP_HTTP_ENDPOINT
+        return installOtlpHttp(endpoint)
+    }
+}
diff --git a/backends/otel-backend-bootstrap/src/test/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLoggingSpec.kt b/backends/otel-backend-bootstrap/src/test/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLoggingSpec.kt
new file mode 100644
index 00000000..87eb0e07
--- /dev/null
+++ b/backends/otel-backend-bootstrap/src/test/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLoggingSpec.kt
@@ -0,0 +1,55 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package io.spine.logging.backend.otel.bootstrap
+
+import io.kotest.assertions.throwables.shouldNotThrowAny
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+
+@DisplayName("`OtelLogging` should")
+internal class OtelLoggingSpec {
+
+    @Test
+    fun `build, install and shut down an OTLP HTTP pipeline`() {
+        shouldNotThrowAny {
+            // No collector is listening; the batch processor exports asynchronously,
+            // so construction, installation and shutdown must all succeed regardless.
+            val installed = OtelLogging.installOtlpHttp(OtelLogging.DEFAULT_OTLP_HTTP_ENDPOINT)
+            installed.close()
+        }
+    }
+
+    @Test
+    fun `install from the environment, falling back to the default endpoint`() {
+        shouldNotThrowAny {
+            // With `OTEL_EXPORTER_OTLP_ENDPOINT` unset, this exercises the fallback
+            // to the default endpoint.
+            val installed = OtelLogging.fromEnvironment()
+            installed.close()
+        }
+    }
+}
diff --git a/backends/otel-backend/README.md b/backends/otel-backend/README.md
new file mode 100644
index 00000000..47629b66
--- /dev/null
+++ b/backends/otel-backend/README.md
@@ -0,0 +1,129 @@
+## OpenTelemetry backend
+
+This module routes Spine Logging statements to [OpenTelemetry][otel] as OTLP-ready
+log records, using the Kotlin-multiplatform [`opentelemetry-kotlin`][otel-kotlin]
+API. It maps each Spine `LogData` onto a single `Logger.emit(...)` call and, on the
+same path, supports log-based **events**.
+
+The backend itself depends only on the OpenTelemetry **API** (`io.opentelemetry.kotlin:api`).
+The application — or a dedicated bootstrap — owns the SDK and decides where records go.
+
+> **Status:** experimental. `opentelemetry-kotlin` is pre-1.0 and its logs API is
+> annotated `@ExperimentalApi`; this backend pins one exact version and may need to
+> change with it.
+
+### Providing the `OpenTelemetry` instance
+
+The backend factory is constructed by the platform via `ServiceLoader`, so it cannot
+receive the `OpenTelemetry` instance through a constructor. Instead, the application
+installs it once, at startup, **before any logging happens**:
+
+```kotlin
+import io.opentelemetry.kotlin.createOpenTelemetry
+import io.spine.logging.backend.otel.OtelBackendSettings
+
+OtelBackendSettings.use(
+    createOpenTelemetry {
+        loggerProvider {
+            export { /* a LogRecordProcessor, e.g. a batch processor over an OTLP exporter */ }
+        }
+    }
+)
+```
+
+Until `use(...)` is called, records go to `NoopOpenTelemetry` and are dropped. The
+instance is owned by the caller, including its shutdown.
+
+This module exposes the factory as a Java service, so adding it to the runtime
+classpath makes `DefaultPlatform` pick it up automatically. Keep exactly **one**
+backend on the classpath; if several are present, select this one explicitly with
+`-Dspine.logging.backend_factory=io.spine.logging.backend.otel.OtelBackendFactory`.
+
+### What is mapped
+
+| Spine `LogData` | OpenTelemetry log record |
+|---|---|
+| rendered message (without the `[CONTEXT …]` suffix) | `body` |
+| `level` | `severityNumber` (numeric threshold) and `severityText` (the level name) |
+| `timestampNanos` | `timestamp` (epoch nanoseconds) |
+| `LogContext.Key.LOG_CAUSE` | `exception` (recorded as `exception.*` attributes) |
+| `logSite` | `code.namespace`, `code.function`, `code.filepath`, `code.lineno` |
+| scope + log-site metadata | attributes, namespaced `spine.<label>` (repeated → list) |
+| `Tags` from `ScopedLoggingContext` | `spine.tag.<name>` attributes |
+| the active span | trace/span ids (the record is emitted with the implicit context) |
+
+Metadata is emitted as **structured attributes**, not folded into the message text,
+so a downstream collector sees Spine's bounded-context, aggregate id, user, etc. as
+queryable fields.
+
+`CONFIG` has no exact OpenTelemetry counterpart and is mapped to `DEBUG4`.
+
+### Log-based events
+
+Because `eventName` is just a parameter on `emit`, an event is a log record with a
+name. Emit one with `logEvent`:
+
+```kotlin
+import io.spine.logging.backend.otel.logEvent
+
+class Checkout : WithLogging {
+    fun complete(orderId: String) {
+        logEvent("acme.orders.OrderCompleted")
+        // Attributes are added the usual way, via the fluent API and metadata keys:
+        // logger.atInfo().with(ORDER_ID, orderId).with(EVENT_NAME, name).log { … }
+    }
+}
+```
+
+Under the hood `logEvent` attaches the [`EVENT_NAME`][event-name] metadata key
+(Spine label `otelEventName`); the backend forwards it as `emit(eventName = …)` and
+does not duplicate it as an attribute. With a non-OpenTelemetry backend the key
+degrades to ordinary metadata.
+
+Event names must be **low-cardinality** (no ids or other dynamic values) per the
+OpenTelemetry [event semantic conventions][otel-events]; dynamic data goes into
+attributes.
+
+### Domain events vs. observability events
+
+In an event-sourced Spine application the word *event* is overloaded, and the two
+meanings must not be conflated:
+
+- A **Spine domain event** is persisted, replayable, and the source of truth.
+- An **OpenTelemetry event** is lossy telemetry.
+
+**Never use the OpenTelemetry pipeline as an event store.** The safe, high-value
+pattern is to emit an observability event *about* a domain event as it is handled —
+turning the existing domain-event flow into trace-correlated telemetry:
+
+- `event.name` ← the Protobuf message **type** name (e.g. `acme.orders.OrderPlaced`),
+  which is naturally low-cardinality;
+- attributes ← selected proto fields plus `ScopedLoggingContext` (aggregate id,
+  bounded context, user);
+- correlation ← the active span, automatically.
+
+This bridge belongs in the **consumer** application, not in this module: it needs the
+Spine domain/proto types, which live in the service's own code (and depends on
+`io.spine:spine-server`), not in the logging library. A sketch in a consumer:
+
+```kotlin
+// In a consumer service, when a domain event is handled/applied:
+fun onDomainEvent(event: EventMessage) {
+    logger.atInfo()
+        .with(EVENT_NAME, event.typeName())   // proto type name → event.name
+        .with(AGGREGATE_ID, /* … */)           // selected fields → attributes
+        .log { "Domain event handled." }
+}
+```
+
+### Aligned with OTEP 4430
+
+Events are emitted through the **Logs API** (`emit(eventName = …)`), never
+`Span.AddEvent` — the direction endorsed by [OTEP 4430][otep-4430] (Span Event API
+deprecation).
+
+[event-name]: src/commonMain/kotlin/io/spine/logging/backend/otel/OtelEvents.kt
+[otel]: https://opentelemetry.io/
+[otel-kotlin]: https://github.com/open-telemetry/opentelemetry-kotlin
+[otel-events]: https://opentelemetry.io/docs/specs/semconv/general/events/
+[otep-4430]: https://github.com/open-telemetry/opentelemetry-specification/blob/main/oteps/4430-span-event-api-deprecation-plan.md
diff --git a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/AttributeMapping.kt b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/AttributeMapping.kt
index 0e4b6bc8..d5255951 100644
--- a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/AttributeMapping.kt
+++ b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/AttributeMapping.kt
@@ -82,9 +82,14 @@ private val attributeHandler: MetadataHandler<AttributesMutator> =
         mutator.putTags(tags)
     }.ignoring(
         // The cause is emitted as the record's exception, not as an attribute.
-        LogContext.Key.LOG_CAUSE
+        LogContext.Key.LOG_CAUSE,
+        // The event name is emitted via `Logger.emit(eventName = …)`, not as an attribute.
+        EVENT_NAME
     ).build()
 
+// OpenTelemetry attributes have only `Long` and `Double` numeric types, so `Int`/`Short`/
+// `Byte` widen to `Long` and `Float` widens to `Double` — the original Kotlin type is not
+// preserved on the wire.
 private fun AttributesMutator.putValue(name: String, value: Any) {
     when (value) {
         is Boolean -> setBooleanAttribute(name, value)
diff --git a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelBackendSettings.kt b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelBackendSettings.kt
index ee7f5c78..c19b8913 100644
--- a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelBackendSettings.kt
+++ b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelBackendSettings.kt
@@ -35,7 +35,7 @@ import io.opentelemetry.kotlin.OpenTelemetry
 /**
  * Holds the [OpenTelemetry] instance the backend emits log records with.
  *
- * The Spine backend SPI constructs a [OtelBackendFactory] without arguments
+ * The Spine backend SPI constructs the `OtelBackendFactory` without arguments
  * (via `ServiceLoader` on the JVM), so the instance cannot be supplied through
  * the factory constructor. Instead, the application injects it here once, at
  * startup, before any logging happens:
diff --git a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelEvents.kt b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelEvents.kt
new file mode 100644
index 00000000..38732a8c
--- /dev/null
+++ b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelEvents.kt
@@ -0,0 +1,71 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package io.spine.logging.backend.otel
+
+import io.spine.logging.Level
+import io.spine.logging.MetadataKey
+import io.spine.logging.WithLogging
+
+/**
+ * The metadata key recognized by [OtelLoggerBackend] as the OpenTelemetry event name.
+ *
+ * When a log statement carries this key, the backend emits the record as a
+ * log-based *event* — `Logger.emit(eventName = …)` — rather than a plain log
+ * record, and the key itself is not duplicated as a `spine.*` attribute.
+ *
+ * This plays the role of the `otel.event.name` key recognized by the OpenTelemetry
+ * Logback and Log4j appenders. The Spine metadata label must be a plain identifier
+ * (letters, digits, underscore), so `otelEventName` is used; the value still becomes
+ * the OpenTelemetry event name. With non-OpenTelemetry backends the key is treated
+ * as ordinary metadata.
+ */
+public val EVENT_NAME: MetadataKey<String> = MetadataKey.single<String>("otelEventName")
+
+/**
+ * Emits a log-based OpenTelemetry event with the given [name].
+ *
+ * An event is an ordinary log statement that carries the [EVENT_NAME] metadata;
+ * the OpenTelemetry backend maps it to `Logger.emit(eventName = name)`. Guarded by
+ * the level, so a disabled event costs nothing.
+ *
+ * The [name] should be low-cardinality (for example, `acme.orders.OrderPlaced`),
+ * per the OpenTelemetry event semantic conventions — dynamic values belong in
+ * attributes added via [with][io.spine.logging.LoggingApi.with], not in the name.
+ *
+ * @param name The event name.
+ * @param level The severity of the event. Defaults to [Level.INFO].
+ * @param message The record body. Defaults to [name].
+ */
+public fun WithLogging.logEvent(
+    name: String,
+    level: Level = Level.INFO,
+    message: String = name,
+) {
+    logger.at(level)
+        .with(EVENT_NAME, name)
+        .log { message }
+}
diff --git a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelLoggerBackend.kt b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelLoggerBackend.kt
index 0cad618c..a50ac6d7 100644
--- a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelLoggerBackend.kt
+++ b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelLoggerBackend.kt
@@ -73,8 +73,10 @@ internal class OtelLoggerBackend(
             data.metadata
         )
         val cause = metadata.getSingleValue(LogContext.Key.LOG_CAUSE)
+        val eventName = metadata.getSingleValue(EVENT_NAME)
         logger.emit(
             body = SimpleMessageFormatter.getLiteralLogMessage(data),
+            eventName = eventName,
             timestamp = data.timestampNanos,
             severityNumber = data.level.toSeverityNumber(),
             severityText = data.level.name,
@@ -88,7 +90,7 @@ internal class OtelLoggerBackend(
 
     override fun handleError(error: RuntimeException, badData: LogData) {
         logger.emit(
-            body = "Spine logging backend error: ${error.message}",
+            body = "Spine logging backend error: ${error.message ?: error}",
             severityNumber = SeverityNumber.ERROR,
             severityText = SeverityNumber.ERROR.name,
             exception = error,
diff --git a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
index d9f42a89..dd39646c 100644
--- a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
+++ b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
@@ -34,14 +34,18 @@ import io.kotest.matchers.maps.shouldNotContainKey
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.string.shouldNotContain
 import io.opentelemetry.kotlin.ExperimentalApi
+import io.opentelemetry.kotlin.NoopOpenTelemetry
 import io.opentelemetry.kotlin.createOpenTelemetry
 import io.opentelemetry.kotlin.logging.SeverityNumber
 import io.spine.logging.Level
 import io.spine.logging.LogContext
 import io.spine.logging.MetadataKey
+import io.spine.logging.WithLogging
+import io.spine.logging.backend.otel.given.NoOpSpanProcessor
 import io.spine.logging.backend.otel.given.RecordingLogRecordProcessor
 import io.spine.logging.backend.otel.given.StubLogData
 import io.spine.logging.backend.otel.given.StubLogSite
+import org.junit.jupiter.api.AfterEach
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Test
@@ -65,6 +69,13 @@ internal class OtelLoggerBackendSpec {
         backend = OtelLoggerBackend(logger, LOGGER_NAME)
     }
 
+    @AfterEach
+    fun tearDown() {
+        // The settings holder is a global singleton; restore the default so a test
+        // that injects an instance does not leak it into later tests.
+        OtelBackendSettings.use(NoopOpenTelemetry)
+    }
+
     @Test
     fun `emit a literal message as the record body`() {
         backend.log(StubLogData(LITERAL))
@@ -148,6 +159,44 @@ internal class OtelLoggerBackendSpec {
         lastRecord.timestamp shouldBe TIMESTAMP_NANOS
     }
 
+    @Test
+    fun `correlate the record with the active span`() {
+        val otel = createOpenTelemetry {
+            tracerProvider { export { NoOpSpanProcessor() } }
+            loggerProvider { export { processor } }
+        }
+        val correlated = OtelLoggerBackend(otel.loggerProvider.getLogger(LOGGER_NAME), LOGGER_NAME)
+        val span = otel.tracerProvider.getTracer(LOGGER_NAME).startSpan("unit")
+        val scope = otel.context.implicit().storeSpan(span).attach()
+        try {
+            correlated.log(StubLogData(LITERAL))
+        } finally {
+            scope.detach()
+            span.end()
+        }
+        with(processor.records.last().spanContext) {
+            isValid shouldBe true
+            traceId shouldBe span.spanContext.traceId
+            spanId shouldBe span.spanContext.spanId
+        }
+    }
+
+    @Test
+    fun `emit a named event when the event-name metadata is set`() {
+        backend.log(StubLogData(LITERAL).addMetadata(EVENT_NAME, "checkout.completed"))
+        lastRecord.eventName shouldBe "checkout.completed"
+        lastRecord.attributes shouldNotContainKey "spine.otelEventName"
+    }
+
+    @Test
+    fun `emit a named event through the 'logEvent' API end-to-end`() {
+        OtelBackendSettings.use(
+            createOpenTelemetry { loggerProvider { export { processor } } }
+        )
+        EventSource().logEvent("checkout.completed")
+        processor.records.last().eventName shouldBe "checkout.completed"
+    }
+
     @Test
     fun `resolve the injected OpenTelemetry instance via the factory`() {
         OtelBackendSettings.use(
@@ -159,6 +208,8 @@ internal class OtelLoggerBackendSpec {
         processor.records shouldHaveSize 1
     }
 
+    private class EventSource : WithLogging
+
     companion object {
         private const val LOGGER_NAME = "io.spine.LoggerName"
         private const val LITERAL = "Hello world"
diff --git a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/NoOpSpanProcessor.kt b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/NoOpSpanProcessor.kt
new file mode 100644
index 00000000..c84739c3
--- /dev/null
+++ b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/NoOpSpanProcessor.kt
@@ -0,0 +1,57 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+@file:OptIn(ExperimentalApi::class)
+
+package io.spine.logging.backend.otel.given
+
+import io.opentelemetry.kotlin.ExperimentalApi
+import io.opentelemetry.kotlin.context.Context
+import io.opentelemetry.kotlin.export.OperationResultCode
+import io.opentelemetry.kotlin.tracing.export.SpanProcessor
+import io.opentelemetry.kotlin.tracing.model.ReadWriteSpan
+import io.opentelemetry.kotlin.tracing.model.ReadableSpan
+
+/**
+ * A [SpanProcessor] that does nothing, used only to obtain a real SDK tracer
+ * (which assigns valid span contexts) in trace-correlation tests.
+ */
+internal class NoOpSpanProcessor : SpanProcessor {
+
+    override fun onStart(span: ReadWriteSpan, parentContext: Context): Unit = Unit
+
+    override fun onEnding(span: ReadWriteSpan): Unit = Unit
+
+    override fun onEnd(span: ReadableSpan): Unit = Unit
+
+    override fun isStartRequired(): Boolean = false
+
+    override fun isEndRequired(): Boolean = false
+
+    override suspend fun forceFlush(): OperationResultCode = OperationResultCode.Success
+
+    override suspend fun shutdown(): OperationResultCode = OperationResultCode.Success
+}
diff --git a/buildSrc/src/main/kotlin/io/spine/dependency/lib/OpenTelemetryKotlin.kt b/buildSrc/src/main/kotlin/io/spine/dependency/lib/OpenTelemetryKotlin.kt
index ec709ea5..60440765 100644
--- a/buildSrc/src/main/kotlin/io/spine/dependency/lib/OpenTelemetryKotlin.kt
+++ b/buildSrc/src/main/kotlin/io/spine/dependency/lib/OpenTelemetryKotlin.kt
@@ -82,11 +82,27 @@ object OpenTelemetryKotlin : Dependency() {
      */
     val compat = "$group:compat:$version"
 
+    /**
+     * Core export machinery: the `batchLogRecordProcessor` / `simpleLogRecordProcessor`
+     * DSL builders that wrap a `LogRecordExporter` into a `LogRecordProcessor`.
+     */
+    val exportersCore = "$group:exporters-core:$version"
+
+    /**
+     * OTLP exporters (HTTP, via Ktor), including the OTLP log-record exporter.
+     *
+     * Used only by a bootstrap that wires a real export pipeline; the backend
+     * itself needs only the [api].
+     */
+    val exportersOtlp = "$group:exporters-otlp:$version"
+
     override val modules: List<String> = listOf(
         "$group:api",
         "$group:noop",
         "$group:core",
         "$group:implementation",
         "$group:compat",
+        "$group:exporters-core",
+        "$group:exporters-otlp",
     )
 }
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 636898b7..3edcaa82 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -43,6 +43,7 @@ includeBackend(
     "jul-backend",
     "probe-backend",
     "otel-backend",
+    "otel-backend-bootstrap",
 )
 
 includeContext(

From 2b5386eae5d1c01414e390856bf2322fb0c3846f Mon Sep 17 00:00:00 2001
From: Alexander Yevsyukov <alexander.yevsyukov@teamdev.com>
Date: Sat, 27 Jun 2026 23:32:06 +0100
Subject: [PATCH 04/20] Apply pre-PR review fixes

Address findings from spine-code-review, kotlin-engineer, dependency-audit, and
review-docs:

- Revert an unintended `rootProject.name` rename (`logging` -> `spine-logging`)
  that a formatter slipped into the Phase 0 commit.
- Add tests for `handleError`, `Tags` expansion (label-only / single / list), and
  boolean and double attribute values (otel-backend now has 16 tests).
- `OpenTelemetryKotlin`: add the project URL comment.
- Use `requireNotNull` instead of `!!` in the `StubLogData` test fixture.
- README: fix an example comment; capitalize a `@return` description.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../backend/otel/bootstrap/OtelLogging.kt     |  2 +-
 backends/otel-backend/README.md               |  4 +-
 .../backend/otel/OtelLoggerBackendSpec.kt     | 44 +++++++++++++++++++
 .../logging/backend/otel/given/StubLogData.kt |  2 +-
 .../dependency/lib/OpenTelemetryKotlin.kt     |  1 +
 docs/dependencies/pom.xml                     | 42 +++++++++++++++++-
 settings.gradle.kts                           |  2 +-
 7 files changed, 91 insertions(+), 6 deletions(-)

diff --git a/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt b/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt
index fa47d244..aaac8d9e 100644
--- a/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt
+++ b/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt
@@ -59,7 +59,7 @@ public object OtelLogging {
      * OTLP/HTTP to [endpoint] and installs it into [OtelBackendSettings].
      *
      * @param endpoint The OTLP/HTTP endpoint. Defaults to [DEFAULT_OTLP_HTTP_ENDPOINT].
-     * @return a handle that uninstalls the backend when closed.
+     * @return A handle that uninstalls the backend when closed.
      */
     public fun installOtlpHttp(endpoint: String = DEFAULT_OTLP_HTTP_ENDPOINT): AutoCloseable {
         val openTelemetry = createOpenTelemetry {
diff --git a/backends/otel-backend/README.md b/backends/otel-backend/README.md
index 47629b66..a3813c6b 100644
--- a/backends/otel-backend/README.md
+++ b/backends/otel-backend/README.md
@@ -69,8 +69,8 @@ import io.spine.logging.backend.otel.logEvent
 class Checkout : WithLogging {
     fun complete(orderId: String) {
         logEvent("acme.orders.OrderCompleted")
-        // Attributes are added the usual way, via the fluent API and metadata keys:
-        // logger.atInfo().with(ORDER_ID, orderId).with(EVENT_NAME, name).log { … }
+        // Attributes are added via the fluent API and metadata keys:
+        // logger.atInfo().with(ORDER_ID, orderId).log { … }
     }
 }
 ```
diff --git a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
index dd39646c..0d411805 100644
--- a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
+++ b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
@@ -28,6 +28,7 @@
 
 package io.spine.logging.backend.otel
 
+import io.kotest.matchers.collections.shouldContainExactlyInAnyOrder
 import io.kotest.matchers.collections.shouldHaveSize
 import io.kotest.matchers.maps.shouldContainKey
 import io.kotest.matchers.maps.shouldNotContainKey
@@ -40,6 +41,7 @@ import io.opentelemetry.kotlin.logging.SeverityNumber
 import io.spine.logging.Level
 import io.spine.logging.LogContext
 import io.spine.logging.MetadataKey
+import io.spine.logging.context.Tags
 import io.spine.logging.WithLogging
 import io.spine.logging.backend.otel.given.NoOpSpanProcessor
 import io.spine.logging.backend.otel.given.RecordingLogRecordProcessor
@@ -159,6 +161,46 @@ internal class OtelLoggerBackendSpec {
         lastRecord.timestamp shouldBe TIMESTAMP_NANOS
     }
 
+    @Test
+    fun `map boolean and double attribute values`() {
+        backend.log(
+            StubLogData(LITERAL)
+                .addMetadata(BOOL_KEY, true)
+                .addMetadata(DOUBLE_KEY, 1.5)
+        )
+        with(lastRecord.attributes) {
+            this["spine.enabled"] shouldBe true
+            this["spine.ratio"] shouldBe 1.5
+        }
+    }
+
+    @Test
+    fun `expand tags into namespaced attributes`() {
+        val tags = Tags.builder()
+            .addTag("flag")             // Label-only → recorded as presence.
+            .addTag("user", "alice")    // Single value.
+            .addTag("ids", "a")         // Multiple values → list.
+            .addTag("ids", "b")
+            .build()
+        backend.log(StubLogData(LITERAL).addMetadata(LogContext.Key.TAGS, tags))
+        with(lastRecord.attributes) {
+            this["spine.tag.flag"] shouldBe true
+            this["spine.tag.user"] shouldBe "alice"
+            (this["spine.tag.ids"] as List<*>) shouldContainExactlyInAnyOrder listOf("a", "b")
+        }
+    }
+
+    @Test
+    fun `record a backend error via handleError`() {
+        backend.handleError(RuntimeException("boom"), StubLogData(LITERAL))
+        with(lastRecord) {
+            severityNumber shouldBe SeverityNumber.ERROR
+            severityText shouldBe SeverityNumber.ERROR.name
+            attributes shouldContainKey "spine.logging.bad_data"
+            attributes["exception.message"] shouldBe "boom"
+        }
+    }
+
     @Test
     fun `correlate the record with the active span`() {
         val otel = createOpenTelemetry {
@@ -216,5 +258,7 @@ internal class OtelLoggerBackendSpec {
         private const val TIMESTAMP_NANOS = 1_234_567_890L
         private val STR_KEY = MetadataKey.single<String>("str")
         private val INT_KEY = MetadataKey.repeated<Int>("int")
+        private val BOOL_KEY = MetadataKey.single<Boolean>("enabled")
+        private val DOUBLE_KEY = MetadataKey.single<Double>("ratio")
     }
 }
diff --git a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/StubLogData.kt b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/StubLogData.kt
index 8344964f..0be602b5 100644
--- a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/StubLogData.kt
+++ b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/given/StubLogData.kt
@@ -74,7 +74,7 @@ internal class StubLogData(literalArgument: Any?) : LogData {
 
     @CanIgnoreReturnValue
     fun <T : Any> addMetadata(key: MetadataKey<T>, value: Any): StubLogData {
-        metadata.add(key, key.cast(value)!!)
+        metadata.add(key, requireNotNull(key.cast(value)) { "Value is not of the key's type." })
         return this
     }
 
diff --git a/buildSrc/src/main/kotlin/io/spine/dependency/lib/OpenTelemetryKotlin.kt b/buildSrc/src/main/kotlin/io/spine/dependency/lib/OpenTelemetryKotlin.kt
index 60440765..982b0dac 100644
--- a/buildSrc/src/main/kotlin/io/spine/dependency/lib/OpenTelemetryKotlin.kt
+++ b/buildSrc/src/main/kotlin/io/spine/dependency/lib/OpenTelemetryKotlin.kt
@@ -41,6 +41,7 @@ import io.spine.dependency.Dependency
  * @see <a href="https://github.com/open-telemetry/opentelemetry-kotlin">opentelemetry-kotlin</a>
  * @see <a href="https://opentelemetry.io/docs/languages/kotlin/">Kotlin docs</a>
  */
+// https://github.com/open-telemetry/opentelemetry-kotlin
 @Suppress("unused")
 object OpenTelemetryKotlin : Dependency() {
 
diff --git a/docs/dependencies/pom.xml b/docs/dependencies/pom.xml
index d7013121..abf0e941 100644
--- a/docs/dependencies/pom.xml
+++ b/docs/dependencies/pom.xml
@@ -9,7 +9,7 @@ all modules and does not describe the project structure per-subproject.
  
  -->
 <groupId>io.spine</groupId>
-<artifactId>spine-logging</artifactId>
+<artifactId>logging</artifactId>
 <version>2.0.0-SNAPSHOT.418</version>
 
 <inceptionYear>2015</inceptionYear>
@@ -76,6 +76,30 @@ all modules and does not describe the project structure per-subproject.
     <version>6.1.11</version>
     <scope>compile</scope>
   </dependency>
+  <dependency>
+    <groupId>io.opentelemetry.kotlin</groupId>
+    <artifactId>exporters-core</artifactId>
+    <version>0.4.0</version>
+    <scope>compile</scope>
+  </dependency>
+  <dependency>
+    <groupId>io.opentelemetry.kotlin</groupId>
+    <artifactId>exporters-otlp</artifactId>
+    <version>0.4.0</version>
+    <scope>compile</scope>
+  </dependency>
+  <dependency>
+    <groupId>io.opentelemetry.kotlin</groupId>
+    <artifactId>implementation</artifactId>
+    <version>0.4.0</version>
+    <scope>compile</scope>
+  </dependency>
+  <dependency>
+    <groupId>io.opentelemetry.kotlin</groupId>
+    <artifactId>noop</artifactId>
+    <version>0.4.0</version>
+    <scope>compile</scope>
+  </dependency>
   <dependency>
     <groupId>io.spine</groupId>
     <artifactId>spine-annotations</artifactId>
@@ -112,6 +136,12 @@ all modules and does not describe the project structure per-subproject.
     <version>1.10.2</version>
     <scope>compile</scope>
   </dependency>
+  <dependency>
+    <groupId>org.jetbrains.kotlinx</groupId>
+    <artifactId>kotlinx-coroutines-core</artifactId>
+    <version>1.10.2</version>
+    <scope>compile</scope>
+  </dependency>
   <dependency>
     <groupId>org.jspecify</groupId>
     <artifactId>jspecify</artifactId>
@@ -230,6 +260,16 @@ all modules and does not describe the project structure per-subproject.
     <artifactId>kotest-runner-junit5-jvm</artifactId>
     <version>6.1.11</version>
   </dependency>
+  <dependency>
+    <groupId>io.opentelemetry.kotlin</groupId>
+    <artifactId>api</artifactId>
+    <version>0.4.0</version>
+  </dependency>
+  <dependency>
+    <groupId>io.opentelemetry.kotlin</groupId>
+    <artifactId>core</artifactId>
+    <version>0.4.0</version>
+  </dependency>
   <dependency>
     <groupId>io.spine.tools</groupId>
     <artifactId>spine-dokka-extensions</artifactId>
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 3edcaa82..c5c74689 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -31,7 +31,7 @@ pluginManagement {
     }
 }
 
-rootProject.name = "logging"
+rootProject.name = "spine-logging"
 
 include(
     "logging",

From ea132ee08feca7927fc21f52a77ff1f1e0bdd06a Mon Sep 17 00:00:00 2001
From: Alexander Yevsyukov <alexander.yevsyukov@teamdev.com>
Date: Sat, 27 Jun 2026 23:47:14 +0100
Subject: [PATCH 05/20] uUpdate docs

---
 README.md                       |  12 ++-
 backends/otel-backend/README.md | 127 +++----------------------
 docs/otel-backend.md            | 159 ++++++++++++++++++++++++++++++++
 3 files changed, 180 insertions(+), 118 deletions(-)
 create mode 100644 docs/otel-backend.md

diff --git a/README.md b/README.md
index 6bd73538..a8927c10 100644
--- a/README.md
+++ b/README.md
@@ -16,10 +16,12 @@ and the introduction of fluent logging API in [SLF4J v2.0.0][fluent-slf4j].
 
 ## Current status: Experimental
 
-Please note that this library is still in the experimental phase of development,
-and hence, its API may undergo significant changes. As such, we advise using
-this library cautiously in your projects until it has reached a stable
-release stage.
+This library is actively used across the SpineEventEngine family of projects, and its
+JVM API is expected to be stable enough for use in JVM-based projects.
+
+The status remains **Experimental** because we are evolving the library toward Kotlin
+Multiplatform (KMP). That work may introduce API changes, so until it settles we advise
+JVM users to pin a specific version and review the release notes before upgrading.
 
 ## Simple example
 
@@ -94,6 +96,8 @@ The following backends are available:
 
 * `io.spine:spine-logging-jul-backend` – the default JUL-based backend.
 * `io.spine:spine-logging-log4j2-backend` – Log4j2 backend.
+* `io.spine:spine-logging-otel-backend` – OpenTelemetry backend.
+  See [the OpenTelemetry backend guide](docs/otel-backend.md).
 
 The default backend is supplied along the logging library itself. To use it,
 one just needs to not supply any other backend. Then JUL backend will be
diff --git a/backends/otel-backend/README.md b/backends/otel-backend/README.md
index a3813c6b..061c1f58 100644
--- a/backends/otel-backend/README.md
+++ b/backends/otel-backend/README.md
@@ -1,129 +1,28 @@
 ## OpenTelemetry backend
 
-This module routes Spine Logging statements to [OpenTelemetry][otel] as OTLP-ready
-log records, using the Kotlin-multiplatform [`opentelemetry-kotlin`][otel-kotlin]
-API. It maps each Spine `LogData` onto a single `Logger.emit(...)` call and, on the
-same path, supports log-based **events**.
-
-The backend itself depends only on the OpenTelemetry **API** (`io.opentelemetry.kotlin:api`).
-The application — or a dedicated bootstrap — owns the SDK and decides where records go.
+Routes Spine Logging statements to [OpenTelemetry][otel] as OTLP-ready log records,
+using the Kotlin-multiplatform [`opentelemetry-kotlin`][otel-kotlin] API. Each Spine
+`LogData` becomes a single `Logger.emit(...)` call, and named log statements become
+log-based **events**. The backend depends only on the OpenTelemetry **API**; the
+application (or the optional `otel-backend-bootstrap` module) owns the SDK.
 
 > **Status:** experimental. `opentelemetry-kotlin` is pre-1.0 and its logs API is
-> annotated `@ExperimentalApi`; this backend pins one exact version and may need to
-> change with it.
-
-### Providing the `OpenTelemetry` instance
-
-The backend factory is constructed by the platform via `ServiceLoader`, so it cannot
-receive the `OpenTelemetry` instance through a constructor. Instead, the application
-installs it once, at startup, **before any logging happens**:
-
-```kotlin
-import io.opentelemetry.kotlin.createOpenTelemetry
-import io.spine.logging.backend.otel.OtelBackendSettings
-
-OtelBackendSettings.use(
-    createOpenTelemetry {
-        loggerProvider {
-            export { /* a LogRecordProcessor, e.g. a batch processor over an OTLP exporter */ }
-        }
-    }
-)
-```
-
-Until `use(...)` is called, records go to `NoopOpenTelemetry` and are dropped. The
-instance is owned by the caller, including its shutdown.
-
-This module exposes the factory as a Java service, so adding it to the runtime
-classpath makes `DefaultPlatform` pick it up automatically. Keep exactly **one**
-backend on the classpath; if several are present, select this one explicitly with
-`-Dspine.logging.backend_factory=io.spine.logging.backend.otel.OtelBackendFactory`.
-
-### What is mapped
-
-| Spine `LogData` | OpenTelemetry log record |
-|---|---|
-| rendered message (without the `[CONTEXT …]` suffix) | `body` |
-| `level` | `severityNumber` (numeric threshold) and `severityText` (the level name) |
-| `timestampNanos` | `timestamp` (epoch nanoseconds) |
-| `LogContext.Key.LOG_CAUSE` | `exception` (recorded as `exception.*` attributes) |
-| `logSite` | `code.namespace`, `code.function`, `code.filepath`, `code.lineno` |
-| scope + log-site metadata | attributes, namespaced `spine.<label>` (repeated → list) |
-| `Tags` from `ScopedLoggingContext` | `spine.tag.<name>` attributes |
-| the active span | trace/span ids (the record is emitted with the implicit context) |
-
-Metadata is emitted as **structured attributes**, not folded into the message text,
-so a downstream collector sees Spine's bounded-context, aggregate id, user, etc. as
-queryable fields.
+> annotated `@ExperimentalApi`; this backend pins one exact version and may change with it.
 
-`CONFIG` has no exact OpenTelemetry counterpart and is mapped to `DEBUG4`.
-
-### Log-based events
-
-Because `eventName` is just a parameter on `emit`, an event is a log record with a
-name. Emit one with `logEvent`:
+Add the backend to the runtime classpath and inject an `OpenTelemetry` instance once,
+at startup, before any logging happens:
 
 ```kotlin
-import io.spine.logging.backend.otel.logEvent
-
-class Checkout : WithLogging {
-    fun complete(orderId: String) {
-        logEvent("acme.orders.OrderCompleted")
-        // Attributes are added via the fluent API and metadata keys:
-        // logger.atInfo().with(ORDER_ID, orderId).log { … }
-    }
-}
+runtimeOnly("io.spine:spine-logging-otel-backend:$version")
 ```
 
-Under the hood `logEvent` attaches the [`EVENT_NAME`][event-name] metadata key
-(Spine label `otelEventName`); the backend forwards it as `emit(eventName = …)` and
-does not duplicate it as an attribute. With a non-OpenTelemetry backend the key
-degrades to ordinary metadata.
-
-Event names must be **low-cardinality** (no ids or other dynamic values) per the
-OpenTelemetry [event semantic conventions][otel-events]; dynamic data goes into
-attributes.
-
-### Domain events vs. observability events
-
-In an event-sourced Spine application the word *event* is overloaded, and the two
-meanings must not be conflated:
-
-- A **Spine domain event** is persisted, replayable, and the source of truth.
-- An **OpenTelemetry event** is lossy telemetry.
-
-**Never use the OpenTelemetry pipeline as an event store.** The safe, high-value
-pattern is to emit an observability event *about* a domain event as it is handled —
-turning the existing domain-event flow into trace-correlated telemetry:
-
-- `event.name` ← the Protobuf message **type** name (e.g. `acme.orders.OrderPlaced`),
-  which is naturally low-cardinality;
-- attributes ← selected proto fields plus `ScopedLoggingContext` (aggregate id,
-  bounded context, user);
-- correlation ← the active span, automatically.
-
-This bridge belongs in the **consumer** application, not in this module: it needs the
-Spine domain/proto types, which live in the service's own code (and depends on
-`io.spine:spine-server`), not in the logging library. A sketch in a consumer:
-
 ```kotlin
-// In a consumer service, when a domain event is handled/applied:
-fun onDomainEvent(event: EventMessage) {
-    logger.atInfo()
-        .with(EVENT_NAME, event.typeName())   // proto type name → event.name
-        .with(AGGREGATE_ID, /* … */)           // selected fields → attributes
-        .log { "Domain event handled." }
-}
+OtelBackendSettings.use(openTelemetry)
 ```
 
-### Aligned with OTEP 4430
-
-Events are emitted through the **Logs API** (`emit(eventName = …)`), never
-`Span.AddEvent` — the direction endorsed by [OTEP 4430][otep-4430] (Span Event API
-deprecation).
+See the **[OpenTelemetry logging backend guide](../../docs/otel-backend.md)** for SDK
+setup (including turnkey OTLP wiring), the `LogData`-to-record mapping, log-based events,
+and the domain-event recipe.
 
-[event-name]: src/commonMain/kotlin/io/spine/logging/backend/otel/OtelEvents.kt
 [otel]: https://opentelemetry.io/
 [otel-kotlin]: https://github.com/open-telemetry/opentelemetry-kotlin
-[otel-events]: https://opentelemetry.io/docs/specs/semconv/general/events/
-[otep-4430]: https://github.com/open-telemetry/opentelemetry-specification/blob/main/oteps/4430-span-event-api-deprecation-plan.md
diff --git a/docs/otel-backend.md b/docs/otel-backend.md
new file mode 100644
index 00000000..b3847c6f
--- /dev/null
+++ b/docs/otel-backend.md
@@ -0,0 +1,159 @@
+# OpenTelemetry logging backend
+
+The `otel-backend` module routes Spine Logging statements to [OpenTelemetry][otel] as
+OTLP-ready log records, using the Kotlin-multiplatform [`opentelemetry-kotlin`][otel-kotlin]
+API. Each Spine `LogData` becomes a single `Logger.emit(...)` call and, on the same path,
+named log statements become log-based **events**.
+
+The backend depends only on the OpenTelemetry **API** (`io.opentelemetry.kotlin:api`). The
+application — or the optional `otel-backend-bootstrap` module — owns the SDK and decides
+where records go.
+
+> **Status:** experimental. `opentelemetry-kotlin` is pre-1.0 and its logs API is annotated
+> `@ExperimentalApi`; this backend pins one exact version and may need to change with it.
+
+## Setup
+
+Add the backend to the runtime classpath:
+
+```kotlin
+dependencies {
+    implementation("io.spine:spine-logging:$version")
+    runtimeOnly("io.spine:spine-logging-otel-backend:$version")
+}
+```
+
+Keep exactly **one** backend on the classpath. If several are present, select this one
+explicitly with the `spine.logging.backend_factory` system property:
+
+```
+-Dspine.logging.backend_factory=io.spine.logging.backend.otel.OtelBackendFactory
+```
+
+## Providing the `OpenTelemetry` instance
+
+The backend factory is constructed by the platform via `ServiceLoader`, so it cannot
+receive the `OpenTelemetry` instance through a constructor. Instead, the application
+installs it once, at startup, **before any logging happens**:
+
+```kotlin
+import io.opentelemetry.kotlin.createOpenTelemetry
+import io.spine.logging.backend.otel.OtelBackendSettings
+
+OtelBackendSettings.use(
+    createOpenTelemetry {
+        loggerProvider {
+            export { /* a LogRecordProcessor, e.g. a batch processor over an OTLP exporter */ }
+        }
+    }
+)
+```
+
+Until `use(...)` is called, records go to `NoopOpenTelemetry` and are dropped. The
+instance is owned by the caller, including its shutdown.
+
+### Turnkey OTLP wiring
+
+The optional `otel-backend-bootstrap` module builds and installs a native OTLP/HTTP SDK
+for you, returning a handle that uninstalls the backend and shuts the SDK down when closed:
+
+```kotlin
+import io.spine.logging.backend.otel.bootstrap.OtelLogging
+
+// Reads `OTEL_EXPORTER_OTLP_ENDPOINT`, falling back to `http://localhost:4318`.
+val installed = OtelLogging.fromEnvironment()
+
+// Or with an explicit endpoint:
+val installed = OtelLogging.installOtlpHttp("http://collector:4318")
+
+// On application shutdown:
+installed.close()
+```
+
+## What is mapped
+
+| Spine `LogData` | OpenTelemetry log record |
+|---|---|
+| rendered message (without the `[CONTEXT …]` suffix) | `body` |
+| `level` | `severityNumber` (numeric threshold) and `severityText` (the level name) |
+| `timestampNanos` | `timestamp` (epoch nanoseconds) |
+| `LogContext.Key.LOG_CAUSE` | `exception` (recorded as `exception.*` attributes) |
+| `logSite` | `code.namespace`, `code.function`, `code.filepath`, `code.lineno` |
+| scope + log-site metadata | attributes, namespaced `spine.<label>` (repeated → list) |
+| `Tags` from `ScopedLoggingContext` | `spine.tag.<name>` attributes |
+| the active span | trace/span ids (the record is emitted with the implicit context) |
+
+Metadata is emitted as **structured attributes**, not folded into the message text, so a
+downstream collector sees Spine's bounded-context, aggregate id, user, etc. as queryable
+fields.
+
+`CONFIG` has no exact OpenTelemetry counterpart and is mapped to `DEBUG4`.
+
+## Log-based events
+
+Because `eventName` is just a parameter on `emit`, an event is a log record with a name.
+Emit one with `logEvent`:
+
+```kotlin
+import io.spine.logging.backend.otel.logEvent
+
+class Checkout : WithLogging {
+    fun complete(orderId: String) {
+        logEvent("acme.orders.OrderCompleted")
+        // Attributes are added via the fluent API and metadata keys:
+        // logger.atInfo().with(ORDER_ID, orderId).log { … }
+    }
+}
+```
+
+Under the hood `logEvent` attaches the `EVENT_NAME` metadata key (Spine label
+`otelEventName`); the backend forwards it as `emit(eventName = …)` and does not
+duplicate it as an attribute. With a non-OpenTelemetry backend the key degrades to
+ordinary metadata.
+
+Event names must be **low-cardinality** (no ids or other dynamic values) per the
+OpenTelemetry [event semantic conventions][otel-events]; dynamic data goes into
+attributes.
+
+## Domain events vs. observability events
+
+In an event-sourced Spine application the word *event* is overloaded, and the two
+meanings must not be conflated:
+
+- A **Spine domain event** is persisted, replayable, and the source of truth.
+- An **OpenTelemetry event** is lossy telemetry.
+
+**Never use the OpenTelemetry pipeline as an event store.** The safe, high-value
+pattern is to emit an observability event *about* a domain event as it is handled —
+turning the existing domain-event flow into trace-correlated telemetry:
+
+- `event.name` ← the Protobuf message **type** name (e.g. `acme.orders.OrderPlaced`),
+  which is naturally low-cardinality;
+- attributes ← selected proto fields plus `ScopedLoggingContext` (aggregate id,
+  bounded context, user);
+- correlation ← the active span, automatically.
+
+This bridge belongs in the **consumer** application, not in this module: it needs the
+Spine domain/proto types, which live in the service's own code (and depends on
+`io.spine:spine-server`), not in the logging library. A sketch in a consumer:
+
+```kotlin
+// In a consumer service, when a domain event is handled/applied:
+fun onDomainEvent(event: EventMessage) {
+    logger.atInfo()
+        .with(EVENT_NAME, event.typeName())   // proto type name → event.name
+        .with(AGGREGATE_ID, /* … */)           // selected fields → attributes
+        .log { "Domain event handled." }
+}
+```
+
+## Aligned with OTEP 4430
+
+Events are emitted through the **Logs API** (`emit(eventName = …)`), never
+`Span.AddEvent` — the direction endorsed by [OTEP 4430][otep-4430] (Span Event API
+deprecation).
+
+[otel]: https://opentelemetry.io/
+[otel-kotlin]: https://github.com/open-telemetry/opentelemetry-kotlin
+[otel-events]: https://opentelemetry.io/docs/specs/semconv/general/events/
+[otep-4430]: https://github.com/open-telemetry/opentelemetry-specification/blob/main/oteps/4430-span-event-api-deprecation-plan.md

From dfe5885f2cafe25f6d06be34de0eb690b0946fe1 Mon Sep 17 00:00:00 2001
From: Alexander Yevsyukov <alexander.yevsyukov@teamdev.com>
Date: Sat, 27 Jun 2026 23:57:55 +0100
Subject: [PATCH 06/20] Address PR review: resolve the OTel logger lazily; wire
 publishing

- `OtelLoggerBackend` no longer captures the OpenTelemetry logger at creation. It
  resolves from `OtelBackendSettings.current()` on every access (a `logger`
  property), so a backend created and cached per logging class before the SDK is
  installed picks it up once `use()` runs, and follows a later replacement (for
  example, the bootstrap restoring the no-op instance on shutdown).
- Publishing: add `otel-backend-bootstrap` to the root `spinePublishing.modules`,
  and configure `otel-backend` (a KMP module) with `kmp-publish` + `customPublishing`
  so it publishes as `spine-logging-otel-backend`. Verified via `publishToMavenLocal`.
- Update the backend tests for the lazy-resolution change.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 backends/otel-backend/build.gradle.kts        | 12 +++++++
 .../logging/backend/otel/OtelLoggerBackend.kt | 31 ++++++++++++++++---
 .../backend/otel/OtelBackendFactory.kt        |  3 +-
 .../backend/otel/OtelLoggerBackendSpec.kt     |  7 +++--
 build.gradle.kts                              |  3 +-
 5 files changed, 46 insertions(+), 10 deletions(-)

diff --git a/backends/otel-backend/build.gradle.kts b/backends/otel-backend/build.gradle.kts
index dd013d8e..d9e25b9e 100644
--- a/backends/otel-backend/build.gradle.kts
+++ b/backends/otel-backend/build.gradle.kts
@@ -27,14 +27,26 @@
 import io.spine.dependency.lib.AutoService
 import io.spine.dependency.lib.AutoServiceKsp
 import io.spine.dependency.lib.OpenTelemetryKotlin
+import io.spine.gradle.publish.SpinePublishing
+import io.spine.gradle.publish.spinePublishing
 import io.spine.gradle.testing.registerTestTasks
 import org.gradle.api.tasks.testing.Test
 
 plugins {
     `kmp-module`
+    `kmp-publish`
     ksp
 }
 
+// `kmp-module` publications are configured by `kmp-publish` (the `spinePublishing`
+// extension does not yet support Kotlin Multiplatform). The artifact is published as
+// `spine-logging-otel-backend`, matching the prefix used by the root project.
+spinePublishing {
+    artifactPrefix = "spine-logging-"
+    destinations = rootProject.the<SpinePublishing>().destinations
+    customPublishing = true
+}
+
 kotlin {
     @Suppress("unused") // Source set `val`s are used implicitly.
     sourceSets {
diff --git a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelLoggerBackend.kt b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelLoggerBackend.kt
index a50ac6d7..fc26a73e 100644
--- a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelLoggerBackend.kt
+++ b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelLoggerBackend.kt
@@ -56,14 +56,37 @@ import io.spine.logging.backend.SimpleMessageFormatter
  * left implicit (`context = null`), so the SDK stamps the current span's
  * trace and span identifiers onto the record.
  *
- * @param logger The OpenTelemetry logger to emit records with.
- * @param loggerName The instrumentation scope name, used by the SPI.
+ * The underlying OpenTelemetry [Logger] is resolved from [OtelBackendSettings] on
+ * every call rather than captured once. The platform caches a backend per logging
+ * class, so a backend may be created (for example, when a class first logs) before
+ * the application installs the SDK via [OtelBackendSettings.use]; resolving lazily
+ * lets such a backend pick up the instance once it is installed, and also lets it
+ * follow a later replacement (for example, the bootstrap restoring the no-op
+ * instance on shutdown).
+ *
+ * @param scopeName The instrumentation scope name (the logging class name with `$`
+ *   replaced by `.`), used both as the SPI [loggerName] and as the OpenTelemetry
+ *   logger name.
  */
 internal class OtelLoggerBackend(
-    private val logger: Logger,
-    override val loggerName: String?,
+    private val scopeName: String,
 ) : LoggerBackend() {
 
+    override val loggerName: String?
+        get() = scopeName
+
+    /**
+     * The OpenTelemetry logger, resolved from the currently installed instance.
+     *
+     * It is read on every access rather than captured once, so that installing or
+     * replacing the `OpenTelemetry` instance via [OtelBackendSettings] after this
+     * backend was created (the platform caches a backend per logging class) takes
+     * effect for subsequent records. The provider caches loggers by name, so the
+     * lookup is cheap.
+     */
+    private val logger: Logger
+        get() = OtelBackendSettings.current().loggerProvider.getLogger(scopeName)
+
     override fun isLoggable(level: Level): Boolean =
         logger.enabled(severityNumber = level.toSeverityNumber())
 
diff --git a/backends/otel-backend/src/jvmMain/kotlin/io/spine/logging/backend/otel/OtelBackendFactory.kt b/backends/otel-backend/src/jvmMain/kotlin/io/spine/logging/backend/otel/OtelBackendFactory.kt
index f6d6ef44..81110d1a 100644
--- a/backends/otel-backend/src/jvmMain/kotlin/io/spine/logging/backend/otel/OtelBackendFactory.kt
+++ b/backends/otel-backend/src/jvmMain/kotlin/io/spine/logging/backend/otel/OtelBackendFactory.kt
@@ -51,8 +51,7 @@ public class OtelBackendFactory : BackendFactory() {
 
     override fun create(loggingClass: String): LoggerBackend {
         val name = loggingClass.replace('$', '.')
-        val logger = OtelBackendSettings.current().loggerProvider.getLogger(name)
-        return OtelLoggerBackend(logger, loggerName = name)
+        return OtelLoggerBackend(name)
     }
 
     /** Returns a fully-qualified name of this class. */
diff --git a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
index 0d411805..d381f8c9 100644
--- a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
+++ b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
@@ -67,8 +67,8 @@ internal class OtelLoggerBackendSpec {
                 export { processor }
             }
         }
-        val logger = otel.loggerProvider.getLogger(LOGGER_NAME)
-        backend = OtelLoggerBackend(logger, LOGGER_NAME)
+        OtelBackendSettings.use(otel)
+        backend = OtelLoggerBackend(LOGGER_NAME)
     }
 
     @AfterEach
@@ -207,7 +207,8 @@ internal class OtelLoggerBackendSpec {
             tracerProvider { export { NoOpSpanProcessor() } }
             loggerProvider { export { processor } }
         }
-        val correlated = OtelLoggerBackend(otel.loggerProvider.getLogger(LOGGER_NAME), LOGGER_NAME)
+        OtelBackendSettings.use(otel)
+        val correlated = OtelLoggerBackend(LOGGER_NAME)
         val span = otel.tracerProvider.getTracer(LOGGER_NAME).startSpan("unit")
         val scope = otel.context.implicit().storeSpan(span).attach()
         try {
diff --git a/build.gradle.kts b/build.gradle.kts
index 973f7c03..e5d4991c 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -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.
@@ -56,6 +56,7 @@ spinePublishing {
     modules = setOf(
         "log4j2-backend",
         "jul-backend",
+        "otel-backend-bootstrap",
         "std-context",
         "grpc-context",
         "smoke-test",

From bf314b34f4f2b3bb4aa4b0bdfc64d80fcd51da4a Mon Sep 17 00:00:00 2001
From: Alexander Yevsyukov <alexander.yevsyukov@teamdev.com>
Date: Sat, 27 Jun 2026 23:59:08 +0100
Subject: [PATCH 07/20] Reformat MD table

---
 docs/otel-backend.md | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/docs/otel-backend.md b/docs/otel-backend.md
index b3847c6f..2b4e1cad 100644
--- a/docs/otel-backend.md
+++ b/docs/otel-backend.md
@@ -72,16 +72,16 @@ installed.close()
 
 ## What is mapped
 
-| Spine `LogData` | OpenTelemetry log record |
-|---|---|
-| rendered message (without the `[CONTEXT …]` suffix) | `body` |
-| `level` | `severityNumber` (numeric threshold) and `severityText` (the level name) |
-| `timestampNanos` | `timestamp` (epoch nanoseconds) |
-| `LogContext.Key.LOG_CAUSE` | `exception` (recorded as `exception.*` attributes) |
-| `logSite` | `code.namespace`, `code.function`, `code.filepath`, `code.lineno` |
-| scope + log-site metadata | attributes, namespaced `spine.<label>` (repeated → list) |
-| `Tags` from `ScopedLoggingContext` | `spine.tag.<name>` attributes |
-| the active span | trace/span ids (the record is emitted with the implicit context) |
+| Spine `LogData`                                     | OpenTelemetry log record                                                 |
+|-----------------------------------------------------|--------------------------------------------------------------------------|
+| rendered message (without the `[CONTEXT …]` suffix) | `body`                                                                   |
+| `level`                                             | `severityNumber` (numeric threshold) and `severityText` (the level name) |
+| `timestampNanos`                                    | `timestamp` (epoch nanoseconds)                                          |
+| `LogContext.Key.LOG_CAUSE`                          | `exception` (recorded as `exception.*` attributes)                       |
+| `logSite`                                           | `code.namespace`, `code.function`, `code.filepath`, `code.lineno`        |
+| scope + log-site metadata                           | attributes, namespaced `spine.<label>` (repeated → list)                 |
+| `Tags` from `ScopedLoggingContext`                  | `spine.tag.<name>` attributes                                            |
+| the active span                                     | trace/span ids (the record is emitted with the implicit context)         |
 
 Metadata is emitted as **structured attributes**, not folded into the message text, so a
 downstream collector sees Spine's bounded-context, aggregate id, user, etc. as queryable

From 215ff0dcea5bbc5eacf72145aeb06eee1fc5fe19 Mon Sep 17 00:00:00 2001
From: Alexander Yevsyukov <alexander.yevsyukov@teamdev.com>
Date: Sun, 28 Jun 2026 16:54:15 +0100
Subject: [PATCH 08/20] Add tests for OTel attribute value types and edge cases

Raise patch coverage for the OpenTelemetry backend: exercise the single and
repeated attribute value-type branches (numeric widening; boolean/double/string
lists; non-primitive `toString` fallback), the unknown line-number / source-file
log site, the factory `toString()`, and the bootstrap default-endpoint install.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../backend/otel/bootstrap/OtelLoggingSpec.kt |  8 +++
 .../backend/otel/OtelLoggerBackendSpec.kt     | 51 +++++++++++++++++++
 2 files changed, 59 insertions(+)

diff --git a/backends/otel-backend-bootstrap/src/test/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLoggingSpec.kt b/backends/otel-backend-bootstrap/src/test/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLoggingSpec.kt
index 87eb0e07..904bdd83 100644
--- a/backends/otel-backend-bootstrap/src/test/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLoggingSpec.kt
+++ b/backends/otel-backend-bootstrap/src/test/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLoggingSpec.kt
@@ -43,6 +43,14 @@ internal class OtelLoggingSpec {
         }
     }
 
+    @Test
+    fun `install using the default endpoint`() {
+        shouldNotThrowAny {
+            val installed = OtelLogging.installOtlpHttp()
+            installed.close()
+        }
+    }
+
     @Test
     fun `install from the environment, falling back to the default endpoint`() {
         shouldNotThrowAny {
diff --git a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
index d381f8c9..ed941e98 100644
--- a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
+++ b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
@@ -251,6 +251,51 @@ internal class OtelLoggerBackendSpec {
         processor.records shouldHaveSize 1
     }
 
+    @Test
+    fun `map single numeric and non-primitive attribute values`() {
+        backend.log(
+            StubLogData(LITERAL)
+                .addMetadata(LONG_KEY, 7L)
+                .addMetadata(CHAR_KEY, 'x')
+        )
+        with(lastRecord.attributes) {
+            this["spine.count"] shouldBe 7L
+            this["spine.symbol"] shouldBe "x"
+        }
+    }
+
+    @Test
+    fun `collect repeated attribute values by type`() {
+        backend.log(
+            StubLogData(LITERAL)
+                .addMetadata(BOOL_LIST_KEY, true).addMetadata(BOOL_LIST_KEY, false)
+                .addMetadata(DOUBLE_LIST_KEY, 1.5).addMetadata(DOUBLE_LIST_KEY, 2.5)
+                .addMetadata(STRING_LIST_KEY, "a").addMetadata(STRING_LIST_KEY, "b")
+                .addMetadata(CHAR_LIST_KEY, 'a').addMetadata(CHAR_LIST_KEY, 'b')
+        )
+        with(lastRecord.attributes) {
+            (this["spine.flags"] as List<*>) shouldContainExactlyInAnyOrder listOf(true, false)
+            (this["spine.ratios"] as List<*>) shouldContainExactlyInAnyOrder listOf(1.5, 2.5)
+            (this["spine.names"] as List<*>) shouldContainExactlyInAnyOrder listOf("a", "b")
+            (this["spine.symbols"] as List<*>) shouldContainExactlyInAnyOrder listOf("a", "b")
+        }
+    }
+
+    @Test
+    fun `omit the line number and source file when unknown`() {
+        backend.log(StubLogData(LITERAL).setLogSite(StubLogSite("C", "m", 0, null)))
+        with(lastRecord.attributes) {
+            this shouldNotContainKey "code.lineno"
+            this shouldNotContainKey "code.filepath"
+        }
+    }
+
+    @Test
+    fun `report its fully-qualified class name from the factory's 'toString'`() {
+        OtelBackendFactory().toString() shouldBe
+            "io.spine.logging.backend.otel.OtelBackendFactory"
+    }
+
     private class EventSource : WithLogging
 
     companion object {
@@ -261,5 +306,11 @@ internal class OtelLoggerBackendSpec {
         private val INT_KEY = MetadataKey.repeated<Int>("int")
         private val BOOL_KEY = MetadataKey.single<Boolean>("enabled")
         private val DOUBLE_KEY = MetadataKey.single<Double>("ratio")
+        private val LONG_KEY = MetadataKey.single<Long>("count")
+        private val CHAR_KEY = MetadataKey.single<Char>("symbol")
+        private val BOOL_LIST_KEY = MetadataKey.repeated<Boolean>("flags")
+        private val DOUBLE_LIST_KEY = MetadataKey.repeated<Double>("ratios")
+        private val STRING_LIST_KEY = MetadataKey.repeated<String>("names")
+        private val CHAR_LIST_KEY = MetadataKey.repeated<Char>("symbols")
     }
 }

From e144c05020415a18f60262026a51a467641505e8 Mon Sep 17 00:00:00 2001
From: Alexander Yevsyukov <alexander.yevsyukov@teamdev.com>
Date: Sun, 28 Jun 2026 17:31:13 +0100
Subject: [PATCH 09/20] Use bare metadata attribute names; keep a `tag.`
 namespace
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Drop the `spine.` prefix on metadata-derived attributes. Spine labels are dot-free
identifiers and cannot collide with OpenTelemetry's dotted semantic conventions, so
the prefix was convention, not collision-prevention — metadata keys now map to bare
attributes named after their label.

Keep a prefix for `Tags`, de-`spine`d to `tag.`: tag names and metadata labels share
the same identifier namespace, so a same-named tag and metadata key would otherwise
overwrite each other. The KDoc now states that actual rationale.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../logging/backend/otel/AttributeMapping.kt  | 24 +++++++-------
 .../backend/otel/OtelLoggerBackendSpec.kt     | 32 +++++++++----------
 docs/otel-backend.md                          |  4 +--
 3 files changed, 29 insertions(+), 31 deletions(-)

diff --git a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/AttributeMapping.kt b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/AttributeMapping.kt
index d5255951..d68b4adb 100644
--- a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/AttributeMapping.kt
+++ b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/AttributeMapping.kt
@@ -36,16 +36,15 @@ import io.spine.logging.backend.MetadataHandler
 import io.spine.logging.backend.MetadataProcessor
 import io.spine.logging.context.Tags
 
-/**
- * The prefix applied to Spine metadata keys so they never collide with
- * OpenTelemetry semantic-convention attribute names.
- */
-private const val SPINE_PREFIX = "spine."
-
 /**
  * The prefix applied to individual [Tags] entries.
+ *
+ * Tag names and metadata-key labels share the same identifier namespace — both are
+ * validated by `checkMetadataIdentifier` — so a tag and a metadata key with the same
+ * name would otherwise map to the same attribute and overwrite each other. The `tag.`
+ * prefix keeps tags in their own namespace.
  */
-private const val TAG_PREFIX = "spine.tag."
+private const val TAG_PREFIX = "tag."
 
 /**
  * Records the log site of the given [data] as OpenTelemetry `code.*`
@@ -64,10 +63,9 @@ internal fun AttributesMutator.putLogSite(data: LogData) {
 /**
  * Records the scope and log-site [metadata] as attributes.
  *
- * The throwable carried under [LogContext.Key.LOG_CAUSE] is ignored here,
- * as it is emitted as the log record's exception. [Tags] are expanded into
- * individual `spine.tag.<name>` attributes; all other keys are namespaced
- * under `spine.<label>`.
+ * Each key becomes an attribute named after its label. The throwable carried under
+ * [LogContext.Key.LOG_CAUSE] is ignored here, as it is emitted as the log record's
+ * exception; [Tags] are expanded into individual `tag.<name>` attributes.
  */
 internal fun AttributesMutator.putMetadata(metadata: MetadataProcessor) {
     metadata.process(attributeHandler, this)
@@ -75,9 +73,9 @@ internal fun AttributesMutator.putMetadata(metadata: MetadataProcessor) {
 
 private val attributeHandler: MetadataHandler<AttributesMutator> =
     MetadataHandler.builder<AttributesMutator> { key, value, mutator ->
-        mutator.putValue(SPINE_PREFIX + key.label, value)
+        mutator.putValue(key.label, value)
     }.setDefaultRepeatedHandler { key, values, mutator ->
-        mutator.putValues(SPINE_PREFIX + key.label, values)
+        mutator.putValues(key.label, values)
     }.addHandler(LogContext.Key.TAGS) { _, tags, mutator ->
         mutator.putTags(tags)
     }.ignoring(
diff --git a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
index ed941e98..c70809b3 100644
--- a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
+++ b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
@@ -129,9 +129,9 @@ internal class OtelLoggerBackendSpec {
     }
 
     @Test
-    fun `namespace custom metadata under 'spine'`() {
+    fun `record custom metadata as an attribute named after its label`() {
         backend.log(StubLogData(LITERAL).addMetadata(STR_KEY, "value"))
-        lastRecord.attributes["spine.str"] shouldBe "value"
+        lastRecord.attributes["str"] shouldBe "value"
     }
 
     @Test
@@ -141,7 +141,7 @@ internal class OtelLoggerBackendSpec {
                 .addMetadata(INT_KEY, 1)
                 .addMetadata(INT_KEY, 2)
         )
-        lastRecord.attributes["spine.int"] shouldBe listOf(1L, 2L)
+        lastRecord.attributes["int"] shouldBe listOf(1L, 2L)
     }
 
     @Test
@@ -151,7 +151,7 @@ internal class OtelLoggerBackendSpec {
         with(lastRecord.attributes) {
             this shouldContainKey "exception.message"
             this["exception.message"] shouldBe "Boom"
-            this shouldNotContainKey "spine.cause"
+            this shouldNotContainKey "cause"
         }
     }
 
@@ -169,8 +169,8 @@ internal class OtelLoggerBackendSpec {
                 .addMetadata(DOUBLE_KEY, 1.5)
         )
         with(lastRecord.attributes) {
-            this["spine.enabled"] shouldBe true
-            this["spine.ratio"] shouldBe 1.5
+            this["enabled"] shouldBe true
+            this["ratio"] shouldBe 1.5
         }
     }
 
@@ -184,9 +184,9 @@ internal class OtelLoggerBackendSpec {
             .build()
         backend.log(StubLogData(LITERAL).addMetadata(LogContext.Key.TAGS, tags))
         with(lastRecord.attributes) {
-            this["spine.tag.flag"] shouldBe true
-            this["spine.tag.user"] shouldBe "alice"
-            (this["spine.tag.ids"] as List<*>) shouldContainExactlyInAnyOrder listOf("a", "b")
+            this["tag.flag"] shouldBe true
+            this["tag.user"] shouldBe "alice"
+            (this["tag.ids"] as List<*>) shouldContainExactlyInAnyOrder listOf("a", "b")
         }
     }
 
@@ -228,7 +228,7 @@ internal class OtelLoggerBackendSpec {
     fun `emit a named event when the event-name metadata is set`() {
         backend.log(StubLogData(LITERAL).addMetadata(EVENT_NAME, "checkout.completed"))
         lastRecord.eventName shouldBe "checkout.completed"
-        lastRecord.attributes shouldNotContainKey "spine.otelEventName"
+        lastRecord.attributes shouldNotContainKey "otelEventName"
     }
 
     @Test
@@ -259,8 +259,8 @@ internal class OtelLoggerBackendSpec {
                 .addMetadata(CHAR_KEY, 'x')
         )
         with(lastRecord.attributes) {
-            this["spine.count"] shouldBe 7L
-            this["spine.symbol"] shouldBe "x"
+            this["count"] shouldBe 7L
+            this["symbol"] shouldBe "x"
         }
     }
 
@@ -274,10 +274,10 @@ internal class OtelLoggerBackendSpec {
                 .addMetadata(CHAR_LIST_KEY, 'a').addMetadata(CHAR_LIST_KEY, 'b')
         )
         with(lastRecord.attributes) {
-            (this["spine.flags"] as List<*>) shouldContainExactlyInAnyOrder listOf(true, false)
-            (this["spine.ratios"] as List<*>) shouldContainExactlyInAnyOrder listOf(1.5, 2.5)
-            (this["spine.names"] as List<*>) shouldContainExactlyInAnyOrder listOf("a", "b")
-            (this["spine.symbols"] as List<*>) shouldContainExactlyInAnyOrder listOf("a", "b")
+            (this["flags"] as List<*>) shouldContainExactlyInAnyOrder listOf(true, false)
+            (this["ratios"] as List<*>) shouldContainExactlyInAnyOrder listOf(1.5, 2.5)
+            (this["names"] as List<*>) shouldContainExactlyInAnyOrder listOf("a", "b")
+            (this["symbols"] as List<*>) shouldContainExactlyInAnyOrder listOf("a", "b")
         }
     }
 
diff --git a/docs/otel-backend.md b/docs/otel-backend.md
index 2b4e1cad..b21a8eb1 100644
--- a/docs/otel-backend.md
+++ b/docs/otel-backend.md
@@ -79,8 +79,8 @@ installed.close()
 | `timestampNanos`                                    | `timestamp` (epoch nanoseconds)                                          |
 | `LogContext.Key.LOG_CAUSE`                          | `exception` (recorded as `exception.*` attributes)                       |
 | `logSite`                                           | `code.namespace`, `code.function`, `code.filepath`, `code.lineno`        |
-| scope + log-site metadata                           | attributes, namespaced `spine.<label>` (repeated → list)                 |
-| `Tags` from `ScopedLoggingContext`                  | `spine.tag.<name>` attributes                                            |
+| scope + log-site metadata                           | attributes, named `<label>` (repeated → list)                 |
+| `Tags` from `ScopedLoggingContext`                  | `tag.<name>` attributes                                            |
 | the active span                                     | trace/span ids (the record is emitted with the implicit context)         |
 
 Metadata is emitted as **structured attributes**, not folded into the message text, so a

From beb08461e9579eb9d312cdec5ccac04bfa33600c Mon Sep 17 00:00:00 2001
From: Alexander Yevsyukov <alexander.yevsyukov@teamdev.com>
Date: Sun, 28 Jun 2026 18:00:02 +0100
Subject: [PATCH 10/20] Update dependency reports

---
 docs/dependencies/dependencies.md | 2357 ++++++++++++++++++++++++++++-
 docs/dependencies/pom.xml         |    2 +-
 2 files changed, 2342 insertions(+), 17 deletions(-)

diff --git a/docs/dependencies/dependencies.md b/docs/dependencies/dependencies.md
index 83457142..8ad2adf7 100644
--- a/docs/dependencies/dependencies.md
+++ b/docs/dependencies/dependencies.md
@@ -441,7 +441,7 @@
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:55:25 WEST 2026** using 
+This report was generated on **Sun Jun 28 17:14: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).
 
@@ -1240,7 +1240,7 @@ This report was generated on **Sun Jun 28 17:55:25 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:55:26 WEST 2026** using 
+This report was generated on **Sun Jun 28 17:14: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).
 
@@ -2094,7 +2094,7 @@ This report was generated on **Sun Jun 28 17:55:26 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:55:25 WEST 2026** using 
+This report was generated on **Sun Jun 28 17:14: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).
 
@@ -2932,7 +2932,7 @@ This report was generated on **Sun Jun 28 17:55:25 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:55:26 WEST 2026** using 
+This report was generated on **Sun Jun 28 17:14: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).
 
@@ -3786,7 +3786,7 @@ This report was generated on **Sun Jun 28 17:55:26 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:55:26 WEST 2026** using 
+This report was generated on **Sun Jun 28 17:14: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).
 
@@ -4692,7 +4692,7 @@ This report was generated on **Sun Jun 28 17:55:26 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:55:25 WEST 2026** using 
+This report was generated on **Sun Jun 28 17:14: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).
 
@@ -5590,7 +5590,7 @@ This report was generated on **Sun Jun 28 17:55:25 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:55:25 WEST 2026** using 
+This report was generated on **Sun Jun 28 17:14: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).
 
@@ -6508,7 +6508,7 @@ This report was generated on **Sun Jun 28 17:55:25 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:55:25 WEST 2026** using 
+This report was generated on **Sun Jun 28 17:14: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).
 
@@ -7414,7 +7414,7 @@ This report was generated on **Sun Jun 28 17:55:25 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:55:25 WEST 2026** using 
+This report was generated on **Sun Jun 28 17:14: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).
 
@@ -8324,7 +8324,7 @@ This report was generated on **Sun Jun 28 17:55:25 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:55:25 WEST 2026** using 
+This report was generated on **Sun Jun 28 17:14: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).
 
@@ -9206,7 +9206,7 @@ This report was generated on **Sun Jun 28 17:55:25 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:55:25 WEST 2026** using 
+This report was generated on **Sun Jun 28 17:14: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).
 
@@ -10013,7 +10013,7 @@ This report was generated on **Sun Jun 28 17:55:25 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:55:26 WEST 2026** using 
+This report was generated on **Sun Jun 28 17:14: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).
 
@@ -10832,7 +10832,2332 @@ This report was generated on **Sun Jun 28 17:55:26 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:55:26 WEST 2026** using 
+This report was generated on **Sun Jun 28 17:14: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-otel-backend:2.0.0-SNAPSHOT.418`
+
+## Runtime
+## Compile, tests, and tooling
+1.  **Group** : com.fasterxml.jackson. **Name** : jackson-bom. **Version** : 2.22.0.
+     * **Project URL:** [https://github.com/FasterXML/jackson-bom](https://github.com/FasterXML/jackson-bom)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.fasterxml.jackson.core. **Name** : jackson-annotations. **Version** : 2.22.
+     * **Project URL:** [https://github.com/FasterXML/jackson](https://github.com/FasterXML/jackson)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.fasterxml.jackson.core. **Name** : jackson-core. **Version** : 2.22.0.
+     * **Project URL:** [https://github.com/FasterXML/jackson-core](https://github.com/FasterXML/jackson-core)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.fasterxml.jackson.core. **Name** : jackson-databind. **Version** : 2.22.0.
+     * **Project URL:** [https://github.com/FasterXML/jackson](https://github.com/FasterXML/jackson)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.fasterxml.jackson.dataformat. **Name** : jackson-dataformat-xml. **Version** : 2.22.0.
+     * **Project URL:** [https://github.com/FasterXML/jackson-dataformat-xml](https://github.com/FasterXML/jackson-dataformat-xml)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.fasterxml.jackson.module. **Name** : jackson-module-kotlin. **Version** : 2.22.0.
+     * **Project URL:** [https://github.com/FasterXML/jackson-module-kotlin](https://github.com/FasterXML/jackson-module-kotlin)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.fasterxml.woodstox. **Name** : woodstox-core. **Version** : 7.2.0.
+     * **Project URL:** [https://github.com/FasterXML/woodstox](https://github.com/FasterXML/woodstox)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.github.ajalt.colormath. **Name** : colormath. **Version** : 3.6.0.
+     * **Project URL:** [https://github.com/ajalt/colormath/](https://github.com/ajalt/colormath/)
+     * **License:** [The MIT License](https://opensource.org/licenses/MIT)
+
+1.  **Group** : com.github.ajalt.mordant. **Name** : mordant. **Version** : 3.0.2.
+     * **Project URL:** [https://github.com/ajalt/mordant/](https://github.com/ajalt/mordant/)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : com.github.ajalt.mordant. **Name** : mordant-core. **Version** : 3.0.2.
+     * **Project URL:** [https://github.com/ajalt/mordant/](https://github.com/ajalt/mordant/)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : com.google.auto.service. **Name** : auto-service-annotations. **Version** : 1.1.1.
+     * **Project URL:** [https://github.com/google/auto/tree/main/service](https://github.com/google/auto/tree/main/service)
+     * **License:** [Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.auto.value. **Name** : auto-value-annotations. **Version** : 1.11.1.
+     * **Project URL:** [https://github.com/google/auto/tree/main/value](https://github.com/google/auto/tree/main/value)
+     * **License:** [Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2.
+     * **Project URL:** [http://findbugs.sourceforge.net/](http://findbugs.sourceforge.net/)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.code.gson. **Name** : gson. **Version** : 2.14.0.
+     * **Project URL:** [https://github.com/google/gson](https://github.com/google/gson)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.code.gson. **Name** : gson. **Version** : 2.8.9.
+     * **Project URL:** [https://github.com/google/gson/gson](https://github.com/google/gson/gson)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.devtools.ksp. **Name** : symbol-processing-api. **Version** : 2.3.9.
+     * **Project URL:** [https://goo.gle/ksp](https://goo.gle/ksp)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.errorprone. **Name** : error_prone_annotations. **Version** : 2.36.0.
+     * **Project URL:** [https://errorprone.info/error_prone_annotations](https://errorprone.info/error_prone_annotations)
+     * **License:** [Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.errorprone. **Name** : error_prone_annotations. **Version** : 2.47.0.
+     * **Project URL:** [https://errorprone.info/error_prone_annotations](https://errorprone.info/error_prone_annotations)
+     * **License:** [Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.errorprone. **Name** : error_prone_type_annotations. **Version** : 2.36.0.
+     * **Project URL:** [https://errorprone.info/error_prone_type_annotations](https://errorprone.info/error_prone_type_annotations)
+     * **License:** [Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.flogger. **Name** : flogger. **Version** : 0.7.4.
+     * **Project URL:** [https://github.com/google/flogger](https://github.com/google/flogger)
+     * **License:** [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.flogger. **Name** : flogger-system-backend. **Version** : 0.7.4.
+     * **Project URL:** [https://github.com/google/flogger](https://github.com/google/flogger)
+     * **License:** [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.guava. **Name** : failureaccess. **Version** : 1.0.3.
+     * **Project URL:** [https://github.com/google/guava/](https://github.com/google/guava/)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.guava. **Name** : guava. **Version** : 33.6.0-jre.
+     * **Project URL:** [https://github.com/google/guava](https://github.com/google/guava)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.guava. **Name** : guava-testlib. **Version** : 33.6.0-jre.
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.guava. **Name** : listenablefuture. **Version** : 9999.0-empty-to-avoid-conflict-with-guava.
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.j2objc. **Name** : j2objc-annotations. **Version** : 3.1.
+     * **Project URL:** [https://github.com/google/j2objc/](https://github.com/google/j2objc/)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.protobuf. **Name** : protobuf-java. **Version** : 4.35.0.
+     * **Project URL:** [https://developers.google.com/protocol-buffers/](https://developers.google.com/protocol-buffers/)
+     * **License:** [BSD-3-Clause](https://opensource.org/licenses/BSD-3-Clause)
+
+1.  **Group** : com.google.protobuf. **Name** : protobuf-java-util. **Version** : 4.35.0.
+     * **Project URL:** [https://developers.google.com/protocol-buffers/](https://developers.google.com/protocol-buffers/)
+     * **License:** [BSD-3-Clause](https://opensource.org/licenses/BSD-3-Clause)
+
+1.  **Group** : com.google.protobuf. **Name** : protobuf-kotlin. **Version** : 4.35.0.
+     * **Project URL:** [https://developers.google.com/protocol-buffers/](https://developers.google.com/protocol-buffers/)
+     * **License:** [BSD-3-Clause](https://opensource.org/licenses/BSD-3-Clause)
+
+1.  **Group** : com.google.truth. **Name** : truth. **Version** : 1.4.5.
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.truth.extensions. **Name** : truth-java8-extension. **Version** : 1.4.5.
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.truth.extensions. **Name** : truth-liteproto-extension. **Version** : 1.4.5.
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.truth.extensions. **Name** : truth-proto-extension. **Version** : 1.4.5.
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.puppycrawl.tools. **Name** : checkstyle. **Version** : 10.12.1.
+     * **Project URL:** [https://checkstyle.org/](https://checkstyle.org/)
+     * **License:** [LGPL-2.1+](http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt)
+
+1.  **Group** : com.soywiz.korlibs.korte. **Name** : korte-jvm. **Version** : 4.0.10.
+     * **Project URL:** [https://github.com/korlibs/korge-next](https://github.com/korlibs/korge-next)
+     * **License:** [MIT](https://raw.githubusercontent.com/korlibs/korge-next/master/korge/LICENSE.txt)
+
+1.  **Group** : com.squareup. **Name** : kotlinpoet. **Version** : 1.17.0.
+     * **Project URL:** [https://github.com/square/kotlinpoet](https://github.com/square/kotlinpoet)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.squareup. **Name** : kotlinpoet-jvm. **Version** : 1.17.0.
+     * **Project URL:** [https://github.com/square/kotlinpoet](https://github.com/square/kotlinpoet)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : commons-beanutils. **Name** : commons-beanutils. **Version** : 1.9.4.
+     * **Project URL:** [https://commons.apache.org/proper/commons-beanutils/](https://commons.apache.org/proper/commons-beanutils/)
+     * **License:** [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : commons-codec. **Name** : commons-codec. **Version** : 1.22.0.
+     * **Project URL:** [https://commons.apache.org/proper/commons-codec/](https://commons.apache.org/proper/commons-codec/)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : commons-collections. **Name** : commons-collections. **Version** : 3.2.2.
+     * **Project URL:** [http://commons.apache.org/collections/](http://commons.apache.org/collections/)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : dev.drewhamilton.poko. **Name** : poko-annotations. **Version** : 0.17.1.
+     * **Project URL:** [https://github.com/drewhamilton/Poko](https://github.com/drewhamilton/Poko)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : dev.drewhamilton.poko. **Name** : poko-annotations-jvm. **Version** : 0.17.1.
+     * **Project URL:** [https://github.com/drewhamilton/Poko](https://github.com/drewhamilton/Poko)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : dev.zacsweers.autoservice. **Name** : auto-service-ksp. **Version** : 1.2.0.
+     * **Project URL:** [https://github.com/ZacSweers/auto-service-ksp](https://github.com/ZacSweers/auto-service-ksp)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : info.picocli. **Name** : picocli. **Version** : 4.7.4.
+     * **Project URL:** [https://picocli.info](https://picocli.info)
+     * **License:** [The Apache Software License, version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.github.davidburstrom.contester. **Name** : contester-breakpoint. **Version** : 0.2.0.
+     * **Project URL:** [https://github.com/davidburstrom/contester](https://github.com/davidburstrom/contester)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.github.detekt.sarif4k. **Name** : sarif4k. **Version** : 0.6.0.
+     * **Project URL:** [https://detekt.github.io/detekt](https://detekt.github.io/detekt)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.github.detekt.sarif4k. **Name** : sarif4k-jvm. **Version** : 0.6.0.
+     * **Project URL:** [https://detekt.github.io/detekt](https://detekt.github.io/detekt)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.github.java-diff-utils. **Name** : java-diff-utils. **Version** : 4.17.
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.github.pdvrieze.xmlutil. **Name** : core. **Version** : 0.91.3.
+     * **Project URL:** [https://github.com/pdvrieze/xmlutil](https://github.com/pdvrieze/xmlutil)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.github.pdvrieze.xmlutil. **Name** : core-jvmcommon. **Version** : 0.91.3.
+     * **Project URL:** [https://github.com/pdvrieze/xmlutil](https://github.com/pdvrieze/xmlutil)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.github.pdvrieze.xmlutil. **Name** : serialization. **Version** : 0.91.3.
+     * **Project URL:** [https://github.com/pdvrieze/xmlutil](https://github.com/pdvrieze/xmlutil)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.github.pdvrieze.xmlutil. **Name** : serialization-jvm. **Version** : 0.91.3.
+     * **Project URL:** [https://github.com/pdvrieze/xmlutil](https://github.com/pdvrieze/xmlutil)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-api. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-cli. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-core. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-metrics. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-parser. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-psi-utils. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-report-html. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-report-md. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-report-sarif. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-report-txt. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-report-xml. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-rules. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-rules-complexity. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-rules-coroutines. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-rules-documentation. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-rules-empty. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-rules-errorprone. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-rules-exceptions. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-rules-naming. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-rules-performance. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-rules-style. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-tooling. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-utils. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.kotest. **Name** : kotest-assertions-core. **Version** : 6.1.11.
+     * **Project URL:** [https://github.com/kotest/kotest](https://github.com/kotest/kotest)
+     * **License:** [Apache-2.0](https://opensource.org/licenses/Apache-2.0)
+
+1.  **Group** : io.kotest. **Name** : kotest-assertions-core-jvm. **Version** : 6.1.11.
+     * **Project URL:** [https://github.com/kotest/kotest](https://github.com/kotest/kotest)
+     * **License:** [Apache-2.0](https://opensource.org/licenses/Apache-2.0)
+
+1.  **Group** : io.kotest. **Name** : kotest-assertions-shared. **Version** : 6.1.11.
+     * **Project URL:** [https://github.com/kotest/kotest](https://github.com/kotest/kotest)
+     * **License:** [Apache-2.0](https://opensource.org/licenses/Apache-2.0)
+
+1.  **Group** : io.kotest. **Name** : kotest-assertions-shared-jvm. **Version** : 6.1.11.
+     * **Project URL:** [https://github.com/kotest/kotest](https://github.com/kotest/kotest)
+     * **License:** [Apache-2.0](https://opensource.org/licenses/Apache-2.0)
+
+1.  **Group** : io.kotest. **Name** : kotest-common. **Version** : 6.1.11.
+     * **Project URL:** [https://github.com/kotest/kotest](https://github.com/kotest/kotest)
+     * **License:** [Apache-2.0](https://opensource.org/licenses/Apache-2.0)
+
+1.  **Group** : io.kotest. **Name** : kotest-common-jvm. **Version** : 6.1.11.
+     * **Project URL:** [https://github.com/kotest/kotest](https://github.com/kotest/kotest)
+     * **License:** [Apache-2.0](https://opensource.org/licenses/Apache-2.0)
+
+1.  **Group** : io.kotest. **Name** : kotest-extensions. **Version** : 6.1.11.
+     * **Project URL:** [https://github.com/kotest/kotest](https://github.com/kotest/kotest)
+     * **License:** [Apache-2.0](https://opensource.org/licenses/Apache-2.0)
+
+1.  **Group** : io.kotest. **Name** : kotest-extensions-jvm. **Version** : 6.1.11.
+     * **Project URL:** [https://github.com/kotest/kotest](https://github.com/kotest/kotest)
+     * **License:** [Apache-2.0](https://opensource.org/licenses/Apache-2.0)
+
+1.  **Group** : io.kotest. **Name** : kotest-framework-engine. **Version** : 6.1.11.
+     * **Project URL:** [https://github.com/kotest/kotest](https://github.com/kotest/kotest)
+     * **License:** [Apache-2.0](https://opensource.org/licenses/Apache-2.0)
+
+1.  **Group** : io.kotest. **Name** : kotest-framework-engine-jvm. **Version** : 6.1.11.
+     * **Project URL:** [https://github.com/kotest/kotest](https://github.com/kotest/kotest)
+     * **License:** [Apache-2.0](https://opensource.org/licenses/Apache-2.0)
+
+1.  **Group** : io.kotest. **Name** : kotest-runner-junit-platform. **Version** : 6.1.11.
+     * **Project URL:** [https://github.com/kotest/kotest](https://github.com/kotest/kotest)
+     * **License:** [Apache-2.0](https://opensource.org/licenses/Apache-2.0)
+
+1.  **Group** : io.kotest. **Name** : kotest-runner-junit-platform-jvm. **Version** : 6.1.11.
+     * **Project URL:** [https://github.com/kotest/kotest](https://github.com/kotest/kotest)
+     * **License:** [Apache-2.0](https://opensource.org/licenses/Apache-2.0)
+
+1.  **Group** : io.kotest. **Name** : kotest-runner-junit5-jvm. **Version** : 6.1.11.
+     * **Project URL:** [https://github.com/kotest/kotest](https://github.com/kotest/kotest)
+     * **License:** [Apache-2.0](https://opensource.org/licenses/Apache-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : api. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : api-ext. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : api-ext-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : api-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : core. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : core-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : exporters-core. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : exporters-core-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : implementation. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : implementation-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : model. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : model-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : noop. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : noop-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : platform-implementations. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : platform-implementations-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : sdk-api. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : sdk-api-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : sdk-common. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : sdk-common-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : semconv. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : semconv-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : junit. **Name** : junit. **Version** : 4.13.2.
+     * **Project URL:** [http://junit.org](http://junit.org)
+     * **License:** [Eclipse Public License 1.0](http://www.eclipse.org/legal/epl-v10.html)
+
+1.  **Group** : net.bytebuddy. **Name** : byte-buddy. **Version** : 1.10.9.
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : net.bytebuddy. **Name** : byte-buddy-agent. **Version** : 1.10.9.
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : net.java.dev.jna. **Name** : jna. **Version** : 5.9.0.
+     * **Project URL:** [https://github.com/java-native-access/jna](https://github.com/java-native-access/jna)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+     * **License:** [LGPL-2.1-or-later](https://www.gnu.org/licenses/old-licenses/lgpl-2.1)
+
+1.  **Group** : net.java.dev.jna. **Name** : jna-platform. **Version** : 5.9.0.
+     * **Project URL:** [https://github.com/java-native-access/jna](https://github.com/java-native-access/jna)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+     * **License:** [LGPL-2.1-or-later](https://www.gnu.org/licenses/old-licenses/lgpl-2.1)
+
+1.  **Group** : net.sf.saxon. **Name** : Saxon-HE. **Version** : 12.2.
+     * **Project URL:** [http://www.saxonica.com/](http://www.saxonica.com/)
+     * **License:** [Mozilla Public License Version 2.0](http://www.mozilla.org/MPL/2.0/)
+
+1.  **Group** : org.antlr. **Name** : antlr4-runtime. **Version** : 4.11.1.
+     * **Project URL:** [https://www.antlr.org/](https://www.antlr.org/)
+     * **License:** [BSD-3-Clause](https://www.antlr.org/license.html)
+
+1.  **Group** : org.apache.httpcomponents.client5. **Name** : httpclient5. **Version** : 5.1.3.
+     * **License:** [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.apache.httpcomponents.core5. **Name** : httpcore5. **Version** : 5.1.3.
+     * **License:** [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.apache.httpcomponents.core5. **Name** : httpcore5-h2. **Version** : 5.1.3.
+     * **License:** [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.apache.logging.log4j. **Name** : log4j-api. **Version** : 2.26.0.
+     * **Project URL:** [https://logging.apache.org/log4j/2.x/](https://logging.apache.org/log4j/2.x/)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.apache.logging.log4j. **Name** : log4j-core. **Version** : 2.26.0.
+     * **Project URL:** [https://logging.apache.org/log4j/2.x/](https://logging.apache.org/log4j/2.x/)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.apiguardian. **Name** : apiguardian-api. **Version** : 1.1.2.
+     * **Project URL:** [https://github.com/apiguardian-team/apiguardian](https://github.com/apiguardian-team/apiguardian)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.checkerframework. **Name** : checker-compat-qual. **Version** : 2.5.3.
+     * **Project URL:** [https://checkerframework.org](https://checkerframework.org)
+     * **License:** [GNU General Public License, version 2 (GPL2), with the classpath exception](http://www.gnu.org/software/classpath/license.html)
+     * **License:** [The MIT License](http://opensource.org/licenses/MIT)
+
+1.  **Group** : org.checkerframework. **Name** : checker-qual. **Version** : 4.2.0.
+     * **Project URL:** [https://checkerframework.org/](https://checkerframework.org/)
+     * **License:** [The MIT License](https://opensource.org/licenses/MIT)
+
+1.  **Group** : org.codehaus.woodstox. **Name** : stax2-api. **Version** : 4.3.0.
+     * **Project URL:** [http://github.com/FasterXML/stax2-api](http://github.com/FasterXML/stax2-api)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+     * **License:** [The BSD 2-Clause License](http://www.opensource.org/licenses/bsd-license.php)
+
+1.  **Group** : org.freemarker. **Name** : freemarker. **Version** : 2.3.32.
+     * **Project URL:** [https://freemarker.apache.org/](https://freemarker.apache.org/)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.hamcrest. **Name** : hamcrest. **Version** : 3.0.
+     * **Project URL:** [http://hamcrest.org/JavaHamcrest/](http://hamcrest.org/JavaHamcrest/)
+     * **License:** [BSD-3-Clause](https://raw.githubusercontent.com/hamcrest/JavaHamcrest/master/LICENSE)
+
+1.  **Group** : org.hamcrest. **Name** : hamcrest-core. **Version** : 3.0.
+     * **Project URL:** [http://hamcrest.org/JavaHamcrest/](http://hamcrest.org/JavaHamcrest/)
+     * **License:** [BSD-3-Clause](https://raw.githubusercontent.com/hamcrest/JavaHamcrest/master/LICENSE)
+
+1.  **Group** : org.jacoco. **Name** : org.jacoco.agent. **Version** : 0.8.15.
+     * **License:** [EPL-2.0](https://www.eclipse.org/legal/epl-2.0/)
+
+1.  **Group** : org.jacoco. **Name** : org.jacoco.core. **Version** : 0.8.15.
+     * **License:** [EPL-2.0](https://www.eclipse.org/legal/epl-2.0/)
+
+1.  **Group** : org.jacoco. **Name** : org.jacoco.report. **Version** : 0.8.15.
+     * **License:** [EPL-2.0](https://www.eclipse.org/legal/epl-2.0/)
+
+1.  **Group** : org.javassist. **Name** : javassist. **Version** : 3.28.0-GA.
+     * **Project URL:** [http://www.javassist.org/](http://www.javassist.org/)
+     * **License:** [Apache License 2.0](http://www.apache.org/licenses/)
+     * **License:** [LGPL 2.1](http://www.gnu.org/licenses/lgpl-2.1.html)
+     * **License:** [MPL 1.1](http://www.mozilla.org/MPL/MPL-1.1.html)
+
+1.  **Group** : org.jcommander. **Name** : jcommander. **Version** : 1.85.
+     * **Project URL:** [https://jcommander.org](https://jcommander.org)
+     * **License:** [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains. **Name** : annotations. **Version** : 23.0.0.
+     * **Project URL:** [https://github.com/JetBrains/java-annotations](https://github.com/JetBrains/java-annotations)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains. **Name** : annotations. **Version** : 26.1.0.
+     * **Project URL:** [https://github.com/JetBrains/java-annotations](https://github.com/JetBrains/java-annotations)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains. **Name** : markdown. **Version** : 0.7.3.
+     * **Project URL:** [https://github.com/JetBrains/markdown](https://github.com/JetBrains/markdown)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains. **Name** : markdown-jvm. **Version** : 0.7.3.
+     * **Project URL:** [https://github.com/JetBrains/markdown](https://github.com/JetBrains/markdown)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.dokka. **Name** : analysis-kotlin-symbols. **Version** : 2.2.0.
+     * **Project URL:** [https://github.com/Kotlin/dokka](https://github.com/Kotlin/dokka)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.dokka. **Name** : analysis-markdown. **Version** : 2.2.0.
+     * **Project URL:** [https://github.com/Kotlin/dokka](https://github.com/Kotlin/dokka)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.dokka. **Name** : dokka-base. **Version** : 2.2.0.
+     * **Project URL:** [https://github.com/Kotlin/dokka](https://github.com/Kotlin/dokka)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.dokka. **Name** : dokka-core. **Version** : 2.2.0.
+     * **Project URL:** [https://github.com/Kotlin/dokka](https://github.com/Kotlin/dokka)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.dokka. **Name** : javadoc-plugin. **Version** : 2.2.0.
+     * **Project URL:** [https://github.com/Kotlin/dokka](https://github.com/Kotlin/dokka)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.dokka. **Name** : kotlin-as-java-plugin. **Version** : 2.2.0.
+     * **Project URL:** [https://github.com/Kotlin/dokka](https://github.com/Kotlin/dokka)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.dokka. **Name** : templating-plugin. **Version** : 2.2.0.
+     * **Project URL:** [https://github.com/Kotlin/dokka](https://github.com/Kotlin/dokka)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.intellij.deps. **Name** : trove4j. **Version** : 1.0.20200330.
+     * **Project URL:** [https://github.com/JetBrains/intellij-deps-trove4j](https://github.com/JetBrains/intellij-deps-trove4j)
+     * **License:** [GNU LESSER GENERAL PUBLIC LICENSE 2.1](https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : abi-tools. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : abi-tools-api. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-bom. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-build-tools-api. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-build-tools-compat. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-build-tools-cri-impl. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-build-tools-impl. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-compiler-embeddable. **Version** : 2.0.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-compiler-embeddable. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-compiler-runner. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-daemon-client. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-daemon-embeddable. **Version** : 2.0.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-daemon-embeddable. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-klib-abi-reader. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-klib-commonizer-embeddable. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-metadata-jvm. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-reflect. **Version** : 2.0.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-reflect. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-script-runtime. **Version** : 2.0.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-script-runtime. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-scripting-common. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-scripting-compiler-embeddable. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-scripting-compiler-impl-embeddable. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-scripting-jvm. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-stdlib. **Version** : 2.0.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-stdlib. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-stdlib-common. **Version** : 2.0.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-stdlib-common. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-stdlib-jdk7. **Version** : 2.0.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-stdlib-jdk7. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-stdlib-jdk8. **Version** : 2.0.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-stdlib-jdk8. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-test. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-test-annotations-common. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-test-common. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-tooling-core. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : atomicfu. **Version** : 0.29.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.atomicfu](https://github.com/Kotlin/kotlinx.atomicfu)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : atomicfu-jvm. **Version** : 0.29.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.atomicfu](https://github.com/Kotlin/kotlinx.atomicfu)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-coroutines-bom. **Version** : 1.10.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.coroutines](https://github.com/Kotlin/kotlinx.coroutines)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-coroutines-core. **Version** : 1.10.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.coroutines](https://github.com/Kotlin/kotlinx.coroutines)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-coroutines-core-jvm. **Version** : 1.10.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.coroutines](https://github.com/Kotlin/kotlinx.coroutines)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-coroutines-core-jvm. **Version** : 1.6.4.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.coroutines](https://github.com/Kotlin/kotlinx.coroutines)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-coroutines-debug. **Version** : 1.10.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.coroutines](https://github.com/Kotlin/kotlinx.coroutines)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-coroutines-jdk8. **Version** : 1.10.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.coroutines](https://github.com/Kotlin/kotlinx.coroutines)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-coroutines-test. **Version** : 1.10.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.coroutines](https://github.com/Kotlin/kotlinx.coroutines)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-coroutines-test-jvm. **Version** : 1.10.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.coroutines](https://github.com/Kotlin/kotlinx.coroutines)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-datetime. **Version** : 0.8.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx-datetime](https://github.com/Kotlin/kotlinx-datetime)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-datetime-jvm. **Version** : 0.8.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx-datetime](https://github.com/Kotlin/kotlinx-datetime)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-html-jvm. **Version** : 0.8.1.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.html](https://github.com/Kotlin/kotlinx.html)
+     * **License:** [The Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-html-jvm. **Version** : 0.9.1.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.html](https://github.com/Kotlin/kotlinx.html)
+     * **License:** [The Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-io-bytestring. **Version** : 0.7.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx-io](https://github.com/Kotlin/kotlinx-io)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-io-bytestring-jvm. **Version** : 0.7.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx-io](https://github.com/Kotlin/kotlinx-io)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-io-core. **Version** : 0.7.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx-io](https://github.com/Kotlin/kotlinx-io)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-io-core-jvm. **Version** : 0.7.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx-io](https://github.com/Kotlin/kotlinx-io)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-serialization-bom. **Version** : 1.9.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.serialization](https://github.com/Kotlin/kotlinx.serialization)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-serialization-core. **Version** : 1.4.1.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.serialization](https://github.com/Kotlin/kotlinx.serialization)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-serialization-core. **Version** : 1.9.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.serialization](https://github.com/Kotlin/kotlinx.serialization)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-serialization-core-jvm. **Version** : 1.4.1.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.serialization](https://github.com/Kotlin/kotlinx.serialization)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-serialization-core-jvm. **Version** : 1.9.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.serialization](https://github.com/Kotlin/kotlinx.serialization)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-serialization-json. **Version** : 1.4.1.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.serialization](https://github.com/Kotlin/kotlinx.serialization)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-serialization-json-jvm. **Version** : 1.4.1.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.serialization](https://github.com/Kotlin/kotlinx.serialization)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jsoup. **Name** : jsoup. **Version** : 1.16.1.
+     * **Project URL:** [https://jsoup.org/](https://jsoup.org/)
+     * **License:** [The MIT License](https://jsoup.org/license)
+
+1.  **Group** : org.jspecify. **Name** : jspecify. **Version** : 1.0.0.
+     * **Project URL:** [http://jspecify.org/](http://jspecify.org/)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.junit. **Name** : junit-bom. **Version** : 6.1.0.
+     * **Project URL:** [https://junit.org/](https://junit.org/)
+     * **License:** [Eclipse Public License v2.0](https://www.eclipse.org/legal/epl-v20.html)
+
+1.  **Group** : org.junit.jupiter. **Name** : junit-jupiter-api. **Version** : 6.1.0.
+     * **Project URL:** [https://junit.org/](https://junit.org/)
+     * **License:** [Eclipse Public License v2.0](https://www.eclipse.org/legal/epl-v20.html)
+
+1.  **Group** : org.junit.jupiter. **Name** : junit-jupiter-engine. **Version** : 6.1.0.
+     * **Project URL:** [https://junit.org/](https://junit.org/)
+     * **License:** [Eclipse Public License v2.0](https://www.eclipse.org/legal/epl-v20.html)
+
+1.  **Group** : org.junit.platform. **Name** : junit-platform-commons. **Version** : 6.1.0.
+     * **Project URL:** [https://junit.org/](https://junit.org/)
+     * **License:** [Eclipse Public License v2.0](https://www.eclipse.org/legal/epl-v20.html)
+
+1.  **Group** : org.junit.platform. **Name** : junit-platform-engine. **Version** : 6.1.0.
+     * **Project URL:** [https://junit.org/](https://junit.org/)
+     * **License:** [Eclipse Public License v2.0](https://www.eclipse.org/legal/epl-v20.html)
+
+1.  **Group** : org.junit.platform. **Name** : junit-platform-launcher. **Version** : 6.1.0.
+     * **Project URL:** [https://junit.org/](https://junit.org/)
+     * **License:** [Eclipse Public License v2.0](https://www.eclipse.org/legal/epl-v20.html)
+
+1.  **Group** : org.junit.platform. **Name** : junit-platform-suite-api. **Version** : 6.1.0.
+     * **Project URL:** [https://junit.org/](https://junit.org/)
+     * **License:** [Eclipse Public License v2.0](https://www.eclipse.org/legal/epl-v20.html)
+
+1.  **Group** : org.opentest4j. **Name** : opentest4j. **Version** : 1.3.0.
+     * **Project URL:** [https://github.com/ota4j-team/opentest4j](https://github.com/ota4j-team/opentest4j)
+     * **License:** [The Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.ow2.asm. **Name** : asm. **Version** : 9.10.1.
+     * **Project URL:** [http://asm.ow2.io/](http://asm.ow2.io/)
+     * **License:** [BSD-3-Clause](https://asm.ow2.io/license.html)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.ow2.asm. **Name** : asm-commons. **Version** : 9.10.1.
+     * **Project URL:** [http://asm.ow2.io/](http://asm.ow2.io/)
+     * **License:** [BSD-3-Clause](https://asm.ow2.io/license.html)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.ow2.asm. **Name** : asm-tree. **Version** : 9.10.1.
+     * **Project URL:** [http://asm.ow2.io/](http://asm.ow2.io/)
+     * **License:** [BSD-3-Clause](https://asm.ow2.io/license.html)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.reflections. **Name** : reflections. **Version** : 0.10.2.
+     * **Project URL:** [http://github.com/ronmamo/reflections](http://github.com/ronmamo/reflections)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+     * **License:** [WTFPL](http://www.wtfpl.net/)
+
+1.  **Group** : org.snakeyaml. **Name** : snakeyaml-engine. **Version** : 2.7.
+     * **Project URL:** [https://bitbucket.org/snakeyaml/snakeyaml-engine](https://bitbucket.org/snakeyaml/snakeyaml-engine)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.xmlresolver. **Name** : xmlresolver. **Version** : 5.1.2.
+     * **Project URL:** [https://github.com/xmlresolver/xmlresolver](https://github.com/xmlresolver/xmlresolver)
+     * **License:** [Apache License version 2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+
+The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
+
+This report was generated on **Sun Jun 28 17:14: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-otel-backend-bootstrap:2.0.0-SNAPSHOT.418`
+
+## Runtime
+1.  **Group** : com.google.auto.service. **Name** : auto-service-annotations. **Version** : 1.1.1.
+     * **Project URL:** [https://github.com/google/auto/tree/main/service](https://github.com/google/auto/tree/main/service)
+     * **License:** [Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2.
+     * **Project URL:** [http://findbugs.sourceforge.net/](http://findbugs.sourceforge.net/)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.code.gson. **Name** : gson. **Version** : 2.14.0.
+     * **Project URL:** [https://github.com/google/gson](https://github.com/google/gson)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.errorprone. **Name** : error_prone_annotations. **Version** : 2.36.0.
+     * **Project URL:** [https://errorprone.info/error_prone_annotations](https://errorprone.info/error_prone_annotations)
+     * **License:** [Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.guava. **Name** : failureaccess. **Version** : 1.0.3.
+     * **Project URL:** [https://github.com/google/guava/](https://github.com/google/guava/)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.guava. **Name** : guava. **Version** : 33.6.0-jre.
+     * **Project URL:** [https://github.com/google/guava](https://github.com/google/guava)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.guava. **Name** : listenablefuture. **Version** : 9999.0-empty-to-avoid-conflict-with-guava.
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.j2objc. **Name** : j2objc-annotations. **Version** : 3.1.
+     * **Project URL:** [https://github.com/google/j2objc/](https://github.com/google/j2objc/)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.protobuf. **Name** : protobuf-java. **Version** : 4.35.0.
+     * **Project URL:** [https://developers.google.com/protocol-buffers/](https://developers.google.com/protocol-buffers/)
+     * **License:** [BSD-3-Clause](https://opensource.org/licenses/BSD-3-Clause)
+
+1.  **Group** : com.google.protobuf. **Name** : protobuf-java-util. **Version** : 4.35.0.
+     * **Project URL:** [https://developers.google.com/protocol-buffers/](https://developers.google.com/protocol-buffers/)
+     * **License:** [BSD-3-Clause](https://opensource.org/licenses/BSD-3-Clause)
+
+1.  **Group** : com.google.protobuf. **Name** : protobuf-kotlin. **Version** : 4.35.0.
+     * **Project URL:** [https://developers.google.com/protocol-buffers/](https://developers.google.com/protocol-buffers/)
+     * **License:** [BSD-3-Clause](https://opensource.org/licenses/BSD-3-Clause)
+
+1.  **Group** : com.squareup.okhttp3. **Name** : okhttp. **Version** : 5.3.2.
+     * **Project URL:** [https://square.github.io/okhttp/](https://square.github.io/okhttp/)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.squareup.okhttp3. **Name** : okhttp-jvm. **Version** : 5.3.2.
+     * **Project URL:** [https://square.github.io/okhttp/](https://square.github.io/okhttp/)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.squareup.okio. **Name** : okio. **Version** : 3.17.0.
+     * **Project URL:** [https://github.com/square/okio/](https://github.com/square/okio/)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.squareup.okio. **Name** : okio-jvm. **Version** : 3.17.0.
+     * **Project URL:** [https://github.com/square/okio/](https://github.com/square/okio/)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.squareup.wire. **Name** : wire-runtime. **Version** : 6.2.0.
+     * **Project URL:** [https://github.com/square/wire/](https://github.com/square/wire/)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : com.squareup.wire. **Name** : wire-runtime-jvm. **Version** : 6.2.0.
+     * **Project URL:** [https://github.com/square/wire/](https://github.com/square/wire/)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.ktor. **Name** : ktor-client-cio. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-client-cio-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-client-content-negotiation. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-client-content-negotiation-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-client-core. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-client-core-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-client-encoding. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-client-encoding-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-client-okhttp. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-client-okhttp-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-events. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-events-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-http. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-http-cio. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-http-cio-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-http-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-io. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-io-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-network. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-network-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-network-tls. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-network-tls-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-serialization. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-serialization-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-sse. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-sse-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-utils. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-utils-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-websocket-serialization. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-websocket-serialization-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-websockets. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-websockets-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : api. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : api-ext. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : api-ext-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : api-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : exporters-core. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : exporters-core-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : exporters-otlp. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : exporters-otlp-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : exporters-protobuf. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : exporters-protobuf-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : implementation. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : implementation-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : model. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : model-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : noop. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : noop-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : platform-implementations. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : platform-implementations-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : sdk-api. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : sdk-api-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : sdk-common. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : sdk-common-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : semconv. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : semconv-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : org.jetbrains. **Name** : annotations. **Version** : 26.1.0.
+     * **Project URL:** [https://github.com/JetBrains/java-annotations](https://github.com/JetBrains/java-annotations)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-bom. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-reflect. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-stdlib. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : atomicfu. **Version** : 0.29.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.atomicfu](https://github.com/Kotlin/kotlinx.atomicfu)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : atomicfu-jvm. **Version** : 0.29.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.atomicfu](https://github.com/Kotlin/kotlinx.atomicfu)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-coroutines-bom. **Version** : 1.10.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.coroutines](https://github.com/Kotlin/kotlinx.coroutines)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-coroutines-core. **Version** : 1.10.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.coroutines](https://github.com/Kotlin/kotlinx.coroutines)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-coroutines-core-jvm. **Version** : 1.10.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.coroutines](https://github.com/Kotlin/kotlinx.coroutines)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-coroutines-slf4j. **Version** : 1.10.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.coroutines](https://github.com/Kotlin/kotlinx.coroutines)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-datetime. **Version** : 0.8.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx-datetime](https://github.com/Kotlin/kotlinx-datetime)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-datetime-jvm. **Version** : 0.8.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx-datetime](https://github.com/Kotlin/kotlinx-datetime)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-io-bytestring. **Version** : 0.8.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx-io](https://github.com/Kotlin/kotlinx-io)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-io-bytestring-jvm. **Version** : 0.8.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx-io](https://github.com/Kotlin/kotlinx-io)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-io-core. **Version** : 0.8.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx-io](https://github.com/Kotlin/kotlinx-io)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-io-core-jvm. **Version** : 0.8.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx-io](https://github.com/Kotlin/kotlinx-io)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-serialization-bom. **Version** : 1.9.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.serialization](https://github.com/Kotlin/kotlinx.serialization)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-serialization-core. **Version** : 1.9.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.serialization](https://github.com/Kotlin/kotlinx.serialization)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-serialization-core-jvm. **Version** : 1.9.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.serialization](https://github.com/Kotlin/kotlinx.serialization)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jspecify. **Name** : jspecify. **Version** : 1.0.0.
+     * **Project URL:** [http://jspecify.org/](http://jspecify.org/)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.slf4j. **Name** : slf4j-api. **Version** : 2.0.18.
+     * **Project URL:** [http://www.slf4j.org](http://www.slf4j.org)
+     * **License:** [MIT](https://opensource.org/license/mit)
+
+## Compile, tests, and tooling
+1.  **Group** : com.fasterxml.jackson. **Name** : jackson-bom. **Version** : 2.22.0.
+     * **Project URL:** [https://github.com/FasterXML/jackson-bom](https://github.com/FasterXML/jackson-bom)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.fasterxml.jackson.core. **Name** : jackson-annotations. **Version** : 2.22.
+     * **Project URL:** [https://github.com/FasterXML/jackson](https://github.com/FasterXML/jackson)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.fasterxml.jackson.core. **Name** : jackson-core. **Version** : 2.22.0.
+     * **Project URL:** [https://github.com/FasterXML/jackson-core](https://github.com/FasterXML/jackson-core)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.fasterxml.jackson.core. **Name** : jackson-databind. **Version** : 2.22.0.
+     * **Project URL:** [https://github.com/FasterXML/jackson](https://github.com/FasterXML/jackson)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.fasterxml.jackson.dataformat. **Name** : jackson-dataformat-xml. **Version** : 2.22.0.
+     * **Project URL:** [https://github.com/FasterXML/jackson-dataformat-xml](https://github.com/FasterXML/jackson-dataformat-xml)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.fasterxml.jackson.module. **Name** : jackson-module-kotlin. **Version** : 2.22.0.
+     * **Project URL:** [https://github.com/FasterXML/jackson-module-kotlin](https://github.com/FasterXML/jackson-module-kotlin)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.fasterxml.woodstox. **Name** : woodstox-core. **Version** : 7.2.0.
+     * **Project URL:** [https://github.com/FasterXML/woodstox](https://github.com/FasterXML/woodstox)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.github.ben-manes.caffeine. **Name** : caffeine. **Version** : 3.0.5.
+     * **Project URL:** [https://github.com/ben-manes/caffeine](https://github.com/ben-manes/caffeine)
+     * **License:** [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.github.kevinstern. **Name** : software-and-algorithms. **Version** : 1.0.
+     * **Project URL:** [https://www.github.com/KevinStern/software-and-algorithms](https://www.github.com/KevinStern/software-and-algorithms)
+     * **License:** [MIT License](http://www.opensource.org/licenses/mit-license.php)
+
+1.  **Group** : com.github.oowekyala.ooxml. **Name** : nice-xml-messages. **Version** : 3.1.
+     * **Project URL:** [https://github.com/oowekyala/nice-xml-messages](https://github.com/oowekyala/nice-xml-messages)
+     * **License:** [MIT License](https://github.com/oowekyala/nice-xml-messages/tree/master/LICENSE)
+
+1.  **Group** : com.google.auto. **Name** : auto-common. **Version** : 1.2.2.
+     * **Project URL:** [https://github.com/google/auto/tree/main/common](https://github.com/google/auto/tree/main/common)
+     * **License:** [Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.auto.service. **Name** : auto-service-annotations. **Version** : 1.1.1.
+     * **Project URL:** [https://github.com/google/auto/tree/main/service](https://github.com/google/auto/tree/main/service)
+     * **License:** [Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.auto.value. **Name** : auto-value-annotations. **Version** : 1.11.1.
+     * **Project URL:** [https://github.com/google/auto/tree/main/value](https://github.com/google/auto/tree/main/value)
+     * **License:** [Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2.
+     * **Project URL:** [http://findbugs.sourceforge.net/](http://findbugs.sourceforge.net/)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.code.gson. **Name** : gson. **Version** : 2.14.0.
+     * **Project URL:** [https://github.com/google/gson](https://github.com/google/gson)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.code.gson. **Name** : gson. **Version** : 2.8.9.
+     * **Project URL:** [https://github.com/google/gson/gson](https://github.com/google/gson/gson)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.errorprone. **Name** : error_prone_annotation. **Version** : 2.36.0.
+     * **Project URL:** [https://errorprone.info/error_prone_annotation](https://errorprone.info/error_prone_annotation)
+     * **License:** [Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.errorprone. **Name** : error_prone_annotations. **Version** : 2.36.0.
+     * **Project URL:** [https://errorprone.info/error_prone_annotations](https://errorprone.info/error_prone_annotations)
+     * **License:** [Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.errorprone. **Name** : error_prone_annotations. **Version** : 2.47.0.
+     * **Project URL:** [https://errorprone.info/error_prone_annotations](https://errorprone.info/error_prone_annotations)
+     * **License:** [Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.errorprone. **Name** : error_prone_check_api. **Version** : 2.36.0.
+     * **Project URL:** [https://errorprone.info/error_prone_check_api](https://errorprone.info/error_prone_check_api)
+     * **License:** [Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.errorprone. **Name** : error_prone_core. **Version** : 2.36.0.
+     * **Project URL:** [https://errorprone.info/error_prone_core](https://errorprone.info/error_prone_core)
+     * **License:** [Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.errorprone. **Name** : error_prone_type_annotations. **Version** : 2.36.0.
+     * **Project URL:** [https://errorprone.info/error_prone_type_annotations](https://errorprone.info/error_prone_type_annotations)
+     * **License:** [Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.flogger. **Name** : flogger. **Version** : 0.7.4.
+     * **Project URL:** [https://github.com/google/flogger](https://github.com/google/flogger)
+     * **License:** [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.flogger. **Name** : flogger-system-backend. **Version** : 0.7.4.
+     * **Project URL:** [https://github.com/google/flogger](https://github.com/google/flogger)
+     * **License:** [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.googlejavaformat. **Name** : google-java-format. **Version** : 1.19.1.
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.guava. **Name** : failureaccess. **Version** : 1.0.3.
+     * **Project URL:** [https://github.com/google/guava/](https://github.com/google/guava/)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.guava. **Name** : guava. **Version** : 33.6.0-jre.
+     * **Project URL:** [https://github.com/google/guava](https://github.com/google/guava)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.guava. **Name** : guava-testlib. **Version** : 33.6.0-jre.
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.guava. **Name** : listenablefuture. **Version** : 9999.0-empty-to-avoid-conflict-with-guava.
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.j2objc. **Name** : j2objc-annotations. **Version** : 3.1.
+     * **Project URL:** [https://github.com/google/j2objc/](https://github.com/google/j2objc/)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.protobuf. **Name** : protobuf-java. **Version** : 4.35.0.
+     * **Project URL:** [https://developers.google.com/protocol-buffers/](https://developers.google.com/protocol-buffers/)
+     * **License:** [BSD-3-Clause](https://opensource.org/licenses/BSD-3-Clause)
+
+1.  **Group** : com.google.protobuf. **Name** : protobuf-java-util. **Version** : 4.35.0.
+     * **Project URL:** [https://developers.google.com/protocol-buffers/](https://developers.google.com/protocol-buffers/)
+     * **License:** [BSD-3-Clause](https://opensource.org/licenses/BSD-3-Clause)
+
+1.  **Group** : com.google.protobuf. **Name** : protobuf-kotlin. **Version** : 4.35.0.
+     * **Project URL:** [https://developers.google.com/protocol-buffers/](https://developers.google.com/protocol-buffers/)
+     * **License:** [BSD-3-Clause](https://opensource.org/licenses/BSD-3-Clause)
+
+1.  **Group** : com.google.truth. **Name** : truth. **Version** : 1.4.5.
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.truth.extensions. **Name** : truth-java8-extension. **Version** : 1.4.5.
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.truth.extensions. **Name** : truth-liteproto-extension. **Version** : 1.4.5.
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.google.truth.extensions. **Name** : truth-proto-extension. **Version** : 1.4.5.
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.puppycrawl.tools. **Name** : checkstyle. **Version** : 10.12.1.
+     * **Project URL:** [https://checkstyle.org/](https://checkstyle.org/)
+     * **License:** [LGPL-2.1+](http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt)
+
+1.  **Group** : com.soywiz.korlibs.korte. **Name** : korte-jvm. **Version** : 4.0.10.
+     * **Project URL:** [https://github.com/korlibs/korge-next](https://github.com/korlibs/korge-next)
+     * **License:** [MIT](https://raw.githubusercontent.com/korlibs/korge-next/master/korge/LICENSE.txt)
+
+1.  **Group** : com.squareup.okhttp3. **Name** : okhttp. **Version** : 5.3.2.
+     * **Project URL:** [https://square.github.io/okhttp/](https://square.github.io/okhttp/)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.squareup.okhttp3. **Name** : okhttp-jvm. **Version** : 5.3.2.
+     * **Project URL:** [https://square.github.io/okhttp/](https://square.github.io/okhttp/)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.squareup.okio. **Name** : okio. **Version** : 3.17.0.
+     * **Project URL:** [https://github.com/square/okio/](https://github.com/square/okio/)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.squareup.okio. **Name** : okio-jvm. **Version** : 3.17.0.
+     * **Project URL:** [https://github.com/square/okio/](https://github.com/square/okio/)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : com.squareup.wire. **Name** : wire-runtime. **Version** : 6.2.0.
+     * **Project URL:** [https://github.com/square/wire/](https://github.com/square/wire/)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : com.squareup.wire. **Name** : wire-runtime-jvm. **Version** : 6.2.0.
+     * **Project URL:** [https://github.com/square/wire/](https://github.com/square/wire/)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : commons-beanutils. **Name** : commons-beanutils. **Version** : 1.9.4.
+     * **Project URL:** [https://commons.apache.org/proper/commons-beanutils/](https://commons.apache.org/proper/commons-beanutils/)
+     * **License:** [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : commons-codec. **Name** : commons-codec. **Version** : 1.22.0.
+     * **Project URL:** [https://commons.apache.org/proper/commons-codec/](https://commons.apache.org/proper/commons-codec/)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : commons-collections. **Name** : commons-collections. **Version** : 3.2.2.
+     * **Project URL:** [http://commons.apache.org/collections/](http://commons.apache.org/collections/)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : dev.drewhamilton.poko. **Name** : poko-annotations. **Version** : 0.17.1.
+     * **Project URL:** [https://github.com/drewhamilton/Poko](https://github.com/drewhamilton/Poko)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : dev.drewhamilton.poko. **Name** : poko-annotations-jvm. **Version** : 0.17.1.
+     * **Project URL:** [https://github.com/drewhamilton/Poko](https://github.com/drewhamilton/Poko)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : info.picocli. **Name** : picocli. **Version** : 4.7.4.
+     * **Project URL:** [https://picocli.info](https://picocli.info)
+     * **License:** [The Apache Software License, version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.github.davidburstrom.contester. **Name** : contester-breakpoint. **Version** : 0.2.0.
+     * **Project URL:** [https://github.com/davidburstrom/contester](https://github.com/davidburstrom/contester)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.github.detekt.sarif4k. **Name** : sarif4k. **Version** : 0.6.0.
+     * **Project URL:** [https://detekt.github.io/detekt](https://detekt.github.io/detekt)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.github.detekt.sarif4k. **Name** : sarif4k-jvm. **Version** : 0.6.0.
+     * **Project URL:** [https://detekt.github.io/detekt](https://detekt.github.io/detekt)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.github.eisop. **Name** : dataflow-errorprone. **Version** : 3.41.0-eisop1.
+     * **Project URL:** [https://eisop.github.io/](https://eisop.github.io/)
+     * **License:** [GNU General Public License, version 2 (GPL2), with the classpath exception](http://www.gnu.org/software/classpath/license.html)
+
+1.  **Group** : io.github.java-diff-utils. **Name** : java-diff-utils. **Version** : 4.17.
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-api. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-cli. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-core. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-metrics. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-parser. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-psi-utils. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-report-html. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-report-md. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-report-sarif. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-report-txt. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-report-xml. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-rules. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-rules-complexity. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-rules-coroutines. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-rules-documentation. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-rules-empty. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-rules-errorprone. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-rules-exceptions. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-rules-naming. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-rules-performance. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-rules-style. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-tooling. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.gitlab.arturbosch.detekt. **Name** : detekt-utils. **Version** : 1.23.8.
+     * **Project URL:** [https://detekt.dev](https://detekt.dev)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.kotest. **Name** : kotest-assertions-core. **Version** : 6.1.11.
+     * **Project URL:** [https://github.com/kotest/kotest](https://github.com/kotest/kotest)
+     * **License:** [Apache-2.0](https://opensource.org/licenses/Apache-2.0)
+
+1.  **Group** : io.kotest. **Name** : kotest-assertions-core-jvm. **Version** : 6.1.11.
+     * **Project URL:** [https://github.com/kotest/kotest](https://github.com/kotest/kotest)
+     * **License:** [Apache-2.0](https://opensource.org/licenses/Apache-2.0)
+
+1.  **Group** : io.kotest. **Name** : kotest-assertions-shared. **Version** : 6.1.11.
+     * **Project URL:** [https://github.com/kotest/kotest](https://github.com/kotest/kotest)
+     * **License:** [Apache-2.0](https://opensource.org/licenses/Apache-2.0)
+
+1.  **Group** : io.kotest. **Name** : kotest-assertions-shared-jvm. **Version** : 6.1.11.
+     * **Project URL:** [https://github.com/kotest/kotest](https://github.com/kotest/kotest)
+     * **License:** [Apache-2.0](https://opensource.org/licenses/Apache-2.0)
+
+1.  **Group** : io.kotest. **Name** : kotest-common. **Version** : 6.1.11.
+     * **Project URL:** [https://github.com/kotest/kotest](https://github.com/kotest/kotest)
+     * **License:** [Apache-2.0](https://opensource.org/licenses/Apache-2.0)
+
+1.  **Group** : io.kotest. **Name** : kotest-common-jvm. **Version** : 6.1.11.
+     * **Project URL:** [https://github.com/kotest/kotest](https://github.com/kotest/kotest)
+     * **License:** [Apache-2.0](https://opensource.org/licenses/Apache-2.0)
+
+1.  **Group** : io.ktor. **Name** : ktor-client-cio. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-client-cio-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-client-content-negotiation. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-client-content-negotiation-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-client-core. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-client-core-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-client-encoding. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-client-encoding-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-client-okhttp. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-client-okhttp-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-events. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-events-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-http. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-http-cio. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-http-cio-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-http-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-io. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-io-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-network. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-network-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-network-tls. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-network-tls-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-serialization. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-serialization-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-sse. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-sse-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-utils. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-utils-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-websocket-serialization. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-websocket-serialization-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-websockets. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.ktor. **Name** : ktor-websockets-jvm. **Version** : 3.4.2.
+     * **Project URL:** [https://github.com/ktorio/ktor](https://github.com/ktorio/ktor)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : api. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : api-ext. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : api-ext-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : api-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : exporters-core. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : exporters-core-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : exporters-otlp. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : exporters-otlp-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : exporters-protobuf. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : exporters-protobuf-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : implementation. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : implementation-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : model. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : model-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : noop. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : noop-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : platform-implementations. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : platform-implementations-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : sdk-api. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : sdk-api-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : sdk-common. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : sdk-common-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : semconv. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : io.opentelemetry.kotlin. **Name** : semconv-jvm. **Version** : 0.4.0.
+     * **Project URL:** [https://github.com/open-telemetry/opentelemetry-kotlin](https://github.com/open-telemetry/opentelemetry-kotlin)
+     * **License:** [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : javax.inject. **Name** : javax.inject. **Version** : 1.
+     * **Project URL:** [http://code.google.com/p/atinject/](http://code.google.com/p/atinject/)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : junit. **Name** : junit. **Version** : 4.13.2.
+     * **Project URL:** [http://junit.org](http://junit.org)
+     * **License:** [Eclipse Public License 1.0](http://www.eclipse.org/legal/epl-v10.html)
+
+1.  **Group** : net.sf.saxon. **Name** : Saxon-HE. **Version** : 12.2.
+     * **Project URL:** [http://www.saxonica.com/](http://www.saxonica.com/)
+     * **License:** [Mozilla Public License Version 2.0](http://www.mozilla.org/MPL/2.0/)
+
+1.  **Group** : net.sf.saxon. **Name** : Saxon-HE. **Version** : 12.9.
+     * **Project URL:** [http://www.saxonica.com/](http://www.saxonica.com/)
+     * **License:** [Mozilla Public License Version 2.0](http://www.mozilla.org/MPL/2.0/)
+
+1.  **Group** : net.sourceforge.pmd. **Name** : pmd-ant. **Version** : 7.25.0.
+     * **License:** [BSD-style](http://pmd.sourceforge.net/license.html)
+
+1.  **Group** : net.sourceforge.pmd. **Name** : pmd-core. **Version** : 7.25.0.
+     * **License:** [BSD-style](http://pmd.sourceforge.net/license.html)
+
+1.  **Group** : net.sourceforge.pmd. **Name** : pmd-java. **Version** : 7.25.0.
+     * **License:** [BSD-style](http://pmd.sourceforge.net/license.html)
+
+1.  **Group** : org.antlr. **Name** : antlr4-runtime. **Version** : 4.11.1.
+     * **Project URL:** [https://www.antlr.org/](https://www.antlr.org/)
+     * **License:** [BSD-3-Clause](https://www.antlr.org/license.html)
+
+1.  **Group** : org.antlr. **Name** : antlr4-runtime. **Version** : 4.13.2.
+     * **Project URL:** [https://www.antlr.org/](https://www.antlr.org/)
+     * **License:** [BSD-3-Clause](https://www.antlr.org/license.html)
+
+1.  **Group** : org.apache.commons. **Name** : commons-lang3. **Version** : 3.20.0.
+     * **Project URL:** [https://commons.apache.org/proper/commons-lang/](https://commons.apache.org/proper/commons-lang/)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.apache.httpcomponents.client5. **Name** : httpclient5. **Version** : 5.1.3.
+     * **License:** [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.apache.httpcomponents.core5. **Name** : httpcore5. **Version** : 5.1.3.
+     * **License:** [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.apache.httpcomponents.core5. **Name** : httpcore5-h2. **Version** : 5.1.3.
+     * **License:** [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.apiguardian. **Name** : apiguardian-api. **Version** : 1.1.2.
+     * **Project URL:** [https://github.com/apiguardian-team/apiguardian](https://github.com/apiguardian-team/apiguardian)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.checkerframework. **Name** : checker-compat-qual. **Version** : 2.5.3.
+     * **Project URL:** [https://checkerframework.org](https://checkerframework.org)
+     * **License:** [GNU General Public License, version 2 (GPL2), with the classpath exception](http://www.gnu.org/software/classpath/license.html)
+     * **License:** [The MIT License](http://opensource.org/licenses/MIT)
+
+1.  **Group** : org.checkerframework. **Name** : checker-qual. **Version** : 4.2.0.
+     * **Project URL:** [https://checkerframework.org/](https://checkerframework.org/)
+     * **License:** [The MIT License](https://opensource.org/licenses/MIT)
+
+1.  **Group** : org.codehaus.woodstox. **Name** : stax2-api. **Version** : 4.3.0.
+     * **Project URL:** [http://github.com/FasterXML/stax2-api](http://github.com/FasterXML/stax2-api)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+     * **License:** [The BSD 2-Clause License](http://www.opensource.org/licenses/bsd-license.php)
+
+1.  **Group** : org.freemarker. **Name** : freemarker. **Version** : 2.3.32.
+     * **Project URL:** [https://freemarker.apache.org/](https://freemarker.apache.org/)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.hamcrest. **Name** : hamcrest. **Version** : 3.0.
+     * **Project URL:** [http://hamcrest.org/JavaHamcrest/](http://hamcrest.org/JavaHamcrest/)
+     * **License:** [BSD-3-Clause](https://raw.githubusercontent.com/hamcrest/JavaHamcrest/master/LICENSE)
+
+1.  **Group** : org.hamcrest. **Name** : hamcrest-core. **Version** : 3.0.
+     * **Project URL:** [http://hamcrest.org/JavaHamcrest/](http://hamcrest.org/JavaHamcrest/)
+     * **License:** [BSD-3-Clause](https://raw.githubusercontent.com/hamcrest/JavaHamcrest/master/LICENSE)
+
+1.  **Group** : org.jacoco. **Name** : org.jacoco.agent. **Version** : 0.8.15.
+     * **License:** [EPL-2.0](https://www.eclipse.org/legal/epl-2.0/)
+
+1.  **Group** : org.jacoco. **Name** : org.jacoco.core. **Version** : 0.8.15.
+     * **License:** [EPL-2.0](https://www.eclipse.org/legal/epl-2.0/)
+
+1.  **Group** : org.jacoco. **Name** : org.jacoco.report. **Version** : 0.8.15.
+     * **License:** [EPL-2.0](https://www.eclipse.org/legal/epl-2.0/)
+
+1.  **Group** : org.javassist. **Name** : javassist. **Version** : 3.28.0-GA.
+     * **Project URL:** [http://www.javassist.org/](http://www.javassist.org/)
+     * **License:** [Apache License 2.0](http://www.apache.org/licenses/)
+     * **License:** [LGPL 2.1](http://www.gnu.org/licenses/lgpl-2.1.html)
+     * **License:** [MPL 1.1](http://www.mozilla.org/MPL/MPL-1.1.html)
+
+1.  **Group** : org.jcommander. **Name** : jcommander. **Version** : 1.85.
+     * **Project URL:** [https://jcommander.org](https://jcommander.org)
+     * **License:** [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains. **Name** : annotations. **Version** : 23.0.0.
+     * **Project URL:** [https://github.com/JetBrains/java-annotations](https://github.com/JetBrains/java-annotations)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains. **Name** : annotations. **Version** : 26.1.0.
+     * **Project URL:** [https://github.com/JetBrains/java-annotations](https://github.com/JetBrains/java-annotations)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains. **Name** : markdown. **Version** : 0.7.3.
+     * **Project URL:** [https://github.com/JetBrains/markdown](https://github.com/JetBrains/markdown)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains. **Name** : markdown-jvm. **Version** : 0.7.3.
+     * **Project URL:** [https://github.com/JetBrains/markdown](https://github.com/JetBrains/markdown)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.dokka. **Name** : analysis-kotlin-symbols. **Version** : 2.2.0.
+     * **Project URL:** [https://github.com/Kotlin/dokka](https://github.com/Kotlin/dokka)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.dokka. **Name** : analysis-markdown. **Version** : 2.2.0.
+     * **Project URL:** [https://github.com/Kotlin/dokka](https://github.com/Kotlin/dokka)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.dokka. **Name** : dokka-base. **Version** : 2.2.0.
+     * **Project URL:** [https://github.com/Kotlin/dokka](https://github.com/Kotlin/dokka)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.dokka. **Name** : dokka-core. **Version** : 2.2.0.
+     * **Project URL:** [https://github.com/Kotlin/dokka](https://github.com/Kotlin/dokka)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.dokka. **Name** : javadoc-plugin. **Version** : 2.2.0.
+     * **Project URL:** [https://github.com/Kotlin/dokka](https://github.com/Kotlin/dokka)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.dokka. **Name** : kotlin-as-java-plugin. **Version** : 2.2.0.
+     * **Project URL:** [https://github.com/Kotlin/dokka](https://github.com/Kotlin/dokka)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.dokka. **Name** : templating-plugin. **Version** : 2.2.0.
+     * **Project URL:** [https://github.com/Kotlin/dokka](https://github.com/Kotlin/dokka)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.intellij.deps. **Name** : trove4j. **Version** : 1.0.20200330.
+     * **Project URL:** [https://github.com/JetBrains/intellij-deps-trove4j](https://github.com/JetBrains/intellij-deps-trove4j)
+     * **License:** [GNU LESSER GENERAL PUBLIC LICENSE 2.1](https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : abi-tools. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : abi-tools-api. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-bom. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-build-tools-api. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-build-tools-compat. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-build-tools-cri-impl. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-build-tools-impl. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-compiler-embeddable. **Version** : 2.0.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-compiler-embeddable. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-compiler-runner. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-daemon-client. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-daemon-embeddable. **Version** : 2.0.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-daemon-embeddable. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-klib-abi-reader. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-klib-commonizer-embeddable. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-metadata-jvm. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-reflect. **Version** : 2.0.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-reflect. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-script-runtime. **Version** : 2.0.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-script-runtime. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-scripting-common. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-scripting-compiler-embeddable. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-scripting-compiler-impl-embeddable. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-scripting-jvm. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-stdlib. **Version** : 2.0.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-stdlib. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-stdlib-common. **Version** : 2.0.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-stdlib-common. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-stdlib-jdk7. **Version** : 2.0.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-stdlib-jdk7. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-stdlib-jdk8. **Version** : 2.0.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-stdlib-jdk8. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlin. **Name** : kotlin-tooling-core. **Version** : 2.3.21.
+     * **Project URL:** [https://kotlinlang.org/](https://kotlinlang.org/)
+     * **License:** [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : atomicfu. **Version** : 0.29.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.atomicfu](https://github.com/Kotlin/kotlinx.atomicfu)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : atomicfu-jvm. **Version** : 0.29.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.atomicfu](https://github.com/Kotlin/kotlinx.atomicfu)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-coroutines-bom. **Version** : 1.10.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.coroutines](https://github.com/Kotlin/kotlinx.coroutines)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-coroutines-core. **Version** : 1.10.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.coroutines](https://github.com/Kotlin/kotlinx.coroutines)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-coroutines-core-jvm. **Version** : 1.10.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.coroutines](https://github.com/Kotlin/kotlinx.coroutines)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-coroutines-core-jvm. **Version** : 1.6.4.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.coroutines](https://github.com/Kotlin/kotlinx.coroutines)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-coroutines-jdk8. **Version** : 1.10.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.coroutines](https://github.com/Kotlin/kotlinx.coroutines)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-coroutines-slf4j. **Version** : 1.10.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.coroutines](https://github.com/Kotlin/kotlinx.coroutines)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-coroutines-test. **Version** : 1.10.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.coroutines](https://github.com/Kotlin/kotlinx.coroutines)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-coroutines-test-jvm. **Version** : 1.10.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.coroutines](https://github.com/Kotlin/kotlinx.coroutines)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-datetime. **Version** : 0.8.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx-datetime](https://github.com/Kotlin/kotlinx-datetime)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-datetime-jvm. **Version** : 0.8.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx-datetime](https://github.com/Kotlin/kotlinx-datetime)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-html-jvm. **Version** : 0.8.1.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.html](https://github.com/Kotlin/kotlinx.html)
+     * **License:** [The Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-html-jvm. **Version** : 0.9.1.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.html](https://github.com/Kotlin/kotlinx.html)
+     * **License:** [The Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-io-bytestring. **Version** : 0.8.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx-io](https://github.com/Kotlin/kotlinx-io)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-io-bytestring-jvm. **Version** : 0.8.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx-io](https://github.com/Kotlin/kotlinx-io)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-io-core. **Version** : 0.8.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx-io](https://github.com/Kotlin/kotlinx-io)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-io-core-jvm. **Version** : 0.8.2.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx-io](https://github.com/Kotlin/kotlinx-io)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-serialization-bom. **Version** : 1.9.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.serialization](https://github.com/Kotlin/kotlinx.serialization)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-serialization-core. **Version** : 1.4.1.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.serialization](https://github.com/Kotlin/kotlinx.serialization)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-serialization-core. **Version** : 1.9.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.serialization](https://github.com/Kotlin/kotlinx.serialization)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-serialization-core-jvm. **Version** : 1.4.1.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.serialization](https://github.com/Kotlin/kotlinx.serialization)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-serialization-core-jvm. **Version** : 1.9.0.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.serialization](https://github.com/Kotlin/kotlinx.serialization)
+     * **License:** [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-serialization-json. **Version** : 1.4.1.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.serialization](https://github.com/Kotlin/kotlinx.serialization)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jetbrains.kotlinx. **Name** : kotlinx-serialization-json-jvm. **Version** : 1.4.1.
+     * **Project URL:** [https://github.com/Kotlin/kotlinx.serialization](https://github.com/Kotlin/kotlinx.serialization)
+     * **License:** [The Apache Software License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.jsoup. **Name** : jsoup. **Version** : 1.16.1.
+     * **Project URL:** [https://jsoup.org/](https://jsoup.org/)
+     * **License:** [The MIT License](https://jsoup.org/license)
+
+1.  **Group** : org.jspecify. **Name** : jspecify. **Version** : 1.0.0.
+     * **Project URL:** [http://jspecify.org/](http://jspecify.org/)
+     * **License:** [The Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.junit. **Name** : junit-bom. **Version** : 6.1.0.
+     * **Project URL:** [https://junit.org/](https://junit.org/)
+     * **License:** [Eclipse Public License v2.0](https://www.eclipse.org/legal/epl-v20.html)
+
+1.  **Group** : org.junit-pioneer. **Name** : junit-pioneer. **Version** : 2.3.0.
+     * **Project URL:** [https://junit-pioneer.org/](https://junit-pioneer.org/)
+     * **License:** [Eclipse Public License v2.0](https://www.eclipse.org/legal/epl-v20.html)
+
+1.  **Group** : org.junit.jupiter. **Name** : junit-jupiter-api. **Version** : 6.1.0.
+     * **Project URL:** [https://junit.org/](https://junit.org/)
+     * **License:** [Eclipse Public License v2.0](https://www.eclipse.org/legal/epl-v20.html)
+
+1.  **Group** : org.junit.jupiter. **Name** : junit-jupiter-engine. **Version** : 6.1.0.
+     * **Project URL:** [https://junit.org/](https://junit.org/)
+     * **License:** [Eclipse Public License v2.0](https://www.eclipse.org/legal/epl-v20.html)
+
+1.  **Group** : org.junit.jupiter. **Name** : junit-jupiter-params. **Version** : 6.1.0.
+     * **Project URL:** [https://junit.org/](https://junit.org/)
+     * **License:** [Eclipse Public License v2.0](https://www.eclipse.org/legal/epl-v20.html)
+
+1.  **Group** : org.junit.platform. **Name** : junit-platform-commons. **Version** : 6.1.0.
+     * **Project URL:** [https://junit.org/](https://junit.org/)
+     * **License:** [Eclipse Public License v2.0](https://www.eclipse.org/legal/epl-v20.html)
+
+1.  **Group** : org.junit.platform. **Name** : junit-platform-engine. **Version** : 6.1.0.
+     * **Project URL:** [https://junit.org/](https://junit.org/)
+     * **License:** [Eclipse Public License v2.0](https://www.eclipse.org/legal/epl-v20.html)
+
+1.  **Group** : org.junit.platform. **Name** : junit-platform-launcher. **Version** : 6.1.0.
+     * **Project URL:** [https://junit.org/](https://junit.org/)
+     * **License:** [Eclipse Public License v2.0](https://www.eclipse.org/legal/epl-v20.html)
+
+1.  **Group** : org.opentest4j. **Name** : opentest4j. **Version** : 1.3.0.
+     * **Project URL:** [https://github.com/ota4j-team/opentest4j](https://github.com/ota4j-team/opentest4j)
+     * **License:** [The Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.ow2.asm. **Name** : asm. **Version** : 9.10.1.
+     * **Project URL:** [http://asm.ow2.io/](http://asm.ow2.io/)
+     * **License:** [BSD-3-Clause](https://asm.ow2.io/license.html)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.ow2.asm. **Name** : asm-commons. **Version** : 9.10.1.
+     * **Project URL:** [http://asm.ow2.io/](http://asm.ow2.io/)
+     * **License:** [BSD-3-Clause](https://asm.ow2.io/license.html)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.ow2.asm. **Name** : asm-tree. **Version** : 9.10.1.
+     * **Project URL:** [http://asm.ow2.io/](http://asm.ow2.io/)
+     * **License:** [BSD-3-Clause](https://asm.ow2.io/license.html)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.pcollections. **Name** : pcollections. **Version** : 4.0.1.
+     * **Project URL:** [https://github.com/hrldcpr/pcollections](https://github.com/hrldcpr/pcollections)
+     * **License:** [The MIT License](https://opensource.org/licenses/mit-license.php)
+
+1.  **Group** : org.pcollections. **Name** : pcollections. **Version** : 4.0.2.
+     * **Project URL:** [https://github.com/hrldcpr/pcollections](https://github.com/hrldcpr/pcollections)
+     * **License:** [The MIT License](https://opensource.org/licenses/mit-license.php)
+
+1.  **Group** : org.reflections. **Name** : reflections. **Version** : 0.10.2.
+     * **Project URL:** [http://github.com/ronmamo/reflections](http://github.com/ronmamo/reflections)
+     * **License:** [The Apache Software License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+     * **License:** [WTFPL](http://www.wtfpl.net/)
+
+1.  **Group** : org.slf4j. **Name** : jul-to-slf4j. **Version** : 1.7.36.
+     * **Project URL:** [http://www.slf4j.org](http://www.slf4j.org)
+     * **License:** [MIT License](http://www.opensource.org/licenses/mit-license.php)
+
+1.  **Group** : org.slf4j. **Name** : slf4j-api. **Version** : 2.0.18.
+     * **Project URL:** [http://www.slf4j.org](http://www.slf4j.org)
+     * **License:** [MIT](https://opensource.org/license/mit)
+
+1.  **Group** : org.snakeyaml. **Name** : snakeyaml-engine. **Version** : 2.7.
+     * **Project URL:** [https://bitbucket.org/snakeyaml/snakeyaml-engine](https://bitbucket.org/snakeyaml/snakeyaml-engine)
+     * **License:** [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+1.  **Group** : org.xmlresolver. **Name** : xmlresolver. **Version** : 5.1.2.
+     * **Project URL:** [https://github.com/xmlresolver/xmlresolver](https://github.com/xmlresolver/xmlresolver)
+     * **License:** [Apache License version 2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+1.  **Group** : org.xmlresolver. **Name** : xmlresolver. **Version** : 5.3.3.
+     * **Project URL:** [https://github.com/xmlresolver/xmlresolver](https://github.com/xmlresolver/xmlresolver)
+     * **License:** [Apache License version 2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+
+The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
+
+This report was generated on **Sun Jun 28 17:14: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).
 
@@ -11690,7 +14015,7 @@ This report was generated on **Sun Jun 28 17:55:26 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:55:25 WEST 2026** using 
+This report was generated on **Sun Jun 28 17:14: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).
 
@@ -12596,7 +14921,7 @@ This report was generated on **Sun Jun 28 17:55:25 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:55:25 WEST 2026** using 
+This report was generated on **Sun Jun 28 17:14: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).
 
@@ -13434,6 +15759,6 @@ This report was generated on **Sun Jun 28 17:55:25 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:55:25 WEST 2026** using 
+This report was generated on **Sun Jun 28 17:14: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 abf0e941..a718e096 100644
--- a/docs/dependencies/pom.xml
+++ b/docs/dependencies/pom.xml
@@ -9,7 +9,7 @@ all modules and does not describe the project structure per-subproject.
  
  -->
 <groupId>io.spine</groupId>
-<artifactId>logging</artifactId>
+<artifactId>spine-logging</artifactId>
 <version>2.0.0-SNAPSHOT.418</version>
 
 <inceptionYear>2015</inceptionYear>

From da16ff7cdbcafa1d60650e33e23485d29fba7836 Mon Sep 17 00:00:00 2001
From: Alexander Yevsyukov <alexander.yevsyukov@teamdev.com>
Date: Sun, 28 Jun 2026 19:59:37 +0100
Subject: [PATCH 11/20] Avoid `spine-` prefix in the root project name

---
 settings.gradle.kts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/settings.gradle.kts b/settings.gradle.kts
index c5c74689..3edcaa82 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -31,7 +31,7 @@ pluginManagement {
     }
 }
 
-rootProject.name = "spine-logging"
+rootProject.name = "logging"
 
 include(
     "logging",

From 864efc2010d4b3f27d0a3faa929fd1d99a626e33 Mon Sep 17 00:00:00 2001
From: Alexander Yevsyukov <alexander.yevsyukov@teamdev.com>
Date: Sun, 28 Jun 2026 20:04:54 +0100
Subject: [PATCH 12/20] Harden OTLP bootstrap and centralize the logger-name
 convention

otel-backend-bootstrap:
- Document DEFAULT_OTLP_HTTP_ENDPOINT as the OpenTelemetry-standard port and its
  override paths; resolve the endpoint through a testable endpointFromEnvironment().
- Build the lifecycle test against a free ephemeral port instead of 4318 so it
  cannot collide with a real collector or a parallel suite; verify default
  resolution as pure logic.
- Report a failed shutdown() (OperationResultCode.Failure) via JUL instead of
  discarding it silently.

backends:
- Add BackendFactory.loggerName() as the single home for the `$`-to-`.` logger-name
  convention and adopt it in the JUL, Log4j2, and OTel factories. JUL now derives
  the name in its factory; the backend no longer re-converts.
- Fix stale KDoc: "Spine Logging backends", and drop the spine.* attribute mention
  removed in 4e467c5b.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../logging/backend/jul/AbstractJulBackend.kt |  9 ++--
 .../spine/logging/backend/jul/JulBackend.kt   |  8 ++--
 .../logging/backend/jul/JulBackendFactory.kt  |  3 +-
 .../backend/log4j2/Log4j2BackendFactory.kt    |  3 +-
 .../backend/otel/bootstrap/OtelLogging.kt     | 42 ++++++++++++++++---
 .../backend/otel/bootstrap/OtelLoggingSpec.kt | 34 +++++++--------
 .../spine/logging/backend/otel/OtelEvents.kt  |  2 +-
 .../backend/otel/OtelBackendFactory.kt        |  7 ++--
 .../spine/logging/backend/BackendFactory.kt   | 14 ++++++-
 9 files changed, 81 insertions(+), 41 deletions(-)

diff --git a/backends/jul-backend/src/main/kotlin/io/spine/logging/backend/jul/AbstractJulBackend.kt b/backends/jul-backend/src/main/kotlin/io/spine/logging/backend/jul/AbstractJulBackend.kt
index e57b22f2..23bb3e78 100644
--- a/backends/jul-backend/src/main/kotlin/io/spine/logging/backend/jul/AbstractJulBackend.kt
+++ b/backends/jul-backend/src/main/kotlin/io/spine/logging/backend/jul/AbstractJulBackend.kt
@@ -53,13 +53,14 @@ public abstract class AbstractJulBackend : LoggerBackend {
     }
 
     /**
-     * Constructs an abstract backend for the given class name.
+     * Constructs an abstract backend for the logger named [loggingClass].
      *
-     * Nested or inner class names (containing '$') are converted to names matching the
-     * standard JDK logger namespace by converting '$' to '.'.
+     * The name is used as given: callers pass a logger name already derived from the
+     * logging class through the shared `BackendFactory.loggerName` convention
+     * (`$` replaced by `.`).
      */
     protected constructor(loggingClass: String) : this(
-        Logger.getLogger(loggingClass.replace('$', '.'))
+        Logger.getLogger(loggingClass)
     )
 
     public override val loggerName: String?
diff --git a/backends/jul-backend/src/main/kotlin/io/spine/logging/backend/jul/JulBackend.kt b/backends/jul-backend/src/main/kotlin/io/spine/logging/backend/jul/JulBackend.kt
index f9a777d9..4c63185c 100644
--- a/backends/jul-backend/src/main/kotlin/io/spine/logging/backend/jul/JulBackend.kt
+++ b/backends/jul-backend/src/main/kotlin/io/spine/logging/backend/jul/JulBackend.kt
@@ -44,11 +44,9 @@ import java.util.logging.Logger
  *
  * It allows forced publishing of logging records.
  *
- * @param loggingClass A name of the logger created for this backend.
- *        A better name for the parameter would be `loggerName`, but we keep the naming
- *        consistent with the API we extend. Please also see the constructor
- *        of `AbstractBackend` which accepts `String` for the operation with
- *        the given class name.
+ * @param loggingClass The name of the logger created for this backend, already derived
+ *        from the logging class by [JulBackendFactory]. A better name for the parameter
+ *        would be `loggerName`, but we keep it consistent with the API we extend.
  * @see AbstractJulBackend
  */
 internal class JulBackend(loggingClass: String): AbstractJulBackend(loggingClass) {
diff --git a/backends/jul-backend/src/main/kotlin/io/spine/logging/backend/jul/JulBackendFactory.kt b/backends/jul-backend/src/main/kotlin/io/spine/logging/backend/jul/JulBackendFactory.kt
index 549edad7..3e8ca7fb 100644
--- a/backends/jul-backend/src/main/kotlin/io/spine/logging/backend/jul/JulBackendFactory.kt
+++ b/backends/jul-backend/src/main/kotlin/io/spine/logging/backend/jul/JulBackendFactory.kt
@@ -35,7 +35,8 @@ import io.spine.logging.backend.LoggerBackend
  */
 public class JulBackendFactory: BackendFactory() {
 
-    public override fun create(loggingClass: String): LoggerBackend = JulBackend(loggingClass)
+    public override fun create(loggingClass: String): LoggerBackend =
+        JulBackend(loggerName(loggingClass))
 
     /**
      * Returns a fully-qualified name of this class.
diff --git a/backends/log4j2-backend/src/main/kotlin/io/spine/logging/backend/log4j2/Log4j2BackendFactory.kt b/backends/log4j2-backend/src/main/kotlin/io/spine/logging/backend/log4j2/Log4j2BackendFactory.kt
index b4b35f60..227ac235 100644
--- a/backends/log4j2-backend/src/main/kotlin/io/spine/logging/backend/log4j2/Log4j2BackendFactory.kt
+++ b/backends/log4j2-backend/src/main/kotlin/io/spine/logging/backend/log4j2/Log4j2BackendFactory.kt
@@ -45,8 +45,7 @@ import org.apache.logging.log4j.core.Logger
 public class Log4j2BackendFactory : BackendFactory() {
 
     override fun create(loggingClass: String): LoggerBackend {
-        // Compute the logger name the same way as in SimpleBackendFactory.
-        val name = loggingClass.replace('$', '.')
+        val name = loggerName(loggingClass)
 
         // There is log4j.Logger interface and log4j.core.Logger implementation.
         // Implementation exposes more methods that are needed by the backend.
diff --git a/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt b/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt
index aaac8d9e..e323cea2 100644
--- a/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt
+++ b/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt
@@ -31,10 +31,12 @@ package io.spine.logging.backend.otel.bootstrap
 import io.opentelemetry.kotlin.ExperimentalApi
 import io.opentelemetry.kotlin.NoopOpenTelemetry
 import io.opentelemetry.kotlin.createOpenTelemetry
+import io.opentelemetry.kotlin.export.OperationResultCode
 import io.opentelemetry.kotlin.export.TelemetryCloseable
 import io.opentelemetry.kotlin.logging.export.batchLogRecordProcessor
 import io.opentelemetry.kotlin.logging.export.otlpHttpLogRecordExporter
 import io.spine.logging.backend.otel.OtelBackendSettings
+import java.util.logging.Logger
 import kotlinx.coroutines.runBlocking
 
 /**
@@ -51,9 +53,19 @@ public object OtelLogging {
 
     /**
      * The default OTLP/HTTP endpoint of a local OpenTelemetry Collector.
+     *
+     * Port `4318` is the OpenTelemetry-standard OTLP/HTTP port, so this default
+     * matches a collector started with stock settings. When your collector listens
+     * elsewhere, override it: pass an explicit endpoint to [installOtlpHttp], or set
+     * the `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable and use [fromEnvironment].
      */
     public const val DEFAULT_OTLP_HTTP_ENDPOINT: String = "http://localhost:4318"
 
+    /**
+     * The environment variable that overrides [DEFAULT_OTLP_HTTP_ENDPOINT].
+     */
+    private const val OTLP_ENDPOINT_ENV: String = "OTEL_EXPORTER_OTLP_ENDPOINT"
+
     /**
      * Builds a native Kotlin OpenTelemetry SDK that exports log records over
      * OTLP/HTTP to [endpoint] and installs it into [OtelBackendSettings].
@@ -77,7 +89,17 @@ public object OtelLogging {
             // The SDK instance created by `createOpenTelemetry` is a `TelemetryCloseable`;
             // the safe cast future-proofs against the factory ever returning otherwise.
             OtelBackendSettings.use(NoopOpenTelemetry)
-            runBlocking { (openTelemetry as? TelemetryCloseable)?.shutdown() }
+            val result = runBlocking { (openTelemetry as? TelemetryCloseable)?.shutdown() }
+            if (result == OperationResultCode.Failure) {
+                // A failed flush/shutdown means buffered records may be lost; do not let
+                // it pass silently. Report via JUL: the Spine OTel backend has just been
+                // pointed at the no-op instance, so logging through it here would itself
+                // be dropped.
+                Logger.getLogger(OtelLogging::class.java.name).warning(
+                    "The OpenTelemetry SDK reported a failure while shutting down; " +
+                        "some buffered log records may not have been exported."
+                )
+            }
         }
     }
 
@@ -86,9 +108,17 @@ public object OtelLogging {
      * `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable, falling back to
      * [DEFAULT_OTLP_HTTP_ENDPOINT] when it is not set.
      */
-    public fun fromEnvironment(): AutoCloseable {
-        val endpoint = System.getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
-            ?: DEFAULT_OTLP_HTTP_ENDPOINT
-        return installOtlpHttp(endpoint)
-    }
+    public fun fromEnvironment(): AutoCloseable =
+        installOtlpHttp(endpointFromEnvironment())
+
+    /**
+     * Resolves the OTLP/HTTP endpoint from the `OTEL_EXPORTER_OTLP_ENDPOINT`
+     * environment variable, falling back to [DEFAULT_OTLP_HTTP_ENDPOINT] when it is
+     * not set.
+     *
+     * Exposed as `internal` so the resolution can be verified without building an
+     * exporter or touching the network.
+     */
+    internal fun endpointFromEnvironment(): String =
+        System.getenv(OTLP_ENDPOINT_ENV) ?: DEFAULT_OTLP_HTTP_ENDPOINT
 }
diff --git a/backends/otel-backend-bootstrap/src/test/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLoggingSpec.kt b/backends/otel-backend-bootstrap/src/test/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLoggingSpec.kt
index 904bdd83..bed54921 100644
--- a/backends/otel-backend-bootstrap/src/test/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLoggingSpec.kt
+++ b/backends/otel-backend-bootstrap/src/test/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLoggingSpec.kt
@@ -27,6 +27,8 @@
 package io.spine.logging.backend.otel.bootstrap
 
 import io.kotest.assertions.throwables.shouldNotThrowAny
+import io.kotest.matchers.shouldBe
+import java.net.ServerSocket
 import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Test
 
@@ -34,30 +36,26 @@ import org.junit.jupiter.api.Test
 internal class OtelLoggingSpec {
 
     @Test
-    fun `build, install and shut down an OTLP HTTP pipeline`() {
-        shouldNotThrowAny {
-            // No collector is listening; the batch processor exports asynchronously,
-            // so construction, installation and shutdown must all succeed regardless.
-            val installed = OtelLogging.installOtlpHttp(OtelLogging.DEFAULT_OTLP_HTTP_ENDPOINT)
-            installed.close()
-        }
+    fun `resolve the default endpoint when the environment variable is unset`() {
+        // `OTEL_EXPORTER_OTLP_ENDPOINT` is not set in the test JVM, so resolution
+        // falls back to the default. This is pure logic: no exporter is built and no
+        // port is touched.
+        OtelLogging.endpointFromEnvironment() shouldBe OtelLogging.DEFAULT_OTLP_HTTP_ENDPOINT
     }
 
     @Test
-    fun `install using the default endpoint`() {
+    fun `build, install and shut down an OTLP HTTP pipeline`() {
         shouldNotThrowAny {
-            val installed = OtelLogging.installOtlpHttp()
+            // Aim the exporter at a free local port rather than the well-known 4318:
+            // the test must not collide with — or accidentally export into — a real
+            // collector or a parallel suite on the standard port. The batch processor
+            // exports asynchronously, so construction, installation and shutdown all
+            // succeed whether or not anything is listening.
+            val installed = OtelLogging.installOtlpHttp("http://localhost:${freePort()}")
             installed.close()
         }
     }
 
-    @Test
-    fun `install from the environment, falling back to the default endpoint`() {
-        shouldNotThrowAny {
-            // With `OTEL_EXPORTER_OTLP_ENDPOINT` unset, this exercises the fallback
-            // to the default endpoint.
-            val installed = OtelLogging.fromEnvironment()
-            installed.close()
-        }
-    }
+    /** Returns a currently-free local TCP port. */
+    private fun freePort(): Int = ServerSocket(0).use { it.localPort }
 }
diff --git a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelEvents.kt b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelEvents.kt
index 38732a8c..786e0646 100644
--- a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelEvents.kt
+++ b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelEvents.kt
@@ -35,7 +35,7 @@ import io.spine.logging.WithLogging
  *
  * When a log statement carries this key, the backend emits the record as a
  * log-based *event* — `Logger.emit(eventName = …)` — rather than a plain log
- * record, and the key itself is not duplicated as a `spine.*` attribute.
+ * record, and the key itself is not duplicated as an attribute.
  *
  * This plays the role of the `otel.event.name` key recognized by the OpenTelemetry
  * Logback and Log4j appenders. The Spine metadata label must be a plain identifier
diff --git a/backends/otel-backend/src/jvmMain/kotlin/io/spine/logging/backend/otel/OtelBackendFactory.kt b/backends/otel-backend/src/jvmMain/kotlin/io/spine/logging/backend/otel/OtelBackendFactory.kt
index 81110d1a..d9346bc8 100644
--- a/backends/otel-backend/src/jvmMain/kotlin/io/spine/logging/backend/otel/OtelBackendFactory.kt
+++ b/backends/otel-backend/src/jvmMain/kotlin/io/spine/logging/backend/otel/OtelBackendFactory.kt
@@ -43,14 +43,15 @@ import io.spine.logging.backend.LoggerBackend
  * several backends are present, set the `spine.logging.backend_factory` system
  * property to this class' fully-qualified name.
  *
- * The instrumentation scope name passed to the logger provider is the logging
- * class name with `$` replaced by `.`, matching the other Spine backends.
+ * The instrumentation scope name passed to the logger provider is the logging class
+ * name converted by the shared `loggerName` convention of [BackendFactory] (`$`
+ * replaced by `.`), matching the other Spine Logging backends.
  */
 @AutoService(BackendFactory::class)
 public class OtelBackendFactory : BackendFactory() {
 
     override fun create(loggingClass: String): LoggerBackend {
-        val name = loggingClass.replace('$', '.')
+        val name = loggerName(loggingClass)
         return OtelLoggerBackend(name)
     }
 
diff --git a/logging/src/commonMain/kotlin/io/spine/logging/backend/BackendFactory.kt b/logging/src/commonMain/kotlin/io/spine/logging/backend/BackendFactory.kt
index d71c3bfd..83e08c7c 100644
--- a/logging/src/commonMain/kotlin/io/spine/logging/backend/BackendFactory.kt
+++ b/logging/src/commonMain/kotlin/io/spine/logging/backend/BackendFactory.kt
@@ -76,7 +76,19 @@ public abstract class BackendFactory {
      * rather than the internal binary format `"com/example/Foo$Bar"`).
      *
      * @param loggingClass The fully-qualified name of the Java class to which the logger is
-     *        associated. The logger name is derived from this string in a backend-specific way.
+     *        associated. The logger name is derived from this string in a backend-specific
+     *        way, commonly via `loggerName`.
      */
     public abstract fun create(loggingClass: String): LoggerBackend
+
+    /**
+     * Derives a backend logger name from the given [loggingClass].
+     *
+     * Nested and inner classes arrive with `$` separating the enclosing class from the
+     * nested one (for example, `com.example.Foo$Bar`). Backends name their loggers with
+     * dots, so this replaces `$` with `.`. It is the single naming convention shared by
+     * the Spine Logging backends; implementations should derive their logger name through
+     * it rather than re-implementing the replacement.
+     */
+    protected fun loggerName(loggingClass: String): String = loggingClass.replace('$', '.')
 }

From ebc32254b424bb3cddfcecc3adff17efd2b6aec2 Mon Sep 17 00:00:00 2001
From: Alexander Yevsyukov <alexander.yevsyukov@teamdev.com>
Date: Sun, 28 Jun 2026 20:14:12 +0100
Subject: [PATCH 13/20] Accept a lazy message supplier in `logEvent`
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`WithLogging.logEvent` now takes `message: () -> String` instead of a `String`, so
the body is built only when the event is enabled — matching the fluent `log {}` API
and the "a disabled event costs nothing" contract. The default still resolves to the
event name, and the trailing-lambda form reads naturally: `logEvent(name) { "body" }`.

Adds a test covering the supplied-message path.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../io/spine/logging/backend/otel/OtelEvents.kt | 10 ++++++----
 .../backend/otel/OtelLoggerBackendSpec.kt       | 17 ++++++++++++++++-
 2 files changed, 22 insertions(+), 5 deletions(-)

diff --git a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelEvents.kt b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelEvents.kt
index 786e0646..e9a50dd5 100644
--- a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelEvents.kt
+++ b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelEvents.kt
@@ -50,7 +50,8 @@ public val EVENT_NAME: MetadataKey<String> = MetadataKey.single<String>("otelEve
  *
  * An event is an ordinary log statement that carries the [EVENT_NAME] metadata;
  * the OpenTelemetry backend maps it to `Logger.emit(eventName = name)`. Guarded by
- * the level, so a disabled event costs nothing.
+ * the level, so a disabled event costs nothing — [message] is evaluated only when
+ * the event is actually emitted.
  *
  * The [name] should be low-cardinality (for example, `acme.orders.OrderPlaced`),
  * per the OpenTelemetry event semantic conventions — dynamic values belong in
@@ -58,14 +59,15 @@ public val EVENT_NAME: MetadataKey<String> = MetadataKey.single<String>("otelEve
  *
  * @param name The event name.
  * @param level The severity of the event. Defaults to [Level.INFO].
- * @param message The record body. Defaults to [name].
+ * @param message Supplies the record body, evaluated lazily only when the event is
+ *   enabled. Defaults to the [name].
  */
 public fun WithLogging.logEvent(
     name: String,
     level: Level = Level.INFO,
-    message: String = name,
+    message: () -> String = { name },
 ) {
     logger.at(level)
         .with(EVENT_NAME, name)
-        .log { message }
+        .log(message)
 }
diff --git a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
index c70809b3..e7730cbf 100644
--- a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
+++ b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
@@ -237,7 +237,22 @@ internal class OtelLoggerBackendSpec {
             createOpenTelemetry { loggerProvider { export { processor } } }
         )
         EventSource().logEvent("checkout.completed")
-        processor.records.last().eventName shouldBe "checkout.completed"
+        with(processor.records.last()) {
+            eventName shouldBe "checkout.completed"
+            body shouldBe "checkout.completed"
+        }
+    }
+
+    @Test
+    fun `use the lazily supplied message as the event body`() {
+        OtelBackendSettings.use(
+            createOpenTelemetry { loggerProvider { export { processor } } }
+        )
+        EventSource().logEvent("checkout.completed") { "Checkout finished." }
+        with(processor.records.last()) {
+            eventName shouldBe "checkout.completed"
+            body shouldBe "Checkout finished."
+        }
     }
 
     @Test

From 65d9194ebb2f45ee474f4329c2487fa9e9e1026c Mon Sep 17 00:00:00 2001
From: Alexander Yevsyukov <alexander.yevsyukov@teamdev.com>
Date: Sun, 28 Jun 2026 20:39:46 +0100
Subject: [PATCH 14/20] Address automated PR review (Copilot, Codex)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- AttributeMapping.putValues: dispatch on the whole list, not just its first element,
  so a repeated<Any> key holding mixed types falls back to a string list instead of
  risking a ClassCastException. Adds a regression test.
- OtelLogging.close(): also warn (via JUL) when the SDK is not a TelemetryCloseable, so
  a skipped shutdown is never silent — previously only OperationResultCode.Failure warned.
- docs/otel-backend.md: note that programmatic setup (OtelBackendSettings.use / logEvent)
  needs the backend as an `implementation` dependency, not `runtimeOnly`.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../backend/otel/bootstrap/OtelLogging.kt     | 23 +++++++++++--------
 .../logging/backend/otel/AttributeMapping.kt  | 12 ++++++----
 .../backend/otel/OtelLoggerBackendSpec.kt     | 11 +++++++++
 docs/otel-backend.md                          |  5 ++++
 4 files changed, 37 insertions(+), 14 deletions(-)

diff --git a/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt b/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt
index e323cea2..290e1dcf 100644
--- a/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt
+++ b/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt
@@ -86,16 +86,21 @@ public object OtelLogging {
         OtelBackendSettings.use(openTelemetry)
         return AutoCloseable {
             // Stop routing new records to this SDK, then flush and shut it down.
-            // The SDK instance created by `createOpenTelemetry` is a `TelemetryCloseable`;
-            // the safe cast future-proofs against the factory ever returning otherwise.
             OtelBackendSettings.use(NoopOpenTelemetry)
-            val result = runBlocking { (openTelemetry as? TelemetryCloseable)?.shutdown() }
-            if (result == OperationResultCode.Failure) {
-                // A failed flush/shutdown means buffered records may be lost; do not let
-                // it pass silently. Report via JUL: the Spine OTel backend has just been
-                // pointed at the no-op instance, so logging through it here would itself
-                // be dropped.
-                Logger.getLogger(OtelLogging::class.java.name).warning(
+            // Report failures via JUL: the Spine OTel backend has just been pointed at the
+            // no-op instance, so logging through it here would itself be dropped.
+            val logger = Logger.getLogger(OtelLogging::class.java.name)
+            val closeable = openTelemetry as? TelemetryCloseable
+            if (closeable == null) {
+                // `createOpenTelemetry` returns a `TelemetryCloseable` today; reaching here
+                // would mean the factory changed and the SDK was NOT shut down — don't hide it.
+                logger.warning(
+                    "The OpenTelemetry SDK is not a TelemetryCloseable; it was not shut down, " +
+                        "so buffered log records may not have been exported."
+                )
+            } else if (runBlocking { closeable.shutdown() } == OperationResultCode.Failure) {
+                // A failed flush/shutdown means buffered records may be lost.
+                logger.warning(
                     "The OpenTelemetry SDK reported a failure while shutting down; " +
                         "some buffered log records may not have been exported."
                 )
diff --git a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/AttributeMapping.kt b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/AttributeMapping.kt
index d68b4adb..7b19cc94 100644
--- a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/AttributeMapping.kt
+++ b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/AttributeMapping.kt
@@ -103,13 +103,15 @@ private fun AttributesMutator.putValues(name: String, values: Iterator<Any>) {
     if (list.isEmpty()) {
         return
     }
-    when (list.first()) {
-        is Boolean -> setBooleanListAttribute(name, list.map { it as Boolean })
-        is Byte, is Short, is Int, is Long ->
+    // Dispatch on the whole list, not just its first element: a `repeated<Any>` key may
+    // hold mixed types, so fall back to a string list rather than risk a `ClassCastException`.
+    when {
+        list.all { it is Boolean } -> setBooleanListAttribute(name, list.map { it as Boolean })
+        list.all { it is Byte || it is Short || it is Int || it is Long } ->
             setLongListAttribute(name, list.map { (it as Number).toLong() })
-        is Float, is Double ->
+        list.all { it is Float || it is Double } ->
             setDoubleListAttribute(name, list.map { (it as Number).toDouble() })
-        is String -> setStringListAttribute(name, list.map { it as String })
+        list.all { it is String } -> setStringListAttribute(name, list.map { it as String })
         else -> setStringListAttribute(name, list.map { it.toString() })
     }
 }
diff --git a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
index e7730cbf..a4918441 100644
--- a/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
+++ b/backends/otel-backend/src/jvmTest/kotlin/io/spine/logging/backend/otel/OtelLoggerBackendSpec.kt
@@ -296,6 +296,16 @@ internal class OtelLoggerBackendSpec {
         }
     }
 
+    @Test
+    fun `fall back to a string list for repeated values of mixed types`() {
+        backend.log(
+            StubLogData(LITERAL)
+                .addMetadata(MIXED_LIST_KEY, 1)
+                .addMetadata(MIXED_LIST_KEY, "two")
+        )
+        (lastRecord.attributes["mixed"] as List<*>) shouldContainExactlyInAnyOrder listOf("1", "two")
+    }
+
     @Test
     fun `omit the line number and source file when unknown`() {
         backend.log(StubLogData(LITERAL).setLogSite(StubLogSite("C", "m", 0, null)))
@@ -327,5 +337,6 @@ internal class OtelLoggerBackendSpec {
         private val DOUBLE_LIST_KEY = MetadataKey.repeated<Double>("ratios")
         private val STRING_LIST_KEY = MetadataKey.repeated<String>("names")
         private val CHAR_LIST_KEY = MetadataKey.repeated<Char>("symbols")
+        private val MIXED_LIST_KEY = MetadataKey.repeated<Any>("mixed")
     }
 }
diff --git a/docs/otel-backend.md b/docs/otel-backend.md
index b21a8eb1..aaad9ecb 100644
--- a/docs/otel-backend.md
+++ b/docs/otel-backend.md
@@ -23,6 +23,11 @@ dependencies {
 }
 ```
 
+`runtimeOnly` is enough when the backend is selected purely via `ServiceLoader`. If your
+code calls the backend's API directly — `OtelBackendSettings.use(...)` (see below) or the
+`logEvent` helper — depend on it with `implementation` instead, so those types are on the
+compile classpath.
+
 Keep exactly **one** backend on the classpath. If several are present, select this one
 explicitly with the `spine.logging.backend_factory` system property:
 

From d05dca54399753c581024dde0774018f292d8d87 Mon Sep 17 00:00:00 2001
From: Alexander Yevsyukov <alexander.yevsyukov@teamdev.com>
Date: Sun, 28 Jun 2026 20:59:34 +0100
Subject: [PATCH 15/20] Honor the logs-specific OTLP endpoint in
 `fromEnvironment()`
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Address Codex review: `endpointFromEnvironment()` now prefers the signal-specific
`OTEL_EXPORTER_OTLP_LOGS_ENDPOINT` over the generic `OTEL_EXPORTER_OTLP_ENDPOINT`
before the localhost default, so logs reach the configured collector. The value is a
base URL — the bundled `otlpHttpLogRecordExporter` always appends `/v1/logs` — kept
consistent with the default and the generic variable.

Resolution is split into a `getenv`-injected overload so the precedence is covered by
deterministic unit tests without mutating the process environment.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../backend/otel/bootstrap/OtelLogging.kt     | 40 ++++++++++++++-----
 .../backend/otel/bootstrap/OtelLoggingSpec.kt | 25 ++++++++++++
 docs/otel-backend.md                          |  3 +-
 3 files changed, 57 insertions(+), 11 deletions(-)

diff --git a/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt b/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt
index 290e1dcf..7e0231e2 100644
--- a/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt
+++ b/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt
@@ -62,7 +62,14 @@ public object OtelLogging {
     public const val DEFAULT_OTLP_HTTP_ENDPOINT: String = "http://localhost:4318"
 
     /**
-     * The environment variable that overrides [DEFAULT_OTLP_HTTP_ENDPOINT].
+     * The signal-specific environment variable that overrides
+     * [DEFAULT_OTLP_HTTP_ENDPOINT], taking precedence over [OTLP_ENDPOINT_ENV].
+     */
+    private const val OTLP_LOGS_ENDPOINT_ENV: String = "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT"
+
+    /**
+     * The generic OTLP environment variable that overrides [DEFAULT_OTLP_HTTP_ENDPOINT]
+     * when [OTLP_LOGS_ENDPOINT_ENV] is not set.
      */
     private const val OTLP_ENDPOINT_ENV: String = "OTEL_EXPORTER_OTLP_ENDPOINT"
 
@@ -109,21 +116,34 @@ public object OtelLogging {
     }
 
     /**
-     * Installs an OTLP/HTTP pipeline using the endpoint from the
-     * `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable, falling back to
-     * [DEFAULT_OTLP_HTTP_ENDPOINT] when it is not set.
+     * Installs an OTLP/HTTP pipeline using the endpoint resolved from the environment.
+     *
+     * The signal-specific `OTEL_EXPORTER_OTLP_LOGS_ENDPOINT` takes precedence over the
+     * generic `OTEL_EXPORTER_OTLP_ENDPOINT`, falling back to [DEFAULT_OTLP_HTTP_ENDPOINT]
+     * when neither is set.
      */
     public fun fromEnvironment(): AutoCloseable =
         installOtlpHttp(endpointFromEnvironment())
 
     /**
-     * Resolves the OTLP/HTTP endpoint from the `OTEL_EXPORTER_OTLP_ENDPOINT`
-     * environment variable, falling back to [DEFAULT_OTLP_HTTP_ENDPOINT] when it is
-     * not set.
+     * Resolves the OTLP/HTTP base endpoint from the environment, preferring the
+     * signal-specific [OTLP_LOGS_ENDPOINT_ENV] over the generic [OTLP_ENDPOINT_ENV] and
+     * falling back to [DEFAULT_OTLP_HTTP_ENDPOINT] when neither is set.
      *
-     * Exposed as `internal` so the resolution can be verified without building an
-     * exporter or touching the network.
+     * The value is treated as a base URL: the exporter appends the OTLP/HTTP logs path
+     * (`/v1/logs`) to it, just as it does for the default.
+     *
+     * Exposed as `internal` so the resolution can be verified without touching the real
+     * environment or the network.
      */
     internal fun endpointFromEnvironment(): String =
-        System.getenv(OTLP_ENDPOINT_ENV) ?: DEFAULT_OTLP_HTTP_ENDPOINT
+        endpointFromEnvironment { System.getenv(it) }
+
+    /**
+     * Resolves the endpoint as [endpointFromEnvironment], looking variables up through
+     * [getenv]. Separated so the precedence can be tested without mutating the process
+     * environment.
+     */
+    internal fun endpointFromEnvironment(getenv: (String) -> String?): String =
+        getenv(OTLP_LOGS_ENDPOINT_ENV) ?: getenv(OTLP_ENDPOINT_ENV) ?: DEFAULT_OTLP_HTTP_ENDPOINT
 }
diff --git a/backends/otel-backend-bootstrap/src/test/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLoggingSpec.kt b/backends/otel-backend-bootstrap/src/test/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLoggingSpec.kt
index bed54921..28f7a49c 100644
--- a/backends/otel-backend-bootstrap/src/test/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLoggingSpec.kt
+++ b/backends/otel-backend-bootstrap/src/test/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLoggingSpec.kt
@@ -43,6 +43,31 @@ internal class OtelLoggingSpec {
         OtelLogging.endpointFromEnvironment() shouldBe OtelLogging.DEFAULT_OTLP_HTTP_ENDPOINT
     }
 
+    @Test
+    fun `prefer the logs-specific endpoint over the generic one`() {
+        val resolved = OtelLogging.endpointFromEnvironment {
+            when (it) {
+                "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT" -> "http://logs:4318"
+                "OTEL_EXPORTER_OTLP_ENDPOINT" -> "http://generic:4318"
+                else -> null
+            }
+        }
+        resolved shouldBe "http://logs:4318"
+    }
+
+    @Test
+    fun `use the generic endpoint when no logs-specific one is set`() {
+        val resolved = OtelLogging.endpointFromEnvironment {
+            if (it == "OTEL_EXPORTER_OTLP_ENDPOINT") "http://generic:4318" else null
+        }
+        resolved shouldBe "http://generic:4318"
+    }
+
+    @Test
+    fun `fall back to the default when no endpoint variable is set`() {
+        OtelLogging.endpointFromEnvironment { null } shouldBe OtelLogging.DEFAULT_OTLP_HTTP_ENDPOINT
+    }
+
     @Test
     fun `build, install and shut down an OTLP HTTP pipeline`() {
         shouldNotThrowAny {
diff --git a/docs/otel-backend.md b/docs/otel-backend.md
index aaad9ecb..5f6caa3f 100644
--- a/docs/otel-backend.md
+++ b/docs/otel-backend.md
@@ -65,7 +65,8 @@ for you, returning a handle that uninstalls the backend and shuts the SDK down w
 ```kotlin
 import io.spine.logging.backend.otel.bootstrap.OtelLogging
 
-// Reads `OTEL_EXPORTER_OTLP_ENDPOINT`, falling back to `http://localhost:4318`.
+// Prefers `OTEL_EXPORTER_OTLP_LOGS_ENDPOINT`, then `OTEL_EXPORTER_OTLP_ENDPOINT`,
+// falling back to `http://localhost:4318`.
 val installed = OtelLogging.fromEnvironment()
 
 // Or with an explicit endpoint:

From 43eed308dcfd675b300f0da9c9bf837d644420c5 Mon Sep 17 00:00:00 2001
From: Alexander Yevsyukov <alexander.yevsyukov@teamdev.com>
Date: Sun, 28 Jun 2026 21:04:21 +0100
Subject: [PATCH 16/20] Bump version -> `2.0.0-SNAPSHOT.419`

---
 version.gradle.kts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/version.gradle.kts b/version.gradle.kts
index 623e94ec..d3b1ef08 100644
--- a/version.gradle.kts
+++ b/version.gradle.kts
@@ -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.
@@ -24,4 +24,4 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-val versionToPublish: String by extra("2.0.0-SNAPSHOT.418")
+val versionToPublish: String by extra("2.0.0-SNAPSHOT.419")

From 07d993c3cbc3440b3cb4cac5077d0ae7b03b76af Mon Sep 17 00:00:00 2001
From: Alexander Yevsyukov <alexander.yevsyukov@teamdev.com>
Date: Sun, 28 Jun 2026 21:07:31 +0100
Subject: [PATCH 17/20] Update dependency reports

---
 docs/dependencies/dependencies.md | 72 +++++++++++++++----------------
 docs/dependencies/pom.xml         |  4 +-
 2 files changed, 38 insertions(+), 38 deletions(-)

diff --git a/docs/dependencies/dependencies.md b/docs/dependencies/dependencies.md
index 8ad2adf7..756a0789 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.418`
+# Dependencies of `io.spine:spine-logging-context-tests:2.0.0-SNAPSHOT.419`
 
 ## 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 **Sun Jun 28 17:14:26 WEST 2026** using 
+This report was generated on **Sun Jun 28 21:04:41 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.418`
+# Dependencies of `io.spine:spine-logging-fixtures:2.0.0-SNAPSHOT.419`
 
 ## Runtime
 ## Compile, tests, and tooling
@@ -1240,14 +1240,14 @@ This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using 
+This report was generated on **Sun Jun 28 21:04:42 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.418`
+# Dependencies of `io.spine:spine-logging-grpc-context:2.0.0-SNAPSHOT.419`
 
 ## Runtime
 1.  **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2.
@@ -2094,14 +2094,14 @@ This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using 
+This report was generated on **Sun Jun 28 21:04:41 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.418`
+# Dependencies of `io.spine:spine-logging-jul-backend:2.0.0-SNAPSHOT.419`
 
 ## Runtime
 1.  **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2.
@@ -2932,14 +2932,14 @@ This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using 
+This report was generated on **Sun Jun 28 21:04:42 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.418`
+# Dependencies of `io.spine:spine-logging-jvm-default-platform:2.0.0-SNAPSHOT.419`
 
 ## Runtime
 1.  **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2.
@@ -3786,14 +3786,14 @@ This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using 
+This report was generated on **Sun Jun 28 21:04:41 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.418`
+# Dependencies of `io.spine:spine-logging-jvm-jul-backend-grpc-context:2.0.0-SNAPSHOT.419`
 
 ## Runtime
 1.  **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2.
@@ -4692,14 +4692,14 @@ This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using 
+This report was generated on **Sun Jun 28 21:04:41 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.418`
+# Dependencies of `io.spine:spine-logging-jvm-jul-backend-std-context:2.0.0-SNAPSHOT.419`
 
 ## Runtime
 1.  **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2.
@@ -5590,14 +5590,14 @@ This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using 
+This report was generated on **Sun Jun 28 21:04:41 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.418`
+# Dependencies of `io.spine:spine-logging-jvm-log4j2-backend-std-context:2.0.0-SNAPSHOT.419`
 
 ## Runtime
 1.  **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2.
@@ -6508,14 +6508,14 @@ This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using 
+This report was generated on **Sun Jun 28 21:04:41 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.418`
+# Dependencies of `io.spine:spine-logging-jvm-slf4j-jdk14-backend-std-context:2.0.0-SNAPSHOT.419`
 
 ## Runtime
 1.  **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2.
@@ -7414,14 +7414,14 @@ This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using 
+This report was generated on **Sun Jun 28 21:04:41 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.418`
+# Dependencies of `io.spine:spine-logging-jvm-slf4j-reload4j-backend-std-context:2.0.0-SNAPSHOT.419`
 
 ## Runtime
 1.  **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2.
@@ -8324,14 +8324,14 @@ This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using 
+This report was generated on **Sun Jun 28 21:04:41 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.418`
+# Dependencies of `io.spine:spine-logging-log4j2-backend:2.0.0-SNAPSHOT.419`
 
 ## Runtime
 1.  **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2.
@@ -9206,14 +9206,14 @@ This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using 
+This report was generated on **Sun Jun 28 21:04:41 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.418`
+# Dependencies of `io.spine:spine-logging:2.0.0-SNAPSHOT.419`
 
 ## Runtime
 ## Compile, tests, and tooling
@@ -10013,14 +10013,14 @@ This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using 
+This report was generated on **Sun Jun 28 21:04:42 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.418`
+# Dependencies of `io.spine.tools:logging-testlib:2.0.0-SNAPSHOT.419`
 
 ## Runtime
 ## Compile, tests, and tooling
@@ -10832,14 +10832,14 @@ This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using 
+This report was generated on **Sun Jun 28 21:04:41 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.418`
+# Dependencies of `io.spine:spine-logging-otel-backend:2.0.0-SNAPSHOT.419`
 
 ## Runtime
 ## Compile, tests, and tooling
@@ -11739,14 +11739,14 @@ This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using 
+This report was generated on **Sun Jun 28 21:04:42 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.418`
+# Dependencies of `io.spine:spine-logging-otel-backend-bootstrap:2.0.0-SNAPSHOT.419`
 
 ## Runtime
 1.  **Group** : com.google.auto.service. **Name** : auto-service-annotations. **Version** : 1.1.1.
@@ -13157,14 +13157,14 @@ This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using 
+This report was generated on **Sun Jun 28 21:04:41 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.418`
+# Dependencies of `io.spine:spine-logging-probe-backend:2.0.0-SNAPSHOT.419`
 
 ## Runtime
 1.  **Group** : com.google.auto.service. **Name** : auto-service-annotations. **Version** : 1.1.1.
@@ -14015,14 +14015,14 @@ This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using 
+This report was generated on **Sun Jun 28 21:04:41 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.418`
+# Dependencies of `io.spine:spine-logging-smoke-test:2.0.0-SNAPSHOT.419`
 
 ## Runtime
 1.  **Group** : com.fasterxml.jackson. **Name** : jackson-bom. **Version** : 2.22.0.
@@ -14921,14 +14921,14 @@ This report was generated on **Sun Jun 28 17:14:26 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:14:27 WEST 2026** using 
+This report was generated on **Sun Jun 28 21:04:41 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.418`
+# Dependencies of `io.spine:spine-logging-std-context:2.0.0-SNAPSHOT.419`
 
 ## Runtime
 1.  **Group** : com.google.code.findbugs. **Name** : jsr305. **Version** : 3.0.2.
@@ -15759,6 +15759,6 @@ This report was generated on **Sun Jun 28 17:14:27 WEST 2026** using
 
 The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
-This report was generated on **Sun Jun 28 17:14:27 WEST 2026** using 
+This report was generated on **Sun Jun 28 21:04:42 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 a718e096..cc46af21 100644
--- a/docs/dependencies/pom.xml
+++ b/docs/dependencies/pom.xml
@@ -9,8 +9,8 @@ all modules and does not describe the project structure per-subproject.
  
  -->
 <groupId>io.spine</groupId>
-<artifactId>spine-logging</artifactId>
-<version>2.0.0-SNAPSHOT.418</version>
+<artifactId>logging</artifactId>
+<version>2.0.0-SNAPSHOT.419</version>
 
 <inceptionYear>2015</inceptionYear>
 

From 822b267f66ab3ee91516322ac05b3b41c6a3544b Mon Sep 17 00:00:00 2001
From: Alexander Yevsyukov <alexander.yevsyukov@teamdev.com>
Date: Sun, 28 Jun 2026 21:21:25 +0100
Subject: [PATCH 18/20] Fix nullability issue

---
 .../kotlin/io/spine/logging/backend/otel/OtelLoggerBackend.kt   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelLoggerBackend.kt b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelLoggerBackend.kt
index fc26a73e..ce199aa1 100644
--- a/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelLoggerBackend.kt
+++ b/backends/otel-backend/src/commonMain/kotlin/io/spine/logging/backend/otel/OtelLoggerBackend.kt
@@ -72,7 +72,7 @@ internal class OtelLoggerBackend(
     private val scopeName: String,
 ) : LoggerBackend() {
 
-    override val loggerName: String?
+    override val loggerName: String
         get() = scopeName
 
     /**

From 3980b7847b87f381110238c63ce9cf3ad5e93dd4 Mon Sep 17 00:00:00 2001
From: Alexander Yevsyukov <alexander.yevsyukov@teamdev.com>
Date: Sun, 28 Jun 2026 21:27:03 +0100
Subject: [PATCH 19/20] Cover bootstrap shutdown and endpoint paths (fix
 codecov/project)

Extract SDK shutdown reporting into a testable `internal reportShutdown(sdk, result,
logger)` so both warning paths (non-closeable SDK, OperationResultCode.Failure) and the
silent-success path are unit-tested via a capturing JUL handler. Add smoke tests for the
no-arg installOtlpHttp() and fromEnvironment() wiring.

Raises otel-backend-bootstrap src/main line coverage from 75% to ~97%, clearing the
codecov/project threshold; the new module's uncovered warning branches were dragging the
src/main aggregate below base.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../backend/otel/bootstrap/OtelLogging.kt     | 49 +++++++++-----
 .../backend/otel/bootstrap/OtelLoggingSpec.kt | 67 +++++++++++++++++++
 2 files changed, 98 insertions(+), 18 deletions(-)

diff --git a/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt b/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt
index 7e0231e2..c9466c2c 100644
--- a/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt
+++ b/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt
@@ -94,25 +94,38 @@ public object OtelLogging {
         return AutoCloseable {
             // Stop routing new records to this SDK, then flush and shut it down.
             OtelBackendSettings.use(NoopOpenTelemetry)
-            // Report failures via JUL: the Spine OTel backend has just been pointed at the
-            // no-op instance, so logging through it here would itself be dropped.
-            val logger = Logger.getLogger(OtelLogging::class.java.name)
-            val closeable = openTelemetry as? TelemetryCloseable
-            if (closeable == null) {
-                // `createOpenTelemetry` returns a `TelemetryCloseable` today; reaching here
-                // would mean the factory changed and the SDK was NOT shut down — don't hide it.
-                logger.warning(
-                    "The OpenTelemetry SDK is not a TelemetryCloseable; it was not shut down, " +
-                        "so buffered log records may not have been exported."
-                )
-            } else if (runBlocking { closeable.shutdown() } == OperationResultCode.Failure) {
-                // A failed flush/shutdown means buffered records may be lost.
-                logger.warning(
-                    "The OpenTelemetry SDK reported a failure while shutting down; " +
-                        "some buffered log records may not have been exported."
-                )
-            }
+            val result =
+                if (openTelemetry is TelemetryCloseable) runBlocking { openTelemetry.shutdown() }
+                else null
+            reportShutdown(openTelemetry, result)
+        }
+    }
+
+    /**
+     * Warns, via JUL, when the SDK could not be shut down cleanly: it is not a
+     * [TelemetryCloseable] (so it was never shut down), or its `shutdown()` reported a
+     * failure. Either way buffered records may be lost, so the outcome must not pass
+     * silently — JUL is used because the Spine OTel backend has just been pointed at the
+     * no-op instance, so logging through it here would itself be dropped.
+     *
+     * Exposed as `internal` (with an injectable [logger]) so both outcomes can be verified
+     * without provoking a real SDK failure.
+     */
+    internal fun reportShutdown(
+        sdk: Any,
+        result: OperationResultCode?,
+        logger: Logger = Logger.getLogger(OtelLogging::class.java.name),
+    ) {
+        val warning = when {
+            sdk !is TelemetryCloseable ->
+                "The OpenTelemetry SDK is not a TelemetryCloseable; it was not shut down, " +
+                    "so buffered log records may not have been exported."
+            result == OperationResultCode.Failure ->
+                "The OpenTelemetry SDK reported a failure while shutting down; " +
+                    "some buffered log records may not have been exported."
+            else -> return
         }
+        logger.warning(warning)
     }
 
     /**
diff --git a/backends/otel-backend-bootstrap/src/test/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLoggingSpec.kt b/backends/otel-backend-bootstrap/src/test/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLoggingSpec.kt
index 28f7a49c..f3f6ad02 100644
--- a/backends/otel-backend-bootstrap/src/test/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLoggingSpec.kt
+++ b/backends/otel-backend-bootstrap/src/test/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLoggingSpec.kt
@@ -24,11 +24,22 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+@file:OptIn(ExperimentalApi::class)
+
 package io.spine.logging.backend.otel.bootstrap
 
 import io.kotest.assertions.throwables.shouldNotThrowAny
+import io.kotest.matchers.collections.shouldHaveSize
 import io.kotest.matchers.shouldBe
+import io.kotest.matchers.string.shouldContain
+import io.opentelemetry.kotlin.ExperimentalApi
+import io.opentelemetry.kotlin.export.OperationResultCode
+import io.opentelemetry.kotlin.export.TelemetryCloseable
 import java.net.ServerSocket
+import java.util.logging.Handler
+import java.util.logging.Level
+import java.util.logging.LogRecord
+import java.util.logging.Logger
 import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Test
 
@@ -81,6 +92,62 @@ internal class OtelLoggingSpec {
         }
     }
 
+    @Test
+    fun `install via the no-arg overload and from the environment`() {
+        shouldNotThrowAny {
+            // Both resolve to the default endpoint. Nothing is listening and no records are
+            // emitted, so this exercises the wiring without exporting anything.
+            OtelLogging.installOtlpHttp().close()
+            OtelLogging.fromEnvironment().close()
+        }
+    }
+
+    @Test
+    fun `warn when the SDK is not closeable`() {
+        val (logger, records) = capturingLogger()
+        OtelLogging.reportShutdown(sdk = Any(), result = null, logger = logger)
+        records shouldHaveSize 1
+        records.first().level shouldBe Level.WARNING
+        records.first().message shouldContain "not a TelemetryCloseable"
+    }
+
+    @Test
+    fun `warn when shutdown reports a failure`() {
+        val (logger, records) = capturingLogger()
+        OtelLogging.reportShutdown(closeableSdk, OperationResultCode.Failure, logger)
+        records shouldHaveSize 1
+        records.first().message shouldContain "reported a failure"
+    }
+
+    @Test
+    fun `stay silent on a successful shutdown`() {
+        val (logger, records) = capturingLogger()
+        OtelLogging.reportShutdown(closeableSdk, OperationResultCode.Success, logger)
+        records shouldHaveSize 0
+    }
+
     /** Returns a currently-free local TCP port. */
     private fun freePort(): Int = ServerSocket(0).use { it.localPort }
+
+    /** A logger that records what it publishes, with parent handlers disabled. */
+    private fun capturingLogger(): Pair<Logger, List<LogRecord>> {
+        val records = mutableListOf<LogRecord>()
+        val logger = Logger.getAnonymousLogger().apply {
+            useParentHandlers = false
+            addHandler(object : Handler() {
+                override fun publish(record: LogRecord) { records += record }
+                override fun flush() = Unit
+                override fun close() = Unit
+            })
+        }
+        return logger to records
+    }
+
+    private companion object {
+        /** A minimal `TelemetryCloseable` SDK stub for shutdown-reporting tests. */
+        private val closeableSdk = object : TelemetryCloseable {
+            override suspend fun forceFlush() = OperationResultCode.Success
+            override suspend fun shutdown() = OperationResultCode.Success
+        }
+    }
 }

From f2f6cff536cc76078fdeb0906c5c426f27f9f166 Mon Sep 17 00:00:00 2001
From: Alexander Yevsyukov <alexander.yevsyukov@teamdev.com>
Date: Sun, 28 Jun 2026 23:11:52 +0100
Subject: [PATCH 20/20] Mark `reportShutdown` as `@VisibleForTesting`

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../io/spine/logging/backend/otel/bootstrap/OtelLogging.kt      | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt b/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt
index c9466c2c..2f802708 100644
--- a/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt
+++ b/backends/otel-backend-bootstrap/src/main/kotlin/io/spine/logging/backend/otel/bootstrap/OtelLogging.kt
@@ -35,6 +35,7 @@ import io.opentelemetry.kotlin.export.OperationResultCode
 import io.opentelemetry.kotlin.export.TelemetryCloseable
 import io.opentelemetry.kotlin.logging.export.batchLogRecordProcessor
 import io.opentelemetry.kotlin.logging.export.otlpHttpLogRecordExporter
+import io.spine.annotation.VisibleForTesting
 import io.spine.logging.backend.otel.OtelBackendSettings
 import java.util.logging.Logger
 import kotlinx.coroutines.runBlocking
@@ -111,6 +112,7 @@ public object OtelLogging {
      * Exposed as `internal` (with an injectable [logger]) so both outcomes can be verified
      * without provoking a real SDK failure.
      */
+    @VisibleForTesting
     internal fun reportShutdown(
         sdk: Any,
         result: OperationResultCode?,