write history only if the trigger is done

Author: sterlp

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## v1.5.0
+
+-  Adjusted transaction handling for trigger life cycle events
+-  Base event entry is only written for done/finished trigger
+
 ## v1.4.6 - (2025-01-08)
 
 -  Trigger history with more details - not waiting for the transaction

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

@@ -0,0 +1,14 @@
+package org.sterl.spring.persistent_tasks.api;
+
+import java.time.OffsetDateTime;
+
+public record TaskHistoryOverview(
+        String taskName,
+        long executionCount,
+        OffsetDateTime firstRun,
+        OffsetDateTime lastRun,
+        double maxDurationMs,
+        double minDurationMs,
+        double avgDurationMs
+        ) {
+}

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

@@ -10,6 +10,7 @@
 import org.springframework.data.domain.Sort;
 import org.springframework.data.domain.Sort.Direction;
 import org.springframework.lang.Nullable;
+import org.sterl.spring.persistent_tasks.api.TaskHistoryOverview;
 import org.sterl.spring.persistent_tasks.api.TriggerKey;
 import org.sterl.spring.persistent_tasks.api.TriggerStatus;
 import org.sterl.spring.persistent_tasks.history.model.TriggerHistoryDetailEntity;
@@ -116,4 +117,8 @@ private Pageable applyDefaultSortIfNeeded(Pageable page) {
         }
         return page;
     }
+
+    public List<TaskHistoryOverview> taskHistory() {
+        return triggerHistoryDetailRepository.listTaskHistoryOverview();
+    }
 }

core/src/main/java/org/sterl/spring/persistent_tasks/history/HistoryService.java

@@ -4,14 +4,14 @@
 
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.data.domain.Pageable;
-import org.springframework.data.domain.Sort.Direction;
 import org.springframework.data.web.PageableDefault;
 import org.springframework.data.web.PagedModel;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
+import org.sterl.spring.persistent_tasks.api.TaskHistoryOverview;
 import org.sterl.spring.persistent_tasks.api.Trigger;
 import org.sterl.spring.persistent_tasks.api.TriggerKey;
 import org.sterl.spring.persistent_tasks.history.HistoryService;
@@ -32,12 +32,16 @@ public List<Trigger> listInstances(@PathVariable("instanceId") long instanceId)
         return FromTriggerStateDetailEntity.INSTANCE.convert( //
                 historyService.findAllDetailsForInstance(instanceId));
     }
+    @GetMapping("task-history")
+    public List<TaskHistoryOverview> taskHistory() {
+        return historyService.taskHistory();
+    }
 
     @GetMapping("history")
     public PagedModel<Trigger> list(
             @RequestParam(name = "id", required = false) String id,
             @RequestParam(name = "taskName", required = false) String taskName,
-            @PageableDefault(size = 100, direction = Direction.DESC, sort = "id") Pageable pageable) {
+            @PageableDefault(size = 100) Pageable pageable) {
 
         return FromLastTriggerStateEntity.INSTANCE.toPage( //
                 historyService.findTriggerState(

core/src/main/java/org/sterl/spring/persistent_tasks/history/api/TriggerHistoryResource.java

@@ -39,26 +39,27 @@ public void onRunning(TriggerRunningEvent e) {
                 e.getClass().getSimpleName(),
                 e.key(), e.status());
 
-        execute(e.id(), e.data());
+        execute(e.id(), e.data(), false);
     }
 
-    // @Transactional(timeout = 10)
-    // @EventListener
     @TransactionalEventListener(phase = TransactionPhase.BEFORE_COMMIT)
     void onPersistentTaskEvent(TriggerLifeCycleEvent e) {
         if (e instanceof TriggerRunningEvent) return; // we have an own listener for that
         log.debug("Received event={} for {} new status={}",
                 e.getClass().getSimpleName(),
                 e.key(), e.status());
 
-        execute(e.id(), e.data());
+        
+        execute(e.id(), e.data(), e.isDone());
     }
 
-    public void execute(final long triggerId, final TriggerData data) {
-        final var state = new TriggerHistoryLastStateEntity();
-        state.setId(triggerId);
-        state.setData(data.copy());
-        triggerHistoryLastStateRepository.save(state);
+    public void execute(final long triggerId, final TriggerData data, boolean isDone) {
+        if (isDone) {
+            final var state = new TriggerHistoryLastStateEntity();
+            state.setId(triggerId);
+            state.setData(data.copy());
+            triggerHistoryLastStateRepository.save(state);
+        }
 
         var detail = new TriggerHistoryDetailEntity();
         detail.setInstanceId(triggerId);

core/src/main/java/org/sterl/spring/persistent_tasks/history/component/TriggerHistoryComponent.java

@@ -2,33 +2,29 @@
 
 import java.util.List;
 
-import org.springframework.data.domain.Page;
-import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
-import org.sterl.spring.persistent_tasks.api.HistoryOverview;
+import org.sterl.spring.persistent_tasks.api.TaskHistoryOverview;
 import org.sterl.spring.persistent_tasks.history.model.TriggerHistoryDetailEntity;
 
 public interface TriggerHistoryDetailRepository extends HistoryTriggerRepository<TriggerHistoryDetailEntity> {
 
     @Query("""
-            SELECT new org.sterl.spring.persistent_tasks.api.HistoryOverview(
-                     e.instanceId,
+            SELECT new org.sterl.spring.persistent_tasks.api.TaskHistoryOverview(
                      e.data.key.taskName,
                      count(1) as entryCount,
-                     MIN(e.data.start) as start,
-                     MAX(e.data.end) as end,
-                     MIN(e.data.createdTime) as createdTime,
-                     MAX(e.data.executionCount) as executionCount,
-                     AVG(e.data.runningDurationInMs) as runningDurationInMs
+                     MIN(e.data.runAt) as firstRun,
+                     MAX(e.data.runAt) as lastRun,
+                     MAX(e.data.runningDurationInMs) as maxDuration,
+                     MIN(e.data.runningDurationInMs) as minDuration,
+                     AVG(e.data.runningDurationInMs) as avgDuration
                    )
              FROM #{#entityName} e
-             GROUP BY 
-                 e.instanceId,
-                 e.data.key.taskName
-             ORDER BY end DESC, createdTime DESC
+             WHERE e.data.end IS NOT NULL
+             GROUP BY e.data.key.taskName
+             ORDER BY e.data.key.taskName ASC
              """)
-     Page<HistoryOverview> listHistoryOverview(Pageable page);
+     List<TaskHistoryOverview> listTaskHistoryOverview();
 
      @Query("""
              SELECT e

core/src/main/java/org/sterl/spring/persistent_tasks/history/repository/TriggerHistoryDetailRepository.java

@@ -39,7 +39,7 @@ public long count() {
     public PagedModel<Trigger> list(
             @RequestParam(name = "id", required = false) String id,
             @RequestParam(name = "taskName", required = false) String taskName,
-            @PageableDefault(size = 100, direction = Direction.DESC, sort = "id")
+            @PageableDefault(size = 100, direction = Direction.ASC, sort = "data.runAt")
             Pageable pageable) {
         return FromTriggerEntity.INSTANCE.toPage(
                 triggerService.findAllTriggers(

core/src/main/java/org/sterl/spring/persistent_tasks/trigger/api/TriggerResource.java

@@ -6,6 +6,7 @@
 import java.util.List;
 import java.util.Optional;
 
+import org.slf4j.event.Level;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.lang.NonNull;
 import org.springframework.stereotype.Component;
@@ -35,40 +36,51 @@ public class EditTriggerComponent {
     private final TriggerRepository triggerRepository;
 
     public Optional<TriggerEntity> completeTaskWithSuccess(TriggerKey key, Serializable state) {
-        return this.completeTaskWithStatus(key, state, null);
+        final Optional<TriggerEntity> result = triggerRepository.findByKey(key);
+
+        result.ifPresent(t -> {
+            t.complete(null);
+            publisher.publishEvent(new TriggerSuccessEvent(
+                    t.getId(), t.copyData(), state));
+            log.debug("Setting {} to status={}", key, t.getData().getStatus());
+            triggerRepository.delete(t);
+        });
+        return result;
     }
 
     /**
      * Sets success or error based on the fact if an exception is given or not.
      */
-    public Optional<TriggerEntity> completeTaskWithStatus(TriggerKey key, Serializable state, Exception e) {
+    public Optional<TriggerEntity> failTrigger(
+            TriggerKey key, 
+            Serializable state, 
+            Exception e,
+            OffsetDateTime retryAt) {
         final Optional<TriggerEntity> result = triggerRepository.findByKey(key);
 
+
         result.ifPresent(t -> {
+            log.atLevel(retryAt == null ? Level.ERROR : Level.WARN)
+            .setCause(e)
+            .log("{} failed, retryAt={}",
+                    key, retryAt == null ? "no" : retryAt);
             t.complete(e);
+            publisher.publishEvent(new TriggerFailedEvent(t.getId(), t.copyData(), state, e, retryAt));
 
-            if (t.getData().getStatus() == TriggerStatus.SUCCESS) {
-                publisher.publishEvent(new TriggerSuccessEvent(
-                        t.getId(), t.copyData(), state));
-                log.debug("Setting {} to status={} {}", key, t.getData().getStatus(),
-                        e == null ? "" : "error=" + e.getClass().getSimpleName());
+            if (retryAt == null) {
+                triggerRepository.delete(t);
             } else {
-                publisher.publishEvent(new TriggerFailedEvent(t.getId(), t.copyData(), state, e));
-                log.info("Setting {} to status={} {}", key, t.getData().getStatus(),
-                        e == null ? "" : "error=" + e.getClass().getSimpleName());
+                t.runAt(retryAt);
             }
-
         });
+        if (result.isEmpty()) {
+            log.error("Trigger with key={} not found and may be at a wrong state!",
+                    key, e);
+        }
 
         return result;
     }
 
-    public Optional<TriggerEntity> retryTrigger(TriggerKey id, OffsetDateTime retryAt) {
-        return triggerRepository //
-                .findByKey(id) //
-                .map(t -> t.runAt(retryAt));
-    }
-
     public Optional<TriggerEntity> cancelTask(TriggerKey id) {
         return triggerRepository //
                 .findByKey(id) //