This is an automated email from the ASF dual-hosted git repository.

martinweiler pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/incubator-kie.git


The following commit(s) were added to refs/heads/main by this push:
     new b33c7f1c741 [incubator-kie#7275] Fix timestamps for enter and exit 
node events (#7276)
b33c7f1c741 is described below

commit b33c7f1c741508d424e81532e80c6feb92877d9d
Author: Martin Weiler <[email protected]>
AuthorDate: Mon Nov 16 12:07:41 2026 -0600

    [incubator-kie#7275] Fix timestamps for enter and exit node events (#7276)
---
 .../impl/adapter/AbstractDataEventAdapter.java     |  20 +++-
 .../event/impl/adapter/NodeEventDateTest.java      | 127 +++++++++++++++++++++
 2 files changed, 146 insertions(+), 1 deletion(-)

diff --git 
a/kogito-api/kogito-events-core/src/main/java/org/kie/kogito/event/impl/adapter/AbstractDataEventAdapter.java
 
b/kogito-api/kogito-events-core/src/main/java/org/kie/kogito/event/impl/adapter/AbstractDataEventAdapter.java
index 4015253defb..4d511347d48 100644
--- 
a/kogito-api/kogito-events-core/src/main/java/org/kie/kogito/event/impl/adapter/AbstractDataEventAdapter.java
+++ 
b/kogito-api/kogito-events-core/src/main/java/org/kie/kogito/event/impl/adapter/AbstractDataEventAdapter.java
@@ -18,6 +18,7 @@
  */
 package org.kie.kogito.event.impl.adapter;
 
+import java.time.ZoneId;
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
@@ -117,6 +118,21 @@ public abstract class AbstractDataEventAdapter implements 
DataEventAdapter {
                 .build();
     }
 
+    /**
+     * Node events are adapted after the node logic has run (e.g. after a 
synchronous work item completes),
+     * so the adaptation time is not the time the node was actually entered or 
left.
+     * Use the times recorded by the node instance when available.
+     */
+    private static Date nodeEventDate(KogitoNodeInstance nodeInstance, int 
eventType) {
+        Date date = null;
+        if (eventType == ProcessInstanceNodeEventBody.EVENT_TYPE_ENTER) {
+            date = nodeInstance.getTriggerTime();
+        } else if (eventType != 
ProcessInstanceNodeEventBody.EVENT_TYPE_UPDATED) {
+            date = nodeInstance.getLeaveTime();
+        }
+        return date != null ? date : new Date();
+    }
+
     private String getHeader(Map<String, List<String>> headers, String key) {
         List<String> value = headers.get(key);
         return value != null ? value.get(0).toString() : null;
@@ -135,8 +151,9 @@ public abstract class AbstractDataEventAdapter implements 
DataEventAdapter {
         Map<String, Object> metadata = 
AdapterHelper.buildProcessMetadata((KogitoWorkflowProcessInstance) 
event.getProcessInstance());
         KogitoWorkflowProcessInstance pi = (KogitoWorkflowProcessInstance) 
event.getProcessInstance();
         KogitoNodeInstance nodeInstance = (KogitoNodeInstance) 
event.getNodeInstance();
+        Date eventDate = nodeEventDate(nodeInstance, eventType);
         ProcessInstanceNodeEventBody.Builder builder = 
ProcessInstanceNodeEventBody.create()
-                .eventDate(new Date())
+                .eventDate(eventDate)
                 .eventUser(event.getEventIdentity())
                 .eventType(eventType)
                 .processId(pi.getProcessId())
@@ -166,6 +183,7 @@ public abstract class AbstractDataEventAdapter implements 
DataEventAdapter {
         ProcessInstanceNodeEventBody body = builder.build();
 
         return ProcessInstanceNodeDataEvent.builder()
+                
.time(eventDate.toInstant().atZone(ZoneId.systemDefault()).toOffsetDateTime())
                 .source(AdapterHelper.buildSource(getConfig().service(), 
pi.getProcessId()))
                 .kogitoAddons(getConfig().addons().toString())
                 .kogitoIdentity(event.getEventIdentity())
diff --git 
a/kogito-api/kogito-events-core/src/test/java/org/kie/kogito/event/impl/adapter/NodeEventDateTest.java
 
b/kogito-api/kogito-events-core/src/test/java/org/kie/kogito/event/impl/adapter/NodeEventDateTest.java
new file mode 100644
index 00000000000..5e9f82f92ce
--- /dev/null
+++ 
b/kogito-api/kogito-events-core/src/test/java/org/kie/kogito/event/impl/adapter/NodeEventDateTest.java
@@ -0,0 +1,127 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.kie.kogito.event.impl.adapter;
+
+import java.util.Date;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.kie.api.event.process.ProcessNodeLeftEvent;
+import org.kie.api.event.process.ProcessNodeTriggeredEvent;
+import org.kie.kogito.Addons;
+import 
org.kie.kogito.event.impl.adapter.DataEventAdapter.DataEventAdapterConfig;
+import org.kie.kogito.event.process.ProcessInstanceNodeDataEvent;
+import org.kie.kogito.internal.process.runtime.KogitoNode;
+import org.kie.kogito.internal.process.runtime.KogitoNodeInstance;
+import org.kie.kogito.internal.process.runtime.KogitoWorkflowProcess;
+import org.kie.kogito.internal.process.runtime.KogitoWorkflowProcessInstance;
+import org.mockito.Mockito;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Node events are adapted after the node logic has run, so their timestamps 
must come from the
+ * times recorded by the node instance and not from the time of the adaptation.
+ */
+class NodeEventDateTest {
+
+    private static final long ENTER_MILLIS = 1_000_000L;
+    private static final long LEAVE_MILLIS = ENTER_MILLIS + 20_000L;
+
+    private KogitoWorkflowProcessInstance processInstance;
+    private KogitoNodeInstance nodeInstance;
+    private ProcessNodeEnteredEventDataEventAdapter enteredAdapter;
+    private ProcessNodeLeftEventDataEventAdapter leftAdapter;
+
+    @BeforeEach
+    void setUp() {
+        KogitoWorkflowProcess process = 
Mockito.mock(KogitoWorkflowProcess.class);
+        KogitoNode node = Mockito.mock(KogitoNode.class);
+        processInstance = Mockito.mock(KogitoWorkflowProcessInstance.class);
+        nodeInstance = Mockito.mock(KogitoNodeInstance.class);
+        Mockito.when(processInstance.getProcess()).thenReturn(process);
+        Mockito.when(nodeInstance.getNode()).thenReturn(node);
+
+        DataEventAdapterConfig config = new DataEventAdapterConfig("", 
Addons.EMTPY);
+        enteredAdapter = new ProcessNodeEnteredEventDataEventAdapter();
+        enteredAdapter.setup(config);
+        leftAdapter = new ProcessNodeLeftEventDataEventAdapter();
+        leftAdapter.setup(config);
+    }
+
+    @Test
+    void enterEventUsesNodeTriggerTime() {
+        Mockito.when(nodeInstance.getTriggerTime()).thenReturn(new 
Date(ENTER_MILLIS));
+
+        ProcessInstanceNodeDataEvent event = (ProcessInstanceNodeDataEvent) 
enteredAdapter.adapt(triggeredEvent());
+
+        assertThat(event.getData().getEventDate()).isEqualTo(new 
Date(ENTER_MILLIS));
+        
assertThat(event.getTime().toInstant().toEpochMilli()).isEqualTo(ENTER_MILLIS);
+    }
+
+    @Test
+    void exitEventUsesNodeLeaveTime() {
+        Mockito.when(nodeInstance.getTriggerTime()).thenReturn(new 
Date(ENTER_MILLIS));
+        Mockito.when(nodeInstance.getLeaveTime()).thenReturn(new 
Date(LEAVE_MILLIS));
+
+        ProcessInstanceNodeDataEvent event = (ProcessInstanceNodeDataEvent) 
leftAdapter.adapt(leftEvent());
+
+        assertThat(event.getData().getEventDate()).isEqualTo(new 
Date(LEAVE_MILLIS));
+        
assertThat(event.getTime().toInstant().toEpochMilli()).isEqualTo(LEAVE_MILLIS);
+    }
+
+    @Test
+    void enterAndExitEventsKeepTheDurationBetweenTriggerAndLeave() {
+        Mockito.when(nodeInstance.getTriggerTime()).thenReturn(new 
Date(ENTER_MILLIS));
+        Mockito.when(nodeInstance.getLeaveTime()).thenReturn(new 
Date(LEAVE_MILLIS));
+
+        ProcessInstanceNodeDataEvent enter = (ProcessInstanceNodeDataEvent) 
enteredAdapter.adapt(triggeredEvent());
+        ProcessInstanceNodeDataEvent exit = (ProcessInstanceNodeDataEvent) 
leftAdapter.adapt(leftEvent());
+
+        assertThat(exit.getTime().toInstant().toEpochMilli() - 
enter.getTime().toInstant().toEpochMilli()).isEqualTo(20_000L);
+    }
+
+    @Test
+    void fallsBackToCurrentTimeWhenNodeTimesAreNotAvailable() {
+        long before = System.currentTimeMillis();
+
+        ProcessInstanceNodeDataEvent enter = (ProcessInstanceNodeDataEvent) 
enteredAdapter.adapt(triggeredEvent());
+        ProcessInstanceNodeDataEvent exit = (ProcessInstanceNodeDataEvent) 
leftAdapter.adapt(leftEvent());
+
+        long after = System.currentTimeMillis();
+        assertThat(enter.getData().getEventDate().getTime()).isBetween(before, 
after);
+        assertThat(exit.getData().getEventDate().getTime()).isBetween(before, 
after);
+        
assertThat(enter.getTime().toInstant().toEpochMilli()).isBetween(before, after);
+        
assertThat(exit.getTime().toInstant().toEpochMilli()).isBetween(before, after);
+    }
+
+    private ProcessNodeTriggeredEvent triggeredEvent() {
+        ProcessNodeTriggeredEvent event = 
Mockito.mock(ProcessNodeTriggeredEvent.class);
+        Mockito.when(event.getProcessInstance()).thenReturn(processInstance);
+        Mockito.when(event.getNodeInstance()).thenReturn(nodeInstance);
+        return event;
+    }
+
+    private ProcessNodeLeftEvent leftEvent() {
+        ProcessNodeLeftEvent event = Mockito.mock(ProcessNodeLeftEvent.class);
+        Mockito.when(event.getProcessInstance()).thenReturn(processInstance);
+        Mockito.when(event.getNodeInstance()).thenReturn(nodeInstance);
+        return event;
+    }
+}


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to