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]