added interceptor to write task name and id to MDC logging context

Author: sterlp

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## v1.5.5
+
+-  Added MdcTriggerInterceptor
+
 ## v1.5.4 - (2025-01-14)
 
 -  adjusted trigger cols that the UI does not break

core/src/main/java/org/sterl/spring/persistent_tasks/api/TriggerKey.java

@@ -10,14 +10,16 @@
 import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
+import lombok.ToString;
 
 /**
  * Unique key of a trigger during it's execution. But it after that the same key
  * can be added if needed. Ensures that only one trigger with the same key
  * is currently scheduled for execution.
  */
 @Data
-@Builder(toBuilder = true)
+@ToString
+@Builder
 @NoArgsConstructor
 @AllArgsConstructor
 public class TriggerKey implements Serializable {

core/src/main/java/org/sterl/spring/persistent_tasks/exception/SpringPersistentTaskException.java

@@ -0,0 +1,19 @@
+package org.sterl.spring.persistent_tasks.exception;
+
+import lombok.Getter;
+
+public class SpringPersistentTaskException extends RuntimeException {
+    private static final long serialVersionUID = 1L;
+    @Getter
+    protected final Object state;
+
+    public SpringPersistentTaskException(String message, Object state, Throwable cause) {
+        super(message, cause);
+        this.state = state;
+    }
+
+    public SpringPersistentTaskException(String message, Object state) {
+        super(message);
+        this.state = state;
+    }
+}

core/src/main/java/org/sterl/spring/persistent_tasks/trigger/component/EditTriggerComponent.java

@@ -18,6 +18,7 @@
 import org.sterl.spring.persistent_tasks.trigger.event.TriggerAddedEvent;
 import org.sterl.spring.persistent_tasks.trigger.event.TriggerCanceledEvent;
 import org.sterl.spring.persistent_tasks.trigger.event.TriggerFailedEvent;
+import org.sterl.spring.persistent_tasks.trigger.event.TriggerRunningEvent;
 import org.sterl.spring.persistent_tasks.trigger.event.TriggerSuccessEvent;
 import org.sterl.spring.persistent_tasks.trigger.model.TriggerEntity;
 import org.sterl.spring.persistent_tasks.trigger.repository.TriggerRepository;
@@ -40,9 +41,9 @@ public Optional<TriggerEntity> completeTaskWithSuccess(TriggerKey key, Serializa
 
         result.ifPresent(t -> {
             t.complete(null);
+            log.debug("{} set to status={}", key, t.getData().getStatus());
             publisher.publishEvent(new TriggerSuccessEvent(
                     t.getId(), t.copyData(), state));
-            log.debug("Setting {} to status={}", key, t.getData().getStatus());
             triggerRepository.delete(t);
         });
         return result;
@@ -146,4 +147,10 @@ public int markTriggersAsRunning(Collection<TriggerKey> keys, String runOn) {
         return triggerRepository.markTriggersAsRunning(keys, runOn, 
                 OffsetDateTime.now(), TriggerStatus.RUNNING);
     }
+
+    public void triggerIsNowRunning(TriggerEntity trigger, Serializable state) {
+        if (!trigger.isRunning()) trigger.runOn(trigger.getRunningOn());
+        publisher.publishEvent(new TriggerRunningEvent(
+                trigger.getId(), trigger.copyData(), state, trigger.getRunningOn()));
+    }
 }

core/src/main/java/org/sterl/spring/persistent_tasks/trigger/component/RunTriggerComponent.java

@@ -1,18 +1,14 @@
 package org.sterl.spring.persistent_tasks.trigger.component;
 
-import java.io.Serializable;
 import java.time.OffsetDateTime;
 import java.util.Optional;
 
-import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.lang.Nullable;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
-import org.springframework.transaction.support.TransactionTemplate;
-import org.sterl.spring.persistent_tasks.api.PersistentTask;
 import org.sterl.spring.persistent_tasks.task.TaskService;
-import org.sterl.spring.persistent_tasks.trigger.event.TriggerRunningEvent;
+import org.sterl.spring.persistent_tasks.trigger.model.RunTaskWithStateCommand;
 import org.sterl.spring.persistent_tasks.trigger.model.TriggerEntity;
 
 import lombok.RequiredArgsConstructor;
@@ -25,7 +21,6 @@ public class RunTriggerComponent {
 
     private final TaskService taskService;
     private final EditTriggerComponent editTrigger;
-    private final ApplicationEventPublisher eventPublisher;
     private final StateSerializer serializer = new StateSerializer();
 
     /**
@@ -36,79 +31,50 @@ public Optional<TriggerEntity> execute(TriggerEntity trigger) {
         if (trigger == null) {
             return Optional.empty();
         }
+
         final var taskAndState = getTastAndState(trigger);
         // something went really wrong this trigger is crap
         if (taskAndState == null) return Optional.of(trigger);
 
         try {
-            return taskAndState.call();
+            return taskAndState.execute(editTrigger);
         } catch (Exception e) {
             return failTaskAndState(taskAndState, e);
         }
     }
 
     @Nullable
-    private TaskAndState getTastAndState(TriggerEntity trigger) {
+    private RunTaskWithStateCommand getTastAndState(TriggerEntity trigger) {
         try {
-            var task = taskService.assertIsKnown(trigger.newTaskId());
-            var trx = taskService.getTransactionTemplate(task);
-            var state = serializer.deserialize(trigger.getData().getState());
-            return new TaskAndState(task, trx, state, trigger);
+            final var task = taskService.assertIsKnown(trigger.newTaskId());
+            final var trx = taskService.getTransactionTemplate(task);
+            final var state = serializer.deserialize(trigger.getData().getState());
+            return new RunTaskWithStateCommand(task, trx, state, trigger);
         } catch (Exception e) {
-            // this trigger is somehow crap, no retry and done.
-            failTaskAndState(new TaskAndState(null, Optional.empty(), null, trigger), e);
+            failTaskAndState(new RunTaskWithStateCommand(null, Optional.empty(), null, trigger), e);
             return null;
         }
     }
 
-    private Optional<TriggerEntity> failTaskAndState(TaskAndState taskAndState, Exception e) {
+    private Optional<TriggerEntity> failTaskAndState(RunTaskWithStateCommand runTaskWithStateCommand, Exception e) {
 
-        var trigger = taskAndState.trigger;
-        var task = taskAndState.persistentTask;
+        var trigger = runTaskWithStateCommand.trigger();
+        var task = runTaskWithStateCommand.task();
         Optional<TriggerEntity> result;
 
         if (task != null 
                 && task.retryStrategy().shouldRetry(trigger.getData().getExecutionCount(), e)) {
 
             final OffsetDateTime retryAt = task.retryStrategy().retryAt(trigger.getData().getExecutionCount(), e);
 
-            result = editTrigger.failTrigger(trigger.getKey(), taskAndState.state, e, retryAt);
+            result = editTrigger.failTrigger(trigger.getKey(), runTaskWithStateCommand.state(), e, retryAt);
 
         } else {
             log.error("{} failed, no more retries! {}", trigger.getKey(), 
                     e == null ? "No exception given." : e.getMessage(), e);
 
-            result = editTrigger.failTrigger(trigger.getKey(), taskAndState.state, e, null);
+            result = editTrigger.failTrigger(trigger.getKey(), runTaskWithStateCommand.state(), e, null);
         }
         return result;
     }
-    
-    @RequiredArgsConstructor
-    class TaskAndState {
-        final PersistentTask<Serializable> persistentTask;
-        final Optional<TransactionTemplate> trx;
-        final Serializable state;
-        final TriggerEntity trigger;
-
-        Optional<TriggerEntity> call() {
-            if (trx.isPresent()) {
-                return trx.get().execute(t -> runTask());
-            } else {
-                return runTask();
-            }
-        }
-
-        private Optional<TriggerEntity> runTask() {
-            if (!trigger.isRunning()) trigger.runOn(trigger.getRunningOn());
-            eventPublisher.publishEvent(new TriggerRunningEvent(
-                    trigger.getId(), trigger.copyData(), state, trigger.getRunningOn()));
-
-            persistentTask.accept(state);
-
-            var result = editTrigger.completeTaskWithSuccess(trigger.getKey(), state);
-            editTrigger.deleteTrigger(trigger);
-
-            return result;
-        }
-    }
 }

core/src/main/java/org/sterl/spring/persistent_tasks/trigger/component/StateSerializer.java

@@ -7,10 +7,27 @@
 import java.io.ObjectOutputStream;
 import java.io.Serializable;
 
+import org.sterl.spring.persistent_tasks.exception.SpringPersistentTaskException;
+
 import lombok.extern.slf4j.Slf4j;
 
 @Slf4j
 public class StateSerializer {
+    public static class DeSerializationFailedException extends SpringPersistentTaskException {
+        private static final long serialVersionUID = 1L;
+
+        public DeSerializationFailedException(byte[] bytes, Exception e) {
+            super("Failed to deserialize state of length " + bytes.length, bytes, e);
+        }
+    }
+    
+    public static class SerializationFailedException extends SpringPersistentTaskException {
+        private static final long serialVersionUID = 1L;
+
+        public SerializationFailedException(Serializable obj, Exception e) {
+            super("Failed to serialize state " + obj.getClass(), obj, e);
+        }
+    }
 
     public byte[] serialize(final Serializable obj) {
         if (obj == null) {
@@ -23,7 +40,7 @@ public byte[] serialize(final Serializable obj) {
             out.writeObject(obj);
             return bos.toByteArray();
         } catch (Exception ex) {
-            throw new RuntimeException(ex);
+            throw new SerializationFailedException(obj, ex);
         }
     }
 
@@ -36,7 +53,7 @@ public Serializable deserialize(byte[] bytes) {
         try (ObjectInput in = new ObjectInputStream(bis)) {
             return (Serializable)in.readObject();
         } catch (Exception ex) {
-            throw new RuntimeException("Failed to deserialize state of length " + bytes.length, ex);
+            throw new DeSerializationFailedException(bytes, ex);
         }
     }
 

core/src/main/java/org/sterl/spring/persistent_tasks/trigger/interceptor/MdcTriggerInterceptor.java

@@ -0,0 +1,34 @@
+package org.sterl.spring.persistent_tasks.trigger.interceptor;
+
+import org.slf4j.MDC;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Component;
+import org.sterl.spring.persistent_tasks.trigger.event.TriggerFailedEvent;
+import org.sterl.spring.persistent_tasks.trigger.event.TriggerRunningEvent;
+import org.sterl.spring.persistent_tasks.trigger.event.TriggerSuccessEvent;
+
+/**
+ * Adds task name and id to the {@link MDC} context.
+ */
+@Component
+public class MdcTriggerInterceptor {
+
+    public static final String TASK_NAME = "taskName";
+    public static final String TASK_ID = "taskId";
+
+    @EventListener
+    public void beforeRun(TriggerRunningEvent data) {
+        MDC.put(TASK_NAME, data.key().getTaskName());
+        MDC.put(TASK_ID, data.key().getId());
+    }
+    @EventListener
+    public void onFailed(TriggerFailedEvent data) {
+        MDC.remove(TASK_NAME);
+        MDC.remove(TASK_ID);
+    }
+    @EventListener
+    public void onSuccess(TriggerSuccessEvent data) {
+        MDC.remove(TASK_NAME);
+        MDC.remove(TASK_ID);
+    }
+}

core/src/main/java/org/sterl/spring/persistent_tasks/trigger/model/RunTaskWithStateCommand.java

@@ -0,0 +1,41 @@
+package org.sterl.spring.persistent_tasks.trigger.model;
+
+import java.io.Serializable;
+import java.util.Optional;
+
+import org.springframework.transaction.support.TransactionTemplate;
+import org.sterl.spring.persistent_tasks.api.PersistentTask;
+import org.sterl.spring.persistent_tasks.shared.model.HasTriggerData;
+import org.sterl.spring.persistent_tasks.shared.model.TriggerData;
+import org.sterl.spring.persistent_tasks.trigger.component.EditTriggerComponent;
+
+public record RunTaskWithStateCommand (
+        PersistentTask<Serializable> task,
+        Optional<TransactionTemplate> trx,
+        Serializable state,
+        TriggerEntity trigger) implements HasTriggerData {
+
+    public Optional<TriggerEntity> execute(EditTriggerComponent editTrigger) {
+        if (trx.isPresent()) {
+            return trx.get().execute(t -> runTask(editTrigger));
+        } else {
+            return runTask(editTrigger);
+        }
+    }
+
+    private Optional<TriggerEntity> runTask(EditTriggerComponent editTrigger) {
+        editTrigger.triggerIsNowRunning(trigger, state);
+
+        task.accept(state);
+
+        var result = editTrigger.completeTaskWithSuccess(trigger.getKey(), state);
+        editTrigger.deleteTrigger(trigger);
+
+        return result;
+    }
+
+    @Override
+    public TriggerData getData() {
+        return trigger.getData();
+    }
+}

core/src/test/java/org/sterl/spring/persistent_tasks/AbstractSpringTest.java

@@ -16,6 +16,7 @@
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Primary;
 import org.springframework.stereotype.Component;
+import org.springframework.test.context.event.RecordApplicationEvents;
 import org.springframework.transaction.PlatformTransactionManager;
 import org.springframework.transaction.support.TransactionTemplate;
 import org.sterl.spring.persistent_tasks.api.PersistentTask;
@@ -40,6 +41,7 @@
 
 // @ActiveProfiles("mssql") // postgres mssql mariadb mysql
 @SpringBootTest(classes = SampleApp.class, webEnvironment = WebEnvironment.RANDOM_PORT)
+@RecordApplicationEvents
 public class AbstractSpringTest {
 
     @Autowired