Add pending activities with scheduled state (#851)

* add state scheduled to pending activity

* fix eventTime

* avoid duplicating lastFailure

* update snapshot

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,
+  pendingActivityTaskStartEventWithScheduledState,
   pendingDecisionTaskScheduleEvent,
 } from '@/views/workflow-history/__fixtures__/workflow-history-pending-events';
 
@@ -12,6 +13,7 @@ jest.mock('@/utils/logger');
 
 const pendingEvents = [
   pendingActivityTaskStartEvent,
+  pendingActivityTaskStartEventWithScheduledState,
   pendingDecisionTaskScheduleEvent,
 ];
 describe('formatWorkflowHistoryEvent', () => {

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

@@ -16,10 +16,35 @@ exports[`formatWorkflowHistoryEvent should format workflow pendingActivityTaskSt
     "gadence-canary-xdc",
     "workflow.sanity",
   ],
-  "lastFailure": {
-    "details": "",
-    "reason": "",
+  "lastFailureDetails": null,
+  "lastFailureReason": "",
+  "lastHeartbeatTime": null,
+  "lastStartedTime": null,
+  "lastWorkerIdentity": "",
+  "maximumAttempts": 10,
+  "scheduleId": 7,
+  "scheduledTime": 1970-01-01T00:03:00.000Z,
+  "startedWorkerIdentity": "",
+  "state": "started",
+}
+`;
+
+exports[`formatWorkflowHistoryEvent should format workflow pendingActivityTaskStartEventAttributes to match snapshot 2`] = `
+{
+  "activityId": "0",
+  "activityType": {
+    "name": "activity.cron.Start",
   },
+  "attempt": 1,
+  "eventId": null,
+  "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,
@@ -29,6 +54,7 @@ exports[`formatWorkflowHistoryEvent should format workflow pendingActivityTaskSt
   "scheduleId": 7,
   "scheduledTime": 1970-01-01T00:03:00.000Z,
   "startedWorkerIdentity": "",
+  "state": "scheduled",
 }
 `;
 

src/utils/data-formatters/format-pending-workflow-history-event/format-pending-activity-start-event.ts

@@ -1,29 +1,38 @@
-import omit from 'lodash/omit';
-
 import { type PendingActivityTaskStartEvent } from '@/views/workflow-history/workflow-history.types';
 
+import formatEnum from '../format-enum';
 import formatFailureDetails from '../format-failure-details';
 import formatPayload from '../format-payload';
 import formatTimestampToDatetime from '../format-timestamp-to-datetime';
 
 export default function formatPendingActivityTaskStartEvent({
-  pendingActivityTaskStartEventAttributes: pendingInfo,
+  pendingActivityTaskStartEventAttributes: {
+    scheduleId,
+    state,
+    lastHeartbeatTime,
+    lastStartedTime,
+    scheduledTime,
+    expirationTime,
+    heartbeatDetails,
+    lastFailure,
+    ...eventAttributes
+  },
   eventTime,
   eventId,
 }: PendingActivityTaskStartEvent) {
   return {
-    ...omit(pendingInfo, 'state'),
+    ...eventAttributes,
     eventId,
     eventTime: formatTimestampToDatetime(eventTime),
     eventType: 'PendingActivityTaskStart',
-
-    scheduleId: parseInt(pendingInfo.scheduleId),
-    lastHeartbeatTime: formatTimestampToDatetime(pendingInfo.lastHeartbeatTime),
-    lastStartedTime: formatTimestampToDatetime(pendingInfo.lastStartedTime),
-    scheduledTime: formatTimestampToDatetime(pendingInfo.scheduledTime),
-    expirationTime: formatTimestampToDatetime(pendingInfo.expirationTime),
-    heartbeatDetails: formatPayload(pendingInfo.heartbeatDetails),
-    lastFailureDetails: formatFailureDetails(pendingInfo.lastFailure),
-    lastFailureReason: pendingInfo.lastFailure?.reason,
+    state: formatEnum(state, 'PENDING_ACTIVITY_STATE', 'pascal'),
+    scheduleId: parseInt(scheduleId),
+    lastHeartbeatTime: formatTimestampToDatetime(lastHeartbeatTime),
+    lastStartedTime: formatTimestampToDatetime(lastStartedTime),
+    scheduledTime: formatTimestampToDatetime(scheduledTime),
+    expirationTime: formatTimestampToDatetime(expirationTime),
+    heartbeatDetails: formatPayload(heartbeatDetails),
+    lastFailureDetails: formatFailureDetails(lastFailure),
+    lastFailureReason: lastFailure?.reason,
   };
 }

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

@@ -29,7 +29,10 @@ export const pendingActivityTaskStartSchema = z.object({
   pendingActivityTaskStartEventAttributes: z.object({
     activityId: z.string(),
     activityType: activityTypeSchema.nullable(),
-    state: z.literal(PendingActivityState.PENDING_ACTIVITY_STATE_STARTED),
+    state: z.enum([
+      PendingActivityState.PENDING_ACTIVITY_STATE_SCHEDULED,
+      PendingActivityState.PENDING_ACTIVITY_STATE_STARTED,
+    ]),
     heartbeatDetails: payloadSchema.nullable(),
     lastHeartbeatTime: timestampSchema.nullable(),
     lastStartedTime: timestampSchema.nullable(),

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

@@ -5,7 +5,7 @@ import type {
 
 export const pendingActivityTaskStartEvent = {
   eventId: null,
-  computedEventId: 'pending-16',
+  computedEventId: 'pending-7',
   attributes: 'pendingActivityTaskStartEventAttributes',
   eventTime: {
     seconds: '1725747370',
@@ -43,6 +43,14 @@ export const pendingActivityTaskStartEvent = {
   },
 } as const satisfies PendingActivityTaskStartEvent;
 
+export const pendingActivityTaskStartEventWithScheduledState = {
+  ...pendingActivityTaskStartEvent,
+  pendingActivityTaskStartEventAttributes: {
+    ...pendingActivityTaskStartEvent.pendingActivityTaskStartEventAttributes,
+    state: 'PENDING_ACTIVITY_STATE_SCHEDULED',
+  },
+} as const satisfies PendingActivityTaskStartEvent;
+
 export const pendingDecisionTaskScheduleEvent = {
   eventId: '2',
   attributes: 'pendingDecisionTaskScheduleEventAttributes',

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

@@ -9,6 +9,7 @@ import {
 import { startDecisionTaskEvent } from '../../__fixtures__/workflow-history-decision-events';
 import {
   pendingActivityTaskStartEvent,
+  pendingActivityTaskStartEventWithScheduledState,
   pendingDecisionTaskScheduleEvent,
 } from '../../__fixtures__/workflow-history-pending-events';
 import type { ActivityHistoryEvent } from '../../workflow-history.types';
@@ -151,6 +152,25 @@ describe('groupHistoryEvents', () => {
     ]);
   });
 
+  it('should append pending activity start with scheduled state to group that has scheduled activity event only', () => {
+    const events: ActivityHistoryEvent[] = [scheduleActivityTaskEvent];
+    const pendingStartActivities = [
+      pendingActivityTaskStartEventWithScheduledState,
+    ];
+    (getHistoryEventGroupId as jest.Mock).mockReturnValue('group1');
+
+    const result = groupHistoryEvents(events, {
+      allEvents: events,
+      pendingScheduleDecision: null,
+      pendingStartActivities,
+    });
+
+    expect(result.group1.events).toEqual([
+      ...events,
+      ...pendingStartActivities,
+    ]);
+  });
+
   it('should not append pending activity start to group if it does not have scheduled activity event', () => {
     const events: ActivityHistoryEvent[] = [startActivityTaskEvent];
     const pendingStartActivities = [pendingActivityTaskStartEvent];

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

@@ -7,15 +7,16 @@ export default function pendingActivitiesInfoToEvents(
 ): PendingActivityTaskStartEvent[] {
   const events = activities.map((activityInfo) => {
     switch (activityInfo.state) {
+      case 'PENDING_ACTIVITY_STATE_SCHEDULED':
       case 'PENDING_ACTIVITY_STATE_STARTED':
         return {
           attributes: 'pendingActivityTaskStartEventAttributes',
-          eventTime: activityInfo.lastStartedTime,
+          eventTime: activityInfo.lastStartedTime ?? activityInfo.scheduledTime,
           eventId: null,
           computedEventId: `Pending-${activityInfo.scheduleId}`,
           pendingActivityTaskStartEventAttributes: {
             ...activityInfo,
-            state: 'PENDING_ACTIVITY_STATE_STARTED', // make it clear to ts that the state is started (same as a typeguard)
+            state: activityInfo.state, // make it clear to ts that the state is start or scheduled (same as a typeguard)
           },
         } satisfies PendingActivityTaskStartEvent;
       default:

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

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