Add waitTimerInfo field to Workflow History Group (cadence-workflow#1035)

* Add waitTimerInfo field to Workflow History Group, which contains the expected duration of a task/group in the workflow's history, and the prefix to show with it
* Populate this field for Timer and Workflow Started groups
* (misc) Use the waitTimerInfo to render timer end time in Timeline Chart

Author: adhityamamallan

src/views/workflow-history/helpers/get-history-group-from-events/__tests__/get-single-event-group-from-events.test.ts

@@ -230,4 +230,56 @@ describe('getSingleEventGroupFromEvents', () => {
       'newExecutionRunId',
     ]);
   });
+
+  it('should calculate expectedEndTimeInfo for workflow execution started events with firstDecisionTaskBackoff', () => {
+    const group = getSingleEventGroupFromEvents([startWorkflowExecutionEvent]);
+
+    expect(group.expectedEndTimeInfo).toEqual({
+      timeMs: 1724747370549.3777,
+      prefix: 'Starts in',
+    });
+  });
+
+  it('should not calculate expectedEndTimeInfo for non-workflow-started events', () => {
+    const nonStartedEvents = [
+      signalWorkflowExecutionEvent,
+      recordMarkerExecutionEvent,
+      failWorkflowExecutionEvent,
+      completeWorkflowExecutionEvent,
+    ];
+
+    for (const event of nonStartedEvents) {
+      const group = getSingleEventGroupFromEvents([event]);
+      expect(group.expectedEndTimeInfo).toBeUndefined();
+    }
+  });
+
+  it('should not calculate expectedEndTimeInfo for workflow started events with zero firstDecisionTaskBackoff', () => {
+    const eventWithoutBackoff = {
+      ...startWorkflowExecutionEvent,
+      workflowExecutionStartedEventAttributes: {
+        ...startWorkflowExecutionEvent.workflowExecutionStartedEventAttributes,
+        firstDecisionTaskBackoff: {
+          seconds: '0',
+          nanos: 0,
+        },
+      },
+    };
+
+    const group = getSingleEventGroupFromEvents([eventWithoutBackoff]);
+    expect(group.expectedEndTimeInfo).toBeUndefined();
+  });
+
+  it('should not calculate expectedEndTimeInfo for workflow started events without firstDecisionTaskBackoff', () => {
+    const eventWithoutBackoff = {
+      ...startWorkflowExecutionEvent,
+      workflowExecutionStartedEventAttributes: {
+        ...startWorkflowExecutionEvent.workflowExecutionStartedEventAttributes,
+        firstDecisionTaskBackoff: null,
+      },
+    };
+
+    const group = getSingleEventGroupFromEvents([eventWithoutBackoff]);
+    expect(group.expectedEndTimeInfo).toBeUndefined();
+  });
 });

src/views/workflow-history/helpers/get-history-group-from-events/__tests__/get-timer-group-from-events.test.ts

@@ -136,19 +136,55 @@ describe('getTimerGroupFromEvents', () => {
     const group = getTimerGroupFromEvents(events);
 
     // The started event should have summaryFields
-    const startedEventMetadata = group.eventsMetadata.find(
-      (metadata) => metadata.label === 'Started'
-    );
-    expect(startedEventMetadata?.summaryFields).toEqual([
+    const startedEventMetadata = group.eventsMetadata[0];
+    expect(startedEventMetadata.summaryFields).toEqual([
       'startToFireTimeoutSeconds',
     ]);
 
     // Other events should not have summaryFields
-    const otherEventsMetadata = group.eventsMetadata.filter(
-      (metadata) => metadata.label !== 'Started'
-    );
-    otherEventsMetadata.forEach((metadata) => {
-      expect(metadata.summaryFields).toBeUndefined();
+    const otherEventMetadata = group.eventsMetadata[1];
+    expect(otherEventMetadata.summaryFields).toBeUndefined();
+  });
+
+  it('should calculate expectedEndTimeInfo for started timer events without close event', () => {
+    const eventsWithoutClose: TimerHistoryEvent[] = [startTimerTaskEvent];
+    const group = getTimerGroupFromEvents(eventsWithoutClose);
+
+    expect(group.expectedEndTimeInfo).toEqual({
+      timeMs: 1725748375632.0728,
+      prefix: 'Fires in',
     });
   });
+
+  it('should not calculate expectedEndTimeInfo for timer events with close event', () => {
+    const eventsWithClose: TimerHistoryEvent[] = [
+      startTimerTaskEvent,
+      fireTimerTaskEvent,
+    ];
+    const group = getTimerGroupFromEvents(eventsWithClose);
+
+    // Should not calculate expectedEndTimeInfo when there's a close event
+    expect(group.expectedEndTimeInfo).toBeUndefined();
+  });
+
+  it('should not calculate expectedEndTimeInfo for timer events without started event', () => {
+    const eventsWithoutStart: TimerHistoryEvent[] = [fireTimerTaskEvent];
+    const group = getTimerGroupFromEvents(eventsWithoutStart);
+
+    // Should not calculate expectedEndTimeInfo when there's no started event
+    expect(group.expectedEndTimeInfo).toBeUndefined();
+  });
+
+  it('should not calculate expectedEndTimeInfo for started timer events without startToFireTimeout', () => {
+    const eventWithoutTimeout = {
+      ...startTimerTaskEvent,
+      timerStartedEventAttributes: {
+        ...startTimerTaskEvent.timerStartedEventAttributes,
+        startToFireTimeout: null,
+      },
+    };
+
+    const group = getTimerGroupFromEvents([eventWithoutTimeout]);
+    expect(group.expectedEndTimeInfo).toBeUndefined();
+  });
 });

src/views/workflow-history/helpers/get-history-group-from-events/get-single-event-group-from-events.ts

@@ -1,3 +1,5 @@
+import parseGrpcTimestamp from '@/utils/datetime/parse-grpc-timestamp';
+
 import type {
   HistoryGroupEventToNegativeFieldsMap,
   HistoryGroupEventToStatusMap,
@@ -108,6 +110,21 @@ export default function getSingleEventGroupFromEvents(
       ],
     };
 
+  let expectedFirstDecisionScheduleTimeMs: number | undefined;
+  if (
+    event.eventTime &&
+    event.attributes === 'workflowExecutionStartedEventAttributes' &&
+    event.workflowExecutionStartedEventAttributes?.firstDecisionTaskBackoff
+  ) {
+    const firstDecisionTaskBackoffMs = parseGrpcTimestamp(
+      event.workflowExecutionStartedEventAttributes.firstDecisionTaskBackoff
+    );
+
+    if (firstDecisionTaskBackoffMs > 0)
+      expectedFirstDecisionScheduleTimeMs =
+        parseGrpcTimestamp(event.eventTime) + firstDecisionTaskBackoffMs;
+  }
+
   return {
     label,
     hasMissingEvents,
@@ -123,5 +140,13 @@ export default function getSingleEventGroupFromEvents(
       undefined,
       eventToSummaryFields
     ),
+    ...(expectedFirstDecisionScheduleTimeMs
+      ? {
+          expectedEndTimeInfo: {
+            timeMs: expectedFirstDecisionScheduleTimeMs,
+            prefix: 'Starts in',
+          },
+        }
+      : {}),
   };
 }

src/views/workflow-history/helpers/get-history-group-from-events/get-timer-group-from-events.ts

@@ -1,3 +1,5 @@
+import parseGrpcTimestamp from '@/utils/datetime/parse-grpc-timestamp';
+
 import type {
   HistoryGroupEventToStatusMap,
   HistoryGroupEventToStringMap,
@@ -37,6 +39,7 @@ export default function getTimerGroupFromEvents(
     timerFiredEventAttributes: 'Fired',
     timerCanceledEventAttributes: 'Canceled',
   };
+
   const eventToStatus: HistoryGroupEventToStatusMap<TimerHistoryGroup> = {
     timerStartedEventAttributes: (_, events, index) =>
       index < events.length - 1 ? 'COMPLETED' : 'ONGOING',
@@ -49,6 +52,23 @@ export default function getTimerGroupFromEvents(
       timerStartedEventAttributes: ['startToFireTimeoutSeconds'],
     };
 
+  let expectedTimerFireTimeMs: number | undefined;
+
+  if (
+    startedEvent &&
+    startedEvent.eventTime &&
+    !closeEvent &&
+    startedEvent.timerStartedEventAttributes?.startToFireTimeout
+  ) {
+    const timeToFire = parseGrpcTimestamp(
+      startedEvent.timerStartedEventAttributes.startToFireTimeout
+    );
+
+    if (timeToFire > 0)
+      expectedTimerFireTimeMs =
+        parseGrpcTimestamp(startedEvent.eventTime) + timeToFire;
+  }
+
   return {
     label,
     hasMissingEvents,
@@ -63,5 +83,13 @@ export default function getTimerGroupFromEvents(
       undefined,
       eventToSummaryFields
     ),
+    ...(expectedTimerFireTimeMs
+      ? {
+          expectedEndTimeInfo: {
+            timeMs: expectedTimerFireTimeMs,
+            prefix: 'Fires in',
+          },
+        }
+      : {}),
   };
 }

src/views/workflow-history/workflow-history-timeline-chart/helpers/__tests__/convert-event-group-to-timeline-item.test.ts

@@ -57,6 +57,10 @@ describe(convertEventGroupToTimelineItem.name, () => {
           ...mockTimerEventGroup,
           timeMs: null,
           status: 'ONGOING',
+          expectedEndTimeInfo: {
+            timeMs: 1725748375632,
+            prefix: 'Starts in',
+          },
         },
         index: 1,
         classes: {} as any,

src/views/workflow-history/workflow-history-timeline-chart/helpers/convert-event-group-to-timeline-item.ts

@@ -33,15 +33,10 @@ export default function convertEventGroupToTimelineItem({
 
   if (
     group.groupType === 'Timer' &&
-    ['ONGOING', 'WAITING'].includes(group.status)
+    ['ONGOING', 'WAITING'].includes(group.status) &&
+    group.expectedEndTimeInfo
   ) {
-    const timerDuration =
-      group.events[0].timerStartedEventAttributes?.startToFireTimeout;
-
-    if (timerDuration) {
-      const timerDurationMs = parseGrpcTimestamp(timerDuration);
-      groupEndDayjs = groupStartDayjs.add(timerDurationMs, 'milliseconds');
-    }
+    groupEndDayjs = dayjs(group.expectedEndTimeInfo.timeMs);
   } else if (
     group.timeMs &&
     ['COMPLETED', 'FAILED', 'CANCELED'].includes(group.status)

src/views/workflow-history/workflow-history.types.ts

@@ -72,6 +72,10 @@ type BaseHistoryGroup = {
   timeMs: number | null;
   startTimeMs: number | null;
   closeTimeMs?: number | null;
+  expectedEndTimeInfo?: {
+    timeMs: number;
+    prefix: string;
+  };
   timeLabel: string;
   firstEventId: string | null;
   badges?: HistoryGroupBadge[];