Show heartbeat info for started activities (#974)

* Show heartbeat details and last heartbeat time for activities that have been started by retrieving the info from pendingActivityTaskStartEvent (which exists but is hidden after the actual activity task started event is available)
* Populate heartbeat info in additionalDetails
* Move the logic to hide pending event from groupHistoryEvents to getActivityGroupFromEvents
* Display heartbeatDetails as JSON

Author: adhityamamallan

src/views/workflow-history/config/workflow-history-event-details.config.ts

@@ -52,7 +52,7 @@ const workflowHistoryEventDetailsConfig = [
   {
     name: 'Json as PrettyJson',
     pathRegex:
-      '(input|result|details|failureDetails|Error|lastCompletionResult)$',
+      '(input|result|details|failureDetails|Error|lastCompletionResult|heartbeatDetails)$',
     valueComponent: WorkflowHistoryEventDetailsJson,
     forceWrap: true,
   },

src/views/workflow-history/helpers/get-common-history-group-fields.ts

@@ -7,6 +7,7 @@ import {
   type HistoryEventsGroup,
   type HistoryGroupEventToStatusMap,
   type HistoryGroupEventToStringMap,
+  type HistoryGroupEventToAdditionalDetailsMap,
 } from '../workflow-history.types';
 
 export default function getCommonHistoryGroupFields<
@@ -17,7 +18,8 @@ export default function getCommonHistoryGroupFields<
   eventToLabelMap: HistoryGroupEventToStringMap<GroupT>,
   eventToTimeLabelPrefixMap: Partial<HistoryGroupEventToStringMap<GroupT>>,
   closeEvent: GroupT['events'][number] | null | undefined,
-  eventStatusToNegativeFieldsMap?: HistoryGroupEventStatusToNegativeFieldsMap<GroupT>
+  eventStatusToNegativeFieldsMap?: HistoryGroupEventStatusToNegativeFieldsMap<GroupT>,
+  eventToAdditionalDetailsMap?: HistoryGroupEventToAdditionalDetailsMap<GroupT>
 ): Pick<
   GroupT,
   | 'eventsMetadata'
@@ -42,13 +44,15 @@ export default function getCommonHistoryGroupFields<
       : `${eventToLabelMap[attrs]} at`;
 
     const negativeFields = eventStatusToNegativeFieldsMap?.[attrs];
+    const additionalDetails = eventToAdditionalDetailsMap?.[attrs];
 
     return {
       label: eventToLabelMap[attrs],
       status: eventStatus,
       timeMs,
       timeLabel: timeMs ? `${prefix} ${formatDate(timeMs)}` : '',
       ...(negativeFields?.length ? { negativeFields } : {}),
+      ...(additionalDetails ? { additionalDetails } : {}),
     };
   });
 

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

@@ -152,7 +152,6 @@ describe('getActivityGroupFromEvents', () => {
   it('should return group eventsMetadata with correct labels', () => {
     const events: ExtendedActivityHistoryEvent[] = [
       scheduleActivityTaskEvent,
-      pendingActivityTaskStartEvent,
       startActivityTaskEvent,
       completeActivityTaskEvent,
       failedActivityTaskEvent,
@@ -162,7 +161,6 @@ describe('getActivityGroupFromEvents', () => {
     const group = getActivityGroupFromEvents(events);
     expect(group.eventsMetadata.map(({ label }) => label)).toEqual([
       'Scheduled',
-      'Starting',
       'Started',
       'Completed',
       'Failed',
@@ -389,4 +387,113 @@ describe('getActivityGroupFromEvents', () => {
       expect(metadata.negativeFields).toBeUndefined();
     });
   });
+
+  it('should include heartbeat details in additionalDetails when pending activity start event is present', () => {
+    const events: ExtendedActivityHistoryEvent[] = [
+      scheduleActivityTaskEvent,
+      pendingActivityTaskStartEvent,
+      startActivityTaskEvent,
+    ];
+    const group = getActivityGroupFromEvents(events);
+
+    // The started event should have additionalDetails with heartbeat information
+    const startedEventMetadata = group.eventsMetadata.find(
+      (metadata) => metadata.label === 'Started'
+    );
+    expect(startedEventMetadata?.additionalDetails).toEqual({
+      heartbeatDetails: [
+        '1725747370575409843',
+        'gadence-canary-xdc',
+        'workflow.sanity',
+      ],
+      lastHeartbeatTime: null,
+    });
+
+    // Other events should not have additionalDetails
+    const otherEventsMetadata = group.eventsMetadata.filter(
+      (metadata) => metadata.label !== 'Started'
+    );
+    otherEventsMetadata.forEach((metadata) => {
+      expect(metadata.additionalDetails).toBeUndefined();
+    });
+  });
+
+  it('should include last heartbeat time when pending activity start event has lastHeartbeatTime', () => {
+    const pendingEventWithHeartbeatTime = {
+      ...pendingActivityTaskStartEvent,
+      pendingActivityTaskStartEventAttributes: {
+        ...pendingActivityTaskStartEvent.pendingActivityTaskStartEventAttributes,
+        lastHeartbeatTime: {
+          seconds: '1725747370',
+          nanos: 599547391,
+        },
+      },
+    };
+
+    const events: ExtendedActivityHistoryEvent[] = [
+      scheduleActivityTaskEvent,
+      pendingEventWithHeartbeatTime,
+      startActivityTaskEvent,
+    ];
+    const group = getActivityGroupFromEvents(events);
+
+    const startedEventMetadata = group.eventsMetadata.find(
+      (metadata) => metadata.label === 'Started'
+    );
+    expect(startedEventMetadata?.additionalDetails).toEqual({
+      heartbeatDetails: [
+        '1725747370575409843',
+        'gadence-canary-xdc',
+        'workflow.sanity',
+      ],
+      lastHeartbeatTime: new Date('2024-09-07T22:16:10.599Z'),
+    });
+  });
+
+  it('should not include additionalDetails when no pending activity start event is present', () => {
+    const events: ExtendedActivityHistoryEvent[] = [
+      scheduleActivityTaskEvent,
+      startActivityTaskEvent,
+      completeActivityTaskEvent,
+    ];
+    const group = getActivityGroupFromEvents(events);
+
+    // No events should have additionalDetails
+    group.eventsMetadata.forEach((metadata) => {
+      expect(metadata.additionalDetails).toBeUndefined();
+    });
+  });
+
+  it('should filter out pending activity start events when activity start event is present', () => {
+    const events: ExtendedActivityHistoryEvent[] = [
+      scheduleActivityTaskEvent,
+      pendingActivityTaskStartEvent,
+      startActivityTaskEvent,
+      completeActivityTaskEvent,
+    ];
+    const group = getActivityGroupFromEvents(events);
+
+    // Should only have 3 events (schedule, start, complete) - pending start should be filtered out
+    expect(group.eventsMetadata).toHaveLength(3);
+    expect(group.eventsMetadata.map(({ label }) => label)).toEqual([
+      'Scheduled',
+      'Started',
+      'Completed',
+    ]);
+  });
+
+  it('should include pending activity start events when only scheduled and pending events are present', () => {
+    const events: ExtendedActivityHistoryEvent[] = [
+      scheduleActivityTaskEvent,
+      pendingActivityTaskStartEvent,
+    ];
+    const group = getActivityGroupFromEvents(events);
+
+    // Should have both events when no activity start event is present
+    expect(group.eventsMetadata).toHaveLength(2);
+    expect(group.eventsMetadata.map(({ label }) => label)).toEqual([
+      'Scheduled',
+      'Starting',
+    ]);
+  });
 });

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

@@ -1,8 +1,12 @@
+import formatPayload from '@/utils/data-formatters/format-payload';
+import formatTimestampToDatetime from '@/utils/data-formatters/format-timestamp-to-datetime';
+
 import WORKFLOW_HISTORY_SHOULD_SHORTEN_GROUP_LABELS_CONFIG from '../../config/workflow-history-should-shorten-group-labels.config';
 import type {
   ActivityHistoryGroup,
   ExtendedActivityHistoryEvent,
   HistoryGroupEventStatusToNegativeFieldsMap,
+  HistoryGroupEventToAdditionalDetailsMap,
   HistoryGroupEventToStatusMap,
   HistoryGroupEventToStringMap,
   PendingActivityTaskStartEvent,
@@ -129,19 +133,50 @@ export default function getActivityGroupFromEvents(
     ? 'Last started at'
     : 'Scheduled at';
 
+  const eventToAdditionalDetails: HistoryGroupEventToAdditionalDetailsMap<ActivityHistoryGroup> =
+    {
+      ...(pendingStartEvent
+        ? {
+            activityTaskStartedEventAttributes: {
+              heartbeatDetails: formatPayload(
+                pendingStartEvent.pendingActivityTaskStartEventAttributes
+                  .heartbeatDetails
+              ),
+              lastHeartbeatTime: formatTimestampToDatetime(
+                pendingStartEvent.pendingActivityTaskStartEventAttributes
+                  .lastHeartbeatTime
+              ),
+            },
+          }
+        : {}),
+    };
+
+  const shouldShowPendingEvent = Boolean(
+    scheduleEvent &&
+      pendingStartEvent &&
+      !(startEvent || closeEvent || timeoutEvent)
+  );
+
+  const finalEvents = shouldShowPendingEvent
+    ? events
+    : events.filter(
+        (e) => e.attributes !== 'pendingActivityTaskStartEventAttributes'
+      );
+
   return {
     label,
     shortLabel,
     hasMissingEvents,
     groupType,
     badges,
     ...getCommonHistoryGroupFields<ActivityHistoryGroup>(
-      events,
+      finalEvents,
       eventToStatus,
       eventToLabel,
       { pendingActivityTaskStartEventAttributes: pendingStartEventTimePrefix },
       closeEvent || timeoutEvent,
-      eventStatusToNegativeFields
+      eventStatusToNegativeFields,
+      eventToAdditionalDetails
     ),
   };
 }

src/views/workflow-history/helpers/group-history-events.ts

@@ -115,13 +115,9 @@ export function groupHistoryEvents(
       );
     } else {
       const currentGroup = groupByFirstEventId[groupId];
-      // add pendingStart to group only if it is scheduled
       if (
         pa.eventTime &&
         currentGroup &&
-        currentGroup?.events.length === 1 &&
-        currentGroup.events[0].attributes ===
-          'activityTaskScheduledEventAttributes' &&
         currentGroup.events.every(isExtendedActivityEvent)
       ) {
         const updatedEventsArr: ExtendedActivityHistoryEvent[] = [

src/views/workflow-history/workflow-history-event-details/__tests__/workflow-history-event-details.test.tsx

@@ -138,4 +138,29 @@ describe(WorkflowHistoryEventDetails.name, () => {
       negativeFields,
     });
   });
+
+  it('passes additionalDetails merged with formatted event details to generateHistoryEventDetails', () => {
+    const additionalDetails = {
+      key1: 'value1',
+      key2: {
+        value: 2,
+      },
+    };
+    mockGenerateHistoryEventDetails.mockReturnValue([]);
+
+    render(
+      <WorkflowHistoryEventDetails
+        event={completeActivityTaskEvent}
+        decodedPageUrlParams={workflowPageUrlParams}
+        additionalDetails={additionalDetails}
+      />
+    );
+
+    expect(mockGenerateHistoryEventDetails).toHaveBeenCalledWith({
+      details: {
+        mockFormatted: true,
+        ...additionalDetails,
+      },
+    });
+  });
 });

src/views/workflow-history/workflow-history-event-details/workflow-history-event-details.tsx

@@ -16,6 +16,7 @@ export default function WorkflowHistoryEventDetails({
   event,
   decodedPageUrlParams,
   negativeFields,
+  additionalDetails,
 }: Props) {
   const { cls } = useStyletronClasses(cssStyles);
 
@@ -25,9 +26,15 @@ export default function WorkflowHistoryEventDetails({
       : formatWorkflowHistoryEvent(event);
 
     return result
-      ? generateHistoryEventDetails({ details: result, negativeFields })
+      ? generateHistoryEventDetails({
+          details: {
+            ...result,
+            ...additionalDetails,
+          },
+          negativeFields,
+        })
       : [];
-  }, [event, negativeFields]);
+  }, [event, negativeFields, additionalDetails]);
 
   if (detailsEntries.length === 0)
     return <div className={cls.emptyDetails}>No Details</div>;

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

@@ -8,6 +8,7 @@ import type {
 export type Props = {
   event: ExtendedHistoryEvent;
   negativeFields?: Array<string>;
+  additionalDetails?: Record<string, any>;
   decodedPageUrlParams: WorfklowHistoryProps['params'];
 };
 

src/views/workflow-history/workflow-history-events-card/workflow-history-events-card.tsx

@@ -68,6 +68,7 @@ export default function WorkflowHistoryEventsCard({
               event={event}
               decodedPageUrlParams={decodedPageUrlParams}
               negativeFields={eventMetadata.negativeFields}
+              additionalDetails={eventMetadata.additionalDetails}
             />
           </Panel>
         );

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

@@ -12,7 +12,7 @@ export type Props = {
   events: ExtendedHistoryEvent[];
   eventsMetadata: Pick<
     HistoryGroupEventMetadata,
-    'label' | 'status' | 'negativeFields'
+    'label' | 'status' | 'negativeFields' | 'additionalDetails'
   >[];
   showEventPlaceholder?: boolean;
   decodedPageUrlParams: WorfklowHistoryProps['params'];