Add MDC to log4j

src/main/kotlin/eventDemo/app/command/GameCommandHandler.kt

@@ -11,6 +11,7 @@ import eventDemo.app.notification.Notification
 import eventDemo.libs.command.CommandId
 import eventDemo.libs.command.CommandStreamChannel
 import io.github.oshai.kotlinlogging.KotlinLogging
+import io.github.oshai.kotlinlogging.withLoggingContext
 import kotlinx.coroutines.channels.ReceiveChannel
 import kotlinx.coroutines.channels.SendChannel
 import java.util.UUID
@@ -56,19 +57,14 @@ class GameCommandHandler(
     player: Player,
     incomingCommandChannel: ReceiveChannel<GameCommand>,
     channelNotification: SendChannel<Notification>,
-  ) =
+  ) {
     commandStreamChannel.process(incomingCommandChannel) { command ->
+      withLoggingContext("command" to command.toString()) {
         if (command.payload.player.id != player.id) {
-        logger.atWarn {
+          logger.warn { "Handle command Refuse, the player of the command is not the same" }
-          message = "Handle command Refuse, the player of the command is not the same: $command"
-          payload = mapOf("command" to command)
-        }
           channelNotification.sendError(command)("You are not the author of this command\n")
         } else {
-        logger.atInfo {
+          logger.info { "Handle command" }
-          message = "Handle command: $command"
-          payload = mapOf("command" to command)
-        }
           try {
             val eventBuilder = runner.run(command)
 
@@ -77,49 +73,38 @@ class GameCommandHandler(
                 .also { eventCommandMap.set(it.eventId, channelNotification, command.id) }
             }
           } catch (e: CommandException) {
-          logger.atWarn {
+            logger.warn(e) { e.message }
-            message = e.message
-            payload = mapOf("command" to command)
-          }
             channelNotification.sendError(command)(e.message)
           }
         }
       }
     }
+  }
+}
 
 private fun SendChannel<Notification>.sendSuccess(commandId: CommandId): suspend () -> Unit =
   {
     val logger = KotlinLogging.logger { }
     CommandSuccessNotification(commandId = commandId)
       .also { notification ->
-        logger.atDebug {
+        withLoggingContext("notification" to notification.toString(), "commandId" to commandId.toString()) {
-          message = "Notification SUCCESS sent"
+          logger.debug { "Notification SUCCESS sent" }
-          payload =
-            mapOf(
-              "notification" to notification,
-              "commandId" to commandId,
-            )
-        }
           send(notification)
         }
       }
+  }
 
 private fun SendChannel<Notification>.sendError(command: GameCommand): suspend (String) -> Unit =
   {
     val logger = KotlinLogging.logger { }
     CommandErrorNotification(message = it, command = command)
       .also { notification ->
-        logger.atWarn {
+        withLoggingContext("notification" to notification.toString(), "command" to command.toString()) {
-          message = "Notification ERROR sent: ${notification.message}"
+          logger.warn { "Notification ERROR sent: ${notification.message}" }
-          payload =
-            mapOf(
-              "notification" to notification,
-              "command" to command,
-            )
-        }
           send(notification)
         }
       }
+  }
 
 /**
  * Map to record the command that triggered the event.

src/main/kotlin/eventDemo/app/command/GameCommandRoute.kt

@@ -5,6 +5,7 @@ import eventDemo.app.eventListener.PlayerNotificationEventListener
 import eventDemo.app.notification.Notification
 import eventDemo.libs.fromFrameChannel
 import eventDemo.libs.toObjectChannel
+import io.github.oshai.kotlinlogging.withLoggingContext
 import io.ktor.server.application.ApplicationCall
 import io.ktor.server.auth.authenticate
 import io.ktor.server.auth.jwt.JWTPrincipal
@@ -25,6 +26,7 @@ fun Route.gameSocket(
     webSocket("/game") {
       val currentPlayer = call.getPlayer()
       val outgoingFrameChannel: SendChannel<Notification> = fromFrameChannel(outgoing)
+      withLoggingContext("currentPlayer" to currentPlayer.toString()) {
         GlobalScope.launch {
           commandHandler.handle(
             currentPlayer,
@@ -36,6 +38,7 @@ fun Route.gameSocket(
       }
     }
   }
+}
 
 private fun ApplicationCall.getPlayer() =
   principal<JWTPrincipal>()!!.run {

src/main/kotlin/eventDemo/app/event/GameEventHandler.kt

@@ -3,6 +3,7 @@ package eventDemo.app.event
 import eventDemo.app.entity.GameId
 import eventDemo.app.event.event.GameEvent
 import eventDemo.libs.event.VersionBuilder
+import io.github.oshai.kotlinlogging.withLoggingContext
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.ConcurrentLinkedQueue
 import java.util.concurrent.locks.ReentrantLock
@@ -31,6 +32,7 @@ class GameEventHandler(
     aggregateId: GameId,
     buildEvent: (version: Int) -> GameEvent,
   ): GameEvent =
+    withLoggingContext("aggregateId" to aggregateId.toString()) {
       locks
         // Get lock for the aggregate
         .computeIfAbsent(aggregateId) { ReentrantLock() }
@@ -38,13 +40,20 @@ class GameEventHandler(
           // Build event with the version
           buildEvent(versionBuilder.buildNextVersion(aggregateId))
             // then publish it to the event store
-          .also { eventStore.publish(it) }
+            .also {
+              withLoggingContext("event" to it.toString()) {
+                eventStore.publish(it)
+              }
+            }
         }.also { event ->
+          withLoggingContext("event" to event.toString()) {
             // Build the projections
             projectionsBuilders.forEach { it(event) }
             // Publish to the bus
             eventBus.publish(event)
           }
         }
+    }
+}
 
 typealias GameProjectionBuilder = (GameEvent) -> Unit

src/main/kotlin/eventDemo/app/event/GameEventStream.kt

@@ -1,15 +0,0 @@
-package eventDemo.app.event
-
-import eventDemo.app.event.event.GameEvent
-import eventDemo.libs.event.EventStream
-
-/**
- * A stream to publish and read the played card event.
- */
-class GameEventStream(
-  private val eventStream: EventStream<GameEvent>,
-) : EventStream<GameEvent> by eventStream {
-  override fun publish(event: GameEvent) {
-    eventStream.publish(event)
-  }
-}

src/main/kotlin/eventDemo/app/event/projection/GameStateBuilder.kt

@@ -18,7 +18,7 @@ fun GameState.apply(event: GameEvent): GameState =
     if (event is PlayerActionEvent) {
       if (state.currentPlayerTurn != event.player) {
         logger.atError {
-          message = "Inconsistent player turn. CurrentPlayerTurn: $state.currentPlayerTurn | Player: ${event.player}"
+          message = "Inconsistent player turn"
           payload =
             mapOf(
               "CurrentPlayerTurn" to (state.currentPlayerTurn ?: "No currentPlayerTurn"),

src/main/kotlin/eventDemo/app/event/projection/ProjectionSnapshotRepositoryInMemory.kt

@@ -5,6 +5,7 @@ import eventDemo.libs.event.Event
 import eventDemo.libs.event.EventStore
 import eventDemo.libs.event.EventStream
 import io.github.oshai.kotlinlogging.KotlinLogging
+import io.github.oshai.kotlinlogging.withLoggingContext
 import kotlinx.datetime.Clock
 import kotlinx.datetime.Instant
 import java.util.concurrent.ConcurrentHashMap
@@ -176,13 +177,13 @@ class ProjectionSnapshotRepositoryInMemory<E : Event<ID>, P : Projection<ID>, ID
     aggregateId: ID,
     eventsToApply: Set<E>,
   ): P =
-    eventsToApply
+    eventsToApply.fold(this ?: initialStateBuilder(aggregateId), applyToProjectionSecure)
-      .fold(this ?: initialStateBuilder(aggregateId), applyToProjectionSecure)
 
   /**
    * Wrap the [applyToProjection] lambda to avoid duplicate apply of the same event.
    */
   private val applyToProjectionSecure: P.(event: E) -> P = { event ->
+    withLoggingContext("event" to event.toString(), "projection" to this.toString()) {
       if (event.version == lastEventVersion + 1) {
         applyToProjection(event)
       } else if (event.version <= lastEventVersion) {
@@ -193,3 +194,4 @@ class ProjectionSnapshotRepositoryInMemory<E : Event<ID>, P : Projection<ID>, ID
       }
     }
   }
+}

src/main/kotlin/eventDemo/app/eventListener/PlayerNotificationEventListener.kt

@@ -24,6 +24,7 @@ import eventDemo.app.notification.TheGameWasStartedNotification
 import eventDemo.app.notification.WelcomeToTheGameNotification
 import eventDemo.app.notification.YourNewCardNotification
 import io.github.oshai.kotlinlogging.KotlinLogging
+import io.github.oshai.kotlinlogging.withLoggingContext
 import kotlinx.coroutines.channels.SendChannel
 import kotlinx.coroutines.channels.trySendBlocking
 
@@ -38,22 +39,19 @@ class PlayerNotificationEventListener(
     currentPlayer: Player,
   ) {
     eventBus.subscribe { event: GameEvent ->
+      withLoggingContext("event" to event.toString()) {
         val currentState = gameStateRepository.getUntil(event)
 
         fun Notification.send() {
+          withLoggingContext("notification" to this.toString()) {
             if (currentState.players.contains(currentPlayer)) {
               // Only notify players who have already joined the game.
               outgoingNotificationChannel.trySendBlocking(this)
-          logger.atInfo {
+              logger.info { "Notification was SEND" }
-            message = "Notification for player ${currentPlayer.name} was SEND: ${this@send}"
-            payload = mapOf("notification" to this@send, "event" to event)
-          }
             } else {
               // Rare use case, when a connexion is created with the channel,
               // but the player was not already join in the game
-          logger.atWarn {
+              logger.warn { "Notification was SKIP, no player on the game" }
-            message = "Notification for player ${currentPlayer.name} was SKIP, No player on the game: ${this@send}"
-            payload = mapOf("notification" to this@send, "event" to event)
             }
           }
         }
@@ -143,3 +141,4 @@ class PlayerNotificationEventListener(
       }
     }
   }
+}

src/main/kotlin/eventDemo/app/eventListener/ReactionEventListener.kt

@@ -9,6 +9,7 @@ import eventDemo.app.event.event.PlayerWinEvent
 import eventDemo.app.event.projection.GameState
 import eventDemo.app.event.projection.GameStateRepository
 import io.github.oshai.kotlinlogging.KotlinLogging
+import io.github.oshai.kotlinlogging.withLoggingContext
 
 class ReactionEventListener(
   private val eventBus: GameEventBus,
@@ -24,13 +25,15 @@ class ReactionEventListener(
 
   fun init() {
     eventBus.subscribe(priority) { event: GameEvent ->
+      withLoggingContext("event" to event.toString()) {
         val state = gameStateRepository.getUntil(event)
         sendStartGameEvent(state, event)
-      sendWinnerEvent(state, event)
+        sendWinnerEvent(state)
+      }
     }
   }
 
-  private suspend fun sendStartGameEvent(
+  private fun sendStartGameEvent(
     state: GameState,
     event: GameEvent,
   ) {
@@ -44,12 +47,8 @@ class ReactionEventListener(
           )
         }
       logger.atInfo {
-        message = "Reaction event was Send $reactionEvent on reaction of: $event"
+        message = "Reaction event was Send"
-        payload =
+        payload = mapOf("reactionEvent" to reactionEvent)
-          mapOf(
-            "event" to event,
-            "reactionEvent" to reactionEvent,
-          )
       }
     } else {
       if (event is PlayerReadyEvent) {
@@ -58,10 +57,7 @@ class ReactionEventListener(
     }
   }
 
-  private fun sendWinnerEvent(
+  private fun sendWinnerEvent(state: GameState) {
-    state: GameState,
-    event: GameEvent,
-  ) {
     val winner = state.playerHasNoCardLeft().firstOrNull()
     if (winner != null) {
       val reactionEvent =
@@ -74,12 +70,8 @@ class ReactionEventListener(
         }
 
       logger.atInfo {
-        message = "Reaction event was Send $reactionEvent on reaction of: $event"
+        message = "Reaction event was Send"
-        payload =
+        payload = mapOf("reactionEvent" to reactionEvent)
-          mapOf(
-            "event" to event,
-            "reactionEvent" to reactionEvent,
-          )
       }
     }
   }

src/main/kotlin/eventDemo/app/eventListener/SuccessNotificationEventListener.kt

@@ -1,24 +0,0 @@
-package eventDemo.app.eventListener
-
-import eventDemo.app.notification.CommandSuccessNotification
-import eventDemo.app.notification.Notification
-import eventDemo.libs.command.CommandId
-import io.github.oshai.kotlinlogging.KotlinLogging
-import kotlinx.coroutines.channels.SendChannel
-
-private fun SendChannel<Notification>.successNotifier(commandId: CommandId): suspend () -> Unit =
-  {
-    val logger = KotlinLogging.logger { }
-    CommandSuccessNotification(commandId = commandId)
-      .let { notification ->
-        logger.atDebug {
-          message = "Notification SUCCESS sent"
-          payload =
-            mapOf(
-              "notification" to notification,
-              "commandId" to commandId,
-            )
-        }
-        send(notification)
-      }
-  }

src/main/kotlin/eventDemo/libs/command/CommandStreamChannel.kt

@@ -1,6 +1,7 @@
 package eventDemo.libs.command
 
 import io.github.oshai.kotlinlogging.KotlinLogging
+import io.github.oshai.kotlinlogging.withLoggingContext
 import kotlinx.coroutines.channels.ReceiveChannel
 
 /**
@@ -20,15 +21,14 @@ class CommandStreamChannel<C : Command>(
     action: CommandBlock<C>,
   ) {
     for (command in incoming) {
+      withLoggingContext("command" to command.toString()) {
         try {
           controller.runOnlyOnce(command) {
             // Wrap action to add logs
             runAndLogStatus(command, action)
           }
         } catch (e: CommandRunnerController.Exception) {
-        logger.atWarn {
+          logger.warn { e.message }
-          message = e.message
-          payload = mapOf("command" to command)
         }
       }
     }
@@ -40,16 +40,9 @@ class CommandStreamChannel<C : Command>(
   ) {
     val actionResult = runCatching { action(command) }
     if (actionResult.isFailure) {
-      logger.atWarn {
+      logger.warn(actionResult.exceptionOrNull()) { "Compute command FAILED" }
-        message = "Compute command FAILED: $command"
-        payload = mapOf("command" to command)
-        cause = actionResult.exceptionOrNull()
-      }
     } else if (actionResult.isSuccess) {
-      logger.atInfo {
+      logger.info { "Compute command SUCCESS" }
-        message = "Compute command SUCCESS: $command"
-        payload = mapOf("command" to command)
-      }
     }
   }
 }

src/main/kotlin/eventDemo/libs/event/EventBusInMemory.kt

@@ -1,5 +1,6 @@
 package eventDemo.libs.event
 
+import io.github.oshai.kotlinlogging.withLoggingContext
 import kotlinx.coroutines.runBlocking
 
 class EventBusInMemory<E : Event<ID>, ID : AggregateId> : EventBus<E, ID> {
@@ -10,10 +11,12 @@ class EventBusInMemory<E : Event<ID>, ID : AggregateId> : EventBus<E, ID> {
       .sortedByDescending { (priority, _) -> priority }
       .forEach { (_, block) ->
         runBlocking {
+          withLoggingContext("event" to event.toString()) {
             block(event)
           }
         }
       }
+  }
 
   override fun subscribe(
     priority: Int,

src/main/kotlin/eventDemo/libs/event/EventStreamInMemory.kt

@@ -1,6 +1,7 @@
 package eventDemo.libs.event
 
 import io.github.oshai.kotlinlogging.KotlinLogging
+import io.github.oshai.kotlinlogging.withLoggingContext
 import java.util.Queue
 import java.util.concurrent.ConcurrentLinkedQueue
 
@@ -16,15 +17,16 @@ class EventStreamInMemory<E : Event<*>> : EventStream<E> {
   override fun publish(event: E) {
     if (events.none { it.eventId == event.eventId }) {
       events.add(event)
-      logger.atInfo {
+      logger.info { "Event published" }
-        message = "Event published: $event"
-        payload = mapOf("event" to event)
-      }
     }
   }
 
   override fun publish(vararg events: E) {
-    events.forEach { publish(it) }
+    events.forEach {
+      withLoggingContext("event" to it.toString()) {
+        publish(it)
+      }
+    }
   }
 
   override fun readAll(): Set<E> =

src/main/kotlin/eventDemo/libs/event/VersionBuilderLocal.kt

@@ -1,6 +1,7 @@
 package eventDemo.libs.event
 
 import io.github.oshai.kotlinlogging.KotlinLogging
+import io.github.oshai.kotlinlogging.withLoggingContext
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.atomic.AtomicInteger
 
@@ -9,9 +10,11 @@ class VersionBuilderLocal : VersionBuilder {
   private val versions: ConcurrentHashMap<AggregateId, AtomicInteger> = ConcurrentHashMap()
 
   override fun buildNextVersion(aggregateId: AggregateId): Int =
+    withLoggingContext("aggregateId" to aggregateId.toString()) {
       versionOfAggregate(aggregateId)
         .addAndGet(1)
-      .also { logger.debug { "New version $it" } }
+        .also { logger.debug { "New event version $it" } }
+    }
 
   override fun getLastVersion(aggregateId: AggregateId): Int =
     versionOfAggregate(aggregateId).toInt()

src/main/resources/logback.xml

@@ -1,7 +1,7 @@
 <configuration>
     <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
         <encoder>
-            <pattern>%d{YYYY-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+            <pattern>%d{YYYY-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n > MDC=%mdc%n</pattern>
         </encoder>
     </appender>
     <root level="trace">