add cancel request (#853)

Author: Assem-Uber

src/utils/data-formatters/format-pending-workflow-history-event/__tests__/index.test.ts

@@ -3,6 +3,7 @@ import { ZodError } from 'zod';
 import logger from '@/utils/logger';
 import {
   pendingActivityTaskStartEvent,
+  pendingActivityTaskStartEventWithCancelRequestedState,
   pendingActivityTaskStartEventWithStartedState,
   pendingDecisionTaskStartEvent,
   pendingDecisionTaskStartEventWithStartedState,
@@ -15,6 +16,7 @@ jest.mock('@/utils/logger');
 const pendingEvents = [
   pendingActivityTaskStartEvent,
   pendingActivityTaskStartEventWithStartedState,
+  pendingActivityTaskStartEventWithCancelRequestedState,
   pendingDecisionTaskStartEvent,
   pendingDecisionTaskStartEventWithStartedState,
 ];

src/utils/data-formatters/format-pending-workflow-history-event/__tests__/index.test.ts.snapshot

@@ -56,6 +56,34 @@ exports[`formatWorkflowHistoryEvent should format workflow pendingActivityTaskSt
 }
 `;
 
+exports[`formatWorkflowHistoryEvent should format workflow pendingActivityTaskStartEventAttributes to match snapshot 3`] = `
+{
+  "activityId": "0",
+  "activityType": {
+    "name": "activity.cron.Start",
+  },
+  "attempt": 1,
+  "eventTime": 2024-09-07T22:16:10.599Z,
+  "eventType": "PendingActivityTaskStart",
+  "expirationTime": 1970-01-01T00:06:00.000Z,
+  "heartbeatDetails": [
+    "1725747370575409843",
+    "gadence-canary-xdc",
+    "workflow.sanity",
+  ],
+  "lastFailureDetails": null,
+  "lastFailureReason": "",
+  "lastHeartbeatTime": null,
+  "lastStartedTime": 2024-09-07T22:16:10.599Z,
+  "lastWorkerIdentity": "",
+  "maximumAttempts": 10,
+  "scheduleId": 7,
+  "scheduledTime": 1970-01-01T00:03:00.000Z,
+  "startedWorkerIdentity": "worker-1",
+  "state": "cancel requested",
+}
+`;
+
 exports[`formatWorkflowHistoryEvent should format workflow pendingDecisionTaskStartEventAttributes to match snapshot 1`] = `
 {
   "attempt": 1,

src/utils/data-formatters/schema/pending-history-event-schema.ts

@@ -32,6 +32,7 @@ export const pendingActivityTaskStartSchema = z.object({
     state: z.enum([
       PendingActivityState.PENDING_ACTIVITY_STATE_SCHEDULED,
       PendingActivityState.PENDING_ACTIVITY_STATE_STARTED,
+      PendingActivityState.PENDING_ACTIVITY_STATE_CANCEL_REQUESTED,
     ]),
     heartbeatDetails: payloadSchema.nullable(),
     lastHeartbeatTime: timestampSchema.nullable(),

src/views/workflow-history/__fixtures__/workflow-history-pending-events.ts

@@ -54,6 +54,14 @@ export const pendingActivityTaskStartEventWithStartedState = {
   },
 } as const satisfies PendingActivityTaskStartEvent;
 
+export const pendingActivityTaskStartEventWithCancelRequestedState = {
+  ...pendingActivityTaskStartEventWithStartedState,
+  pendingActivityTaskStartEventAttributes: {
+    ...pendingActivityTaskStartEventWithStartedState.pendingActivityTaskStartEventAttributes,
+    state: 'PENDING_ACTIVITY_STATE_CANCEL_REQUESTED',
+  },
+} as const satisfies PendingActivityTaskStartEvent;
+
 export const pendingDecisionTaskStartEvent = {
   eventId: null,
   computedEventId: 'pending-7',

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

@@ -11,6 +11,7 @@ import {
 } from '../../__fixtures__/workflow-history-decision-events';
 import {
   pendingActivityTaskStartEvent,
+  pendingActivityTaskStartEventWithCancelRequestedState,
   pendingActivityTaskStartEventWithStartedState,
   pendingDecisionTaskStartEvent,
   pendingDecisionTaskStartEventWithStartedState,
@@ -149,22 +150,25 @@ describe('groupHistoryEvents', () => {
     ]);
   });
 
-  it('should append pending activity start with started state to group that has scheduled activity event only', () => {
+  it('should append pending activity start with different states to group that has scheduled activity event only', () => {
     const events: ActivityHistoryEvent[] = [scheduleActivityTaskEvent];
-    const pendingStartActivities = [
+    const testPendingActivities = [
       pendingActivityTaskStartEventWithStartedState,
+      pendingActivityTaskStartEventWithCancelRequestedState,
     ];
     (getHistoryEventGroupId as jest.Mock).mockReturnValue('group1');
 
-    const result = groupHistoryEvents(events, {
-      pendingStartDecision: null,
-      pendingStartActivities,
-    });
+    testPendingActivities.forEach((pendingActivityTaskStart) => {
+      const result = groupHistoryEvents(events, {
+        pendingStartDecision: null,
+        pendingStartActivities: [pendingActivityTaskStart],
+      });
 
-    expect(result.group1.events).toEqual([
-      ...events,
-      ...pendingStartActivities,
-    ]);
+      expect(result.group1.events).toEqual([
+        ...events,
+        pendingActivityTaskStart,
+      ]);
+    });
   });
 
   it('should not append pending activity start to group if it does not have scheduled activity event', () => {

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

@@ -6,15 +6,19 @@ import {
   startActivityTaskEvent,
   timeoutActivityTaskEvent,
 } from '@/views/workflow-history/__fixtures__/workflow-history-activity-events';
+import {
+  pendingActivityTaskStartEvent,
+  pendingActivityTaskStartEventWithStartedState,
+} from '@/views/workflow-history/__fixtures__/workflow-history-pending-events';
 
-import type { ActivityHistoryEvent } from '../../../workflow-history.types';
+import type { ExtendedActivityHistoryEvent } from '../../../workflow-history.types';
 import getActivityGroupFromEvents from '../get-activity-group-from-events';
 
 jest.useFakeTimers().setSystemTime(new Date('2024-05-25'));
 
 describe('getActivityGroupFromEvents', () => {
   it('should return a group with a proper label when scheduled event exists', () => {
-    const events: ActivityHistoryEvent[] = [scheduleActivityTaskEvent];
+    const events: ExtendedActivityHistoryEvent[] = [scheduleActivityTaskEvent];
 
     const scheduelAttrs =
       scheduleActivityTaskEvent.activityTaskScheduledEventAttributes;
@@ -26,21 +30,21 @@ describe('getActivityGroupFromEvents', () => {
   });
 
   it('should return a group with empty label when scheduled event is missing', () => {
-    const completeEvents: ActivityHistoryEvent[] = [
+    const completeEvents: ExtendedActivityHistoryEvent[] = [
       startActivityTaskEvent,
       completeActivityTaskEvent,
     ];
     const completedActivitygroup = getActivityGroupFromEvents(completeEvents);
     expect(completedActivitygroup.label).toBe('');
 
-    const failureEvents: ActivityHistoryEvent[] = [
+    const failureEvents: ExtendedActivityHistoryEvent[] = [
       startActivityTaskEvent,
       failedActivityTaskEvent,
     ];
     const failedActivitygroup = getActivityGroupFromEvents(failureEvents);
     expect(failedActivitygroup.label).toBe('');
 
-    const timeoutEvents: ActivityHistoryEvent[] = [
+    const timeoutEvents: ExtendedActivityHistoryEvent[] = [
       startActivityTaskEvent,
       timeoutActivityTaskEvent,
     ];
@@ -51,7 +55,7 @@ describe('getActivityGroupFromEvents', () => {
   it('should return a group with hasMissingEvents when any event is missing', () => {
     const assertions: Array<{
       name: string;
-      events: ActivityHistoryEvent[];
+      events: ExtendedActivityHistoryEvent[];
       assertionValue: boolean;
     }> = [
       {
@@ -92,7 +96,7 @@ describe('getActivityGroupFromEvents', () => {
   });
 
   it('should return a group with groupType equal to Activity', () => {
-    const events: ActivityHistoryEvent[] = [
+    const events: ExtendedActivityHistoryEvent[] = [
       scheduleActivityTaskEvent,
       startActivityTaskEvent,
       completeActivityTaskEvent,
@@ -102,8 +106,9 @@ describe('getActivityGroupFromEvents', () => {
   });
 
   it('should return group eventsMetadata with correct labels', () => {
-    const events: ActivityHistoryEvent[] = [
+    const events: ExtendedActivityHistoryEvent[] = [
       scheduleActivityTaskEvent,
+      pendingActivityTaskStartEvent,
       startActivityTaskEvent,
       completeActivityTaskEvent,
       failedActivityTaskEvent,
@@ -113,6 +118,7 @@ describe('getActivityGroupFromEvents', () => {
     const group = getActivityGroupFromEvents(events);
     expect(group.eventsMetadata.map(({ label }) => label)).toEqual([
       'Scheduled',
+      'Starting',
       'Started',
       'Completed',
       'Failed',
@@ -123,14 +129,16 @@ describe('getActivityGroupFromEvents', () => {
 
   it('should return group eventsMetadata with correct status', () => {
     // just scheduled
-    const scheduleEvents: ActivityHistoryEvent[] = [scheduleActivityTaskEvent];
+    const scheduleEvents: ExtendedActivityHistoryEvent[] = [
+      scheduleActivityTaskEvent,
+    ];
     const scheduledGroup = getActivityGroupFromEvents(scheduleEvents);
     expect(scheduledGroup.eventsMetadata.map(({ status }) => status)).toEqual([
       'WAITING',
     ]);
 
     // started
-    const startEvents: ActivityHistoryEvent[] = [
+    const startEvents: ExtendedActivityHistoryEvent[] = [
       scheduleActivityTaskEvent,
       startActivityTaskEvent,
     ];
@@ -141,7 +149,7 @@ describe('getActivityGroupFromEvents', () => {
     ]);
 
     // Completed
-    const completeEvents: ActivityHistoryEvent[] = [
+    const completeEvents: ExtendedActivityHistoryEvent[] = [
       scheduleActivityTaskEvent,
       startActivityTaskEvent,
       completeActivityTaskEvent,
@@ -154,7 +162,7 @@ describe('getActivityGroupFromEvents', () => {
     ]);
 
     // Failed
-    const failureEvents: ActivityHistoryEvent[] = [
+    const failureEvents: ExtendedActivityHistoryEvent[] = [
       scheduleActivityTaskEvent,
       startActivityTaskEvent,
       failedActivityTaskEvent,
@@ -167,7 +175,7 @@ describe('getActivityGroupFromEvents', () => {
     ]);
 
     // Canceled
-    const cancelEvents: ActivityHistoryEvent[] = [
+    const cancelEvents: ExtendedActivityHistoryEvent[] = [
       scheduleActivityTaskEvent,
       startActivityTaskEvent,
       cancelActivityTaskEvent,
@@ -180,7 +188,7 @@ describe('getActivityGroupFromEvents', () => {
     ]);
 
     // Timed out
-    const timeoutEvents: ActivityHistoryEvent[] = [
+    const timeoutEvents: ExtendedActivityHistoryEvent[] = [
       scheduleActivityTaskEvent,
       startActivityTaskEvent,
       timeoutActivityTaskEvent,
@@ -194,7 +202,7 @@ describe('getActivityGroupFromEvents', () => {
   });
 
   it('should return group eventsMetadata with correct timeLabel', () => {
-    const events: ActivityHistoryEvent[] = [
+    const events: ExtendedActivityHistoryEvent[] = [
       scheduleActivityTaskEvent,
       startActivityTaskEvent,
       completeActivityTaskEvent,
@@ -206,4 +214,22 @@ describe('getActivityGroupFromEvents', () => {
       'Completed at 07 Sep, 22:16:10 UTC',
     ]);
   });
+
+  it('should use correct time label prefix for pending activity events', () => {
+    const groupWithScheduledState = getActivityGroupFromEvents([
+      scheduleActivityTaskEvent,
+      pendingActivityTaskStartEvent,
+    ]);
+    expect(groupWithScheduledState.eventsMetadata[1].timeLabel).toMatch(
+      /^Scheduled at/
+    );
+
+    const groupWithStartedState = getActivityGroupFromEvents([
+      scheduleActivityTaskEvent,
+      pendingActivityTaskStartEventWithStartedState,
+    ]);
+    expect(groupWithStartedState.eventsMetadata[1].timeLabel).toMatch(
+      /^Last started at/
+    );
+  });
 });

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

@@ -3,6 +3,7 @@ import type {
   ExtendedActivityHistoryEvent,
   HistoryGroupEventToStatusMap,
   HistoryGroupEventToStringMap,
+  PendingActivityTaskStartEvent,
 } from '../../workflow-history.types';
 import getCommonHistoryGroupFields from '../get-common-history-group-fields';
 
@@ -26,7 +27,7 @@ export default function getActivityGroupFromEvents(
   let scheduleEvent: ExtendedActivityHistoryEvent | undefined;
   let timeoutEvent: ExtendedActivityHistoryEvent | undefined;
   let startEvent: ExtendedActivityHistoryEvent | undefined;
-  let pendingStartEvent: ExtendedActivityHistoryEvent | undefined;
+  let pendingStartEvent: PendingActivityTaskStartEvent | undefined;
   let closeEvent: ExtendedActivityHistoryEvent | undefined;
 
   events.forEach((e) => {
@@ -89,6 +90,11 @@ export default function getActivityGroupFromEvents(
     activityTaskTimedOutEventAttributes: 'FAILED',
   };
 
+  const pendingStartEventTimePrefix = pendingStartEvent?.[pendingStartAttr]
+    .lastStartedTime
+    ? 'Last started at'
+    : 'Scheduled at';
+
   return {
     label,
     hasMissingEvents,
@@ -98,7 +104,7 @@ export default function getActivityGroupFromEvents(
       events,
       eventToStatus,
       eventToLabel,
-      { pendingActivityTaskStartEventAttributes: 'Last started at' }
+      { pendingActivityTaskStartEventAttributes: pendingStartEventTimePrefix }
     ),
   };
 }

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

@@ -115,7 +115,7 @@ export function groupHistoryEvents(
       );
     } else {
       const currentGroup = groupByFirstEventId[groupId];
-      // add pendingStart to group only if it is schedueled
+      // add pendingStart to group only if it is scheduled
       if (
         pa.eventTime &&
         currentGroup &&

src/views/workflow-history/helpers/pending-activities-info-to-events.ts

@@ -9,6 +9,7 @@ export default function pendingActivitiesInfoToEvents(
     switch (activityInfo.state) {
       case 'PENDING_ACTIVITY_STATE_SCHEDULED':
       case 'PENDING_ACTIVITY_STATE_STARTED':
+      case 'PENDING_ACTIVITY_STATE_CANCEL_REQUESTED':
         return {
           attributes: 'pendingActivityTaskStartEventAttributes',
           eventTime: activityInfo.lastStartedTime ?? activityInfo.scheduledTime,

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

@@ -58,7 +58,10 @@ export type PendingDecisionScheduleInfo = Omit<PendingDecisionInfo, 'state'> & {
 };
 
 export type PendingActivityStartInfo = Omit<PendingActivityInfo, 'state'> & {
-  state: 'PENDING_ACTIVITY_STATE_SCHEDULED' | 'PENDING_ACTIVITY_STATE_STARTED';
+  state:
+    | 'PENDING_ACTIVITY_STATE_SCHEDULED'
+    | 'PENDING_ACTIVITY_STATE_STARTED'
+    | 'PENDING_ACTIVITY_STATE_CANCEL_REQUESTED';
 };
 
 export type PendingActivityTaskStartEvent = {