@outputai/core 0.6.0 → 0.6.1-dev.aab2335.0

package/src/worker/interceptors/activity.js

@@ -1,4 +1,4 @@
-import { Context } from '@temporalio/activity';
+import { Context, activityInfo as activityInfoFn } from '@temporalio/activity';
 import { Storage } from '#async_storage';
 import * as Tracing from '#tracing';
 import { headersToObject } from '../sandboxed_utils.js';
@@ -25,7 +25,7 @@ const log = createChildLogger( 'ActivityInterceptor' );
 
   Context information comes from two sources:
   - Temporal's Activity Context (workflowId, activityId, activityType)
-  - Headers injected by the workflow interceptor (executionContext)
+  - Headers injected by the workflow interceptor
 */
 export class ActivityExecutionInterceptor {
   constructor( { activities, workflows, connection } ) {
@@ -42,25 +42,24 @@ export class ActivityExecutionInterceptor {
 
   /**
    * Returns a workflow entry by its name or throws error
-   * @param {string} workflowName
+   * @param {string} workflowType
    * @returns {object} Workflow entry
    * @throws {Error}
    */
-  getWorkflowEntry( workflowName ) {
-    const workflowEntry = this.workflowsMap.get( workflowName );
+  getWorkflowEntry( workflowType ) {
+    const workflowEntry = this.workflowsMap.get( workflowType );
     if ( !workflowEntry ) {
-      throw new Error( `Activity interceptor: workflow "${workflowName}" not found in workflowsMap.` );
+      throw new Error( `Activity interceptor: workflow "${workflowType}" not found in workflowsMap.` );
     }
     return workflowEntry;
   }
 
   async execute( input, next ) {
-    const startDate = Date.now();
-
-    const { workflowExecution: { workflowId }, activityId: id, activityType: name, workflowType: workflowName } = Context.current().info;
-    const { executionContext } = headersToObject( input.headers );
-    const { type: kind } = this.activities?.[name]?.[METADATA_ACCESS_SYMBOL];
-    const { path: workflowFilename } = this.getWorkflowEntry( workflowName );
+    const activityInfo = activityInfoFn();
+    const { workflowExecution: { workflowId, runId }, activityId, activityType, workflowType } = activityInfo;
+    const { traceInfo, workflowDetails } = headersToObject( input.headers );
+    const { type: outputActivityKind } = this.activities?.[activityType]?.[METADATA_ACCESS_SYMBOL];
+    const { path: workflowFilename } = this.getWorkflowEntry( workflowType );
 
     const state = {
       heartbeat: null,
@@ -76,32 +75,35 @@ export class ActivityExecutionInterceptor {
           const workflowHandle = client.workflow.getHandle( workflowId );
           await workflowHandle.signal( Signal.SEND_AGGREGATIONS, aggregateAttributes( state.attributes ) );
         } catch ( error ) {
-          log.warn( `Signal "${Signal.SEND_AGGREGATIONS}" failed`, {
-            message: error.message,
-            stack: error.stack,
-            activityId: id,
-            activityName: name,
-            workflowId,
-            workflowName
-          } );
+          const errorContext = { message: error.message, stack: error.stack, activityId, activityType, workflowId, workflowType, runId };
+          log.warn( `Signal "${Signal.SEND_AGGREGATIONS}" failed`, errorContext );
         }
       }
     };
 
-    // Wraps the execution with accessible metadata for the activity
-    const ctx = { parentId: id, executionContext, workflowFilename, addAttribute };
+    // Adds context accessible information
+    const storageContext = {
+      parentId: activityId,
+      outputActivityKind,
+      activityInfo,
+      workflowDetails,
+      workflowFilename,
+      traceInfo,
+      addAttribute
+    };
 
-    messageBus.emit( BusEventType.ACTIVITY_START, { id, name, kind, workflowId, workflowName } );
-    Tracing.addEventStart( { id, name, kind, parentId: workflowId, details: input.args[0], executionContext } );
+    messageBus.emit( BusEventType.ACTIVITY_START, { activityInfo, workflowDetails, outputActivityKind } );
+    Tracing.addEventStart( { id: activityId, name: activityType, kind: outputActivityKind, parentId: runId, details: input.args[0], traceInfo } );
 
     try {
       // Sends heartbeat to communicate that activity is still alive
       state.heartbeat = activityHeartbeatEnabled && setInterval( () => Context.current().heartbeat(), activityHeartbeatIntervalMs );
 
-      const output = await Storage.runWithContext( async _ => next( input ), ctx );
+      const output = await Storage.runWithContext( async _ => next( input ), storageContext );
+
+      messageBus.emit( BusEventType.ACTIVITY_END, { activityInfo, workflowDetails, outputActivityKind } );
+      Tracing.addEventEnd( { id: activityId, details: output, traceInfo } );
 
-      messageBus.emit( BusEventType.ACTIVITY_END, { id, name, kind, workflowId, workflowName, duration: Date.now() - startDate } );
-      Tracing.addEventEnd( { id, details: output, executionContext } );
       return {
         [ACTIVITY_WRAPPER_VERSION_FIELD]: 1,
         output,
@@ -109,8 +111,8 @@ export class ActivityExecutionInterceptor {
       };
 
     } catch ( error ) {
-      messageBus.emit( BusEventType.ACTIVITY_ERROR, { id, name, kind, workflowId, workflowName, duration: Date.now() - startDate, error } );
-      Tracing.addEventError( { id, details: error, executionContext } );
+      messageBus.emit( BusEventType.ACTIVITY_ERROR, { activityInfo, workflowDetails, outputActivityKind, error } );
+      Tracing.addEventError( { id: activityId, details: error, traceInfo } );
 
       await sendAggregationsViaSignal();
 

package/src/worker/interceptors/activity.spec.js

@@ -7,20 +7,36 @@ const workflowHandleMock = vi.hoisted( () => ( { signal: vi.fn() } ) );
 const getHandleMock = vi.hoisted( () => vi.fn( () => workflowHandleMock ) );
 const clientConstructorMock = vi.hoisted( () => vi.fn() );
 const logWarnMock = vi.hoisted( () => vi.fn() );
-
-const heartbeatMock = vi.fn();
+const heartbeatMock = vi.hoisted( () => vi.fn() );
 const runWithContextMock = vi.hoisted( () => vi.fn().mockImplementation( async fn => fn() ) );
-const contextInfoMock = {
-  workflowExecution: { workflowId: 'wf-1' },
+const activityInfoMock = vi.hoisted( () => ( {
+  workflowExecution: { workflowId: 'wf-1', runId: 'run-1' },
   activityId: 'act-1',
   activityType: 'myWorkflow#myStep',
   workflowType: 'myWorkflow'
-};
+} ) );
+const traceInfoMock = vi.hoisted( () => ( {
+  workflowId: 'wf-1',
+  runId: 'run-1',
+  workflowType: 'myWorkflow',
+  startTime: 1710000000000,
+  disableTrace: false
+} ) );
+const workflowDetailsMock = vi.hoisted( () => ( {
+  workflowId: 'wf-1',
+  runId: 'run-1',
+  workflowType: 'myWorkflow',
+  firstExecutionRunId: 'run-1',
+  startTime: 1710000000000,
+  runStartTime: 1710000000000,
+  attempt: 1
+} ) );
 
 vi.mock( '@temporalio/activity', () => ( {
+  activityInfo: () => activityInfoMock,
   Context: {
     current: () => ( {
-      info: contextInfoMock,
+      info: activityInfoMock,
       heartbeat: heartbeatMock
     } )
   }
@@ -58,7 +74,7 @@ vi.mock( '#tracing', () => ( {
 } ) );
 
 vi.mock( '../sandboxed_utils.js', () => ( {
-  headersToObject: () => ( { executionContext: { workflowId: 'wf-1' } } )
+  headersToObject: () => ( { traceInfo: traceInfoMock, workflowDetails: workflowDetailsMock } )
 } ) );
 
 const messageBusEmitMock = vi.fn();
@@ -105,6 +121,7 @@ const httpRequestAttribute = {
 describe( 'ActivityExecutionInterceptor', () => {
   beforeEach( () => {
     vi.clearAllMocks();
+    activityInfoMock.workflowType = 'myWorkflow';
     workflowHandleMock.signal.mockResolvedValue( undefined );
     vi.useFakeTimers();
     vi.resetModules();
@@ -132,22 +149,34 @@ describe( 'ActivityExecutionInterceptor', () => {
       aggregations: null,
       [ACTIVITY_WRAPPER_VERSION_FIELD]: 1
     } );
-    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_START, expect.objectContaining( {
-      id: 'act-1', name: 'myWorkflow#myStep', kind: 'step', workflowId: 'wf-1', workflowName: 'myWorkflow'
-    } ) );
-    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_END, expect.objectContaining( {
-      id: 'act-1', name: 'myWorkflow#myStep', kind: 'step', workflowId: 'wf-1', workflowName: 'myWorkflow', duration: expect.any( Number )
-    } ) );
-    expect( addEventStartMock ).toHaveBeenCalledOnce();
-    expect( addEventEndMock ).toHaveBeenCalledOnce();
+    expect( messageBusEmitMock ).toHaveBeenCalledWith(
+      BusEventType.ACTIVITY_START,
+      { activityInfo: activityInfoMock, workflowDetails: workflowDetailsMock, outputActivityKind: 'step' }
+    );
+    expect( messageBusEmitMock ).toHaveBeenCalledWith(
+      BusEventType.ACTIVITY_END,
+      { activityInfo: activityInfoMock, workflowDetails: workflowDetailsMock, outputActivityKind: 'step' }
+    );
+    expect( addEventStartMock ).toHaveBeenCalledWith( {
+      id: 'act-1',
+      name: 'myWorkflow#myStep',
+      kind: 'step',
+      parentId: 'run-1',
+      details: { someInput: 'data' },
+      traceInfo: traceInfoMock
+    } );
+    expect( addEventEndMock ).toHaveBeenCalledWith( { id: 'act-1', details: { result: 'ok' }, traceInfo: traceInfoMock } );
     expect( addEventErrorMock ).not.toHaveBeenCalled();
     expect( clientConstructorMock ).not.toHaveBeenCalled();
     expect( runWithContextMock ).toHaveBeenCalledWith(
       expect.any( Function ),
       expect.objectContaining( {
         parentId: 'act-1',
-        executionContext: { workflowId: 'wf-1' },
+        activityInfo: activityInfoMock,
+        workflowDetails: workflowDetailsMock,
+        outputActivityKind: 'step',
         workflowFilename: '/workflows/myWorkflow.js',
+        traceInfo: traceInfoMock,
         addAttribute: expect.any( Function )
       } )
     );
@@ -166,7 +195,7 @@ describe( 'ActivityExecutionInterceptor', () => {
     } );
 
     expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_END, expect.any( Object ) );
-    expect( addEventEndMock ).toHaveBeenCalledWith( { id: 'act-1', details: { result: 'sync' }, executionContext: { workflowId: 'wf-1' } } );
+    expect( addEventEndMock ).toHaveBeenCalledWith( { id: 'act-1', details: { result: 'sync' }, traceInfo: traceInfoMock } );
     expect( addEventErrorMock ).not.toHaveBeenCalled();
   } );
 
@@ -244,9 +273,10 @@ describe( 'ActivityExecutionInterceptor', () => {
     expect( logWarnMock ).toHaveBeenCalledWith( `Signal "${Signal.SEND_AGGREGATIONS}" failed`, expect.objectContaining( {
       message: 'signal failed',
       activityId: 'act-1',
-      activityName: 'myWorkflow#myStep',
+      activityType: 'myWorkflow#myStep',
       workflowId: 'wf-1',
-      workflowName: 'myWorkflow'
+      workflowType: 'myWorkflow',
+      runId: 'run-1'
     } ) );
   } );
 
@@ -261,12 +291,14 @@ describe( 'ActivityExecutionInterceptor', () => {
 
     await expect( promise ).rejects.toThrow( 'step failed' );
     expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_START, expect.any( Object ) );
-    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, expect.objectContaining( {
-      id: 'act-1', name: 'myWorkflow#myStep', kind: 'step', workflowId: 'wf-1', workflowName: 'myWorkflow',
-      duration: expect.any( Number ), error: expect.any( Error )
-    } ) );
+    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, {
+      activityInfo: activityInfoMock,
+      workflowDetails: workflowDetailsMock,
+      outputActivityKind: 'step',
+      error
+    } );
     expect( addEventStartMock ).toHaveBeenCalledOnce();
-    expect( addEventErrorMock ).toHaveBeenCalledOnce();
+    expect( addEventErrorMock ).toHaveBeenCalledWith( { id: 'act-1', details: error, traceInfo: traceInfoMock } );
     expect( addEventEndMock ).not.toHaveBeenCalled();
   } );
 
@@ -331,7 +363,7 @@ describe( 'ActivityExecutionInterceptor', () => {
     const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows } );
 
     // Override context to use alias as workflowType
-    contextInfoMock.workflowType = 'myWorkflowOld';
+    activityInfoMock.workflowType = 'myWorkflowOld';
     const next = vi.fn().mockResolvedValue( { result: 'ok' } );
 
     const promise = interceptor.execute( makeInput(), next );
@@ -345,7 +377,7 @@ describe( 'ActivityExecutionInterceptor', () => {
     );
 
     // Restore for other tests
-    contextInfoMock.workflowType = 'myWorkflow';
+    activityInfoMock.workflowType = 'myWorkflow';
   } );
 
   it( 'does not heartbeat when OUTPUT_ACTIVITY_HEARTBEAT_ENABLED is false', async () => {

package/src/worker/interceptors/workflow.js

@@ -5,6 +5,7 @@ import { deepMerge } from '#utils';
 import { METADATA_ACCESS_SYMBOL, WorkflowSpecialOutput } from '#consts';
 // this is a dynamic generated file with activity configs overwrites
 import stepOptions from '../temp/__activity_options.js';
+import { createWorkflowDetails } from '#internal_utils/temporal_context';
 
 /*
   This is not an AI comment!
@@ -17,8 +18,12 @@ import stepOptions from '../temp/__activity_options.js';
 */
 class HeadersInjectionInterceptor {
   async scheduleActivity( input, next ) {
-    const memo = workflowInfo().memo ?? {};
-    Object.assign( input.headers, memoToHeaders( memo ) );
+    const info = workflowInfo();
+    const memo = info.memo ?? {};
+    Object.assign( input.headers, memoToHeaders( {
+      ...memo,
+      workflowDetails: createWorkflowDetails( info )
+    } ) );
     // apply per-invocation options passed as second argument by rewritten calls
     const options = stepOptions[input.activityType];
     if ( options ) {

package/src/worker/interceptors/workflow.spec.js

@@ -7,6 +7,35 @@ const workflowStartMock = vi.fn();
 const workflowEndMock = vi.fn();
 const workflowErrorMock = vi.fn();
 const isCancellationMock = vi.fn();
+const startTime = new Date( '2026-06-02T09:00:00.000Z' );
+const runStartTime = new Date( '2026-06-02T09:05:00.000Z' );
+const workflowDetails = {
+  attempt: 1,
+  continuedFromExecutionRunId: undefined,
+  firstExecutionRunId: 'first-run',
+  parent: undefined,
+  root: undefined,
+  runId: 'run-1',
+  runStartTime: runStartTime.getTime(),
+  startTime: startTime.getTime(),
+  workflowId: 'workflow-1',
+  workflowType: 'MyWorkflow'
+};
+
+const workflowInfo = {
+  attempt: 1,
+  continuedFromExecutionRunId: undefined,
+  firstExecutionRunId: 'first-run',
+  parent: undefined,
+  root: undefined,
+  runId: 'run-1',
+  runStartTime,
+  startTime,
+  workflowId: 'workflow-1',
+  workflowType: 'MyWorkflow',
+  memo: { traceInfo: { runId: 'root-run' } }
+};
+
 vi.mock( '@temporalio/workflow', () => ( {
   workflowInfo: ( ...args ) => workflowInfoMock( ...args ),
   proxySinks: () => ( {
@@ -53,7 +82,7 @@ describe( 'workflow interceptors', () => {
   beforeEach( () => {
     vi.clearAllMocks();
     isCancellationMock.mockReturnValue( false );
-    workflowInfoMock.mockReturnValue( { workflowType: 'MyWorkflow', memo: { executionContext: { id: 'ctx-1' } } } );
+    workflowInfoMock.mockReturnValue( workflowInfo );
   } );
 
   describe( 'HeadersInjectionInterceptor', () => {
@@ -64,12 +93,19 @@ describe( 'workflow interceptors', () => {
       const input = { headers: { existing: 'header' }, activityType: 'MyWorkflow#step1' };
       const next = vi.fn().mockResolvedValue( 'result' );
 
-      memoToHeadersMock.mockReturnValue( { executionContext: { id: 'ctx-1' } } );
+      memoToHeadersMock.mockReturnValue( { traceInfo: workflowInfo.memo.traceInfo, workflowDetails } );
 
       const out = await interceptor.scheduleActivity( input, next );
 
-      expect( memoToHeadersMock ).toHaveBeenCalledWith( { executionContext: { id: 'ctx-1' } } );
-      expect( input.headers ).toEqual( { existing: 'header', executionContext: { id: 'ctx-1' } } );
+      expect( memoToHeadersMock ).toHaveBeenCalledWith( {
+        traceInfo: workflowInfo.memo.traceInfo,
+        workflowDetails
+      } );
+      expect( input.headers ).toEqual( {
+        existing: 'header',
+        traceInfo: workflowInfo.memo.traceInfo,
+        workflowDetails
+      } );
       expect( next ).toHaveBeenCalledWith( input );
       expect( out ).toBe( 'result' );
     } );
@@ -77,8 +113,8 @@ describe( 'workflow interceptors', () => {
     it( 'merges stepOptions with memo.activityOptions when stepOptions exist for activityType', async () => {
       stepOptionsDefault['MyWorkflow#step1'] = { scheduleToCloseTimeout: 60 };
       workflowInfoMock.mockReturnValue( {
-        workflowType: 'MyWorkflow',
-        memo: { executionContext: {}, activityOptions: { heartbeatTimeout: 10 } }
+        ...workflowInfo,
+        memo: { traceInfo: workflowInfo.memo.traceInfo, activityOptions: { heartbeatTimeout: 10 } }
       } );
       memoToHeadersMock.mockReturnValue( {} );
       deepMergeMock.mockReturnValue( { heartbeatTimeout: 10, scheduleToCloseTimeout: 60 } );

package/src/worker/log_hooks.js

@@ -1,6 +1,6 @@
 import { messageBus } from '#bus';
 import { createChildLogger } from '#logger';
-import { BusEventType, ComponentType, LifecycleEvent, WORKFLOW_CATALOG } from '#consts';
+import { ACTIVITY_GET_TRACE_DESTINATIONS, BusEventType, LifecycleEvent, WORKFLOW_CATALOG } from '#consts';
 
 const activityLog = createChildLogger( 'Activity' );
 const workflowLog = createChildLogger( 'Workflow' );
@@ -15,43 +15,34 @@ const workflowLog = createChildLogger( 'Workflow' );
 ╚═════════════════╝
 */
 
-/**
- * Returns true if activity event should be logged
- */
-const shouldLogActivityEvent = ( { kind } ) => kind !== ComponentType.INTERNAL_STEP;
+const serializedActivityFields = activityInfo => ( {
+  activityId: activityInfo.activityId,
+  activityType: activityInfo.activityType,
+  workflowId: activityInfo.workflowExecution.workflowId,
+  workflowType: activityInfo.workflowType,
+  runId: activityInfo.workflowExecution.runId
+} );
+
+const shouldLogActivity = activityInfo => activityInfo.activityType !== ACTIVITY_GET_TRACE_DESTINATIONS;
 
-messageBus.on( BusEventType.ACTIVITY_START, ( { id, name, kind, workflowId, workflowName } ) =>
-  shouldLogActivityEvent( { kind } ) && activityLog.info( `Started ${name} ${kind}`, {
+messageBus.on( BusEventType.ACTIVITY_START, ( { activityInfo, outputActivityKind } ) =>
+  shouldLogActivity( activityInfo ) && activityLog.info( `Started ${activityInfo.activityType} ${outputActivityKind}`, {
     event: LifecycleEvent.START,
-    activityId: id,
-    activityName: name,
-    activityKind: kind,
-    workflowId,
-    workflowName
+    ...serializedActivityFields( activityInfo )
   } )
 );
 
-messageBus.on( BusEventType.ACTIVITY_END, ( { id, name, kind, workflowId, workflowName, duration } ) =>
-  shouldLogActivityEvent( { kind } ) && activityLog.info( `Ended ${name} ${kind}`, {
+messageBus.on( BusEventType.ACTIVITY_END, ( { activityInfo, outputActivityKind } ) =>
+  shouldLogActivity( activityInfo ) && activityLog.info( `Ended ${activityInfo.activityType} ${outputActivityKind}`, {
     event: LifecycleEvent.END,
-    activityId: id,
-    activityName: name,
-    activityKind: kind,
-    workflowId,
-    workflowName,
-    durationMs: duration
+    ...serializedActivityFields( activityInfo )
   } )
 );
 
-messageBus.on( BusEventType.ACTIVITY_ERROR, ( { id, name, kind, workflowId, workflowName, duration, error } ) =>
-  shouldLogActivityEvent( { kind } ) && activityLog.error( `Error ${name} ${kind}: ${error.constructor.name}`, {
+messageBus.on( BusEventType.ACTIVITY_ERROR, ( { activityInfo, outputActivityKind, error } ) =>
+  shouldLogActivity( activityInfo ) && activityLog.error( `Error ${activityInfo.activityType} ${outputActivityKind}: ${error.constructor.name}`, {
     event: LifecycleEvent.ERROR,
-    activityId: id,
-    activityName: name,
-    activityKind: kind,
-    workflowId,
-    workflowName,
-    durationMs: duration,
+    ...serializedActivityFields( activityInfo ),
     error: error.message
   } )
 );
@@ -62,34 +53,32 @@ messageBus.on( BusEventType.ACTIVITY_ERROR, ( { id, name, kind, workflowId, work
 ╚═════════════════╝
 */
 
-/**
- * Returns true if activity event should be logged
- */
-const shouldLogWorkflowEvent = ( { name } ) => name !== WORKFLOW_CATALOG;
+const serializeWorkflowFields = workflowDetails => ( {
+  workflowId: workflowDetails.workflowId,
+  workflowType: workflowDetails.workflowType,
+  runId: workflowDetails.runId
+} );
+
+const shouldLogWorkflow = workflowDetails => workflowDetails.workflowType !== WORKFLOW_CATALOG;
 
-messageBus.on( BusEventType.WORKFLOW_START, ( { id, name } ) =>
-  shouldLogWorkflowEvent( { name } ) && workflowLog.info( `Started ${name} workflow`, {
+messageBus.on( BusEventType.WORKFLOW_START, ( { workflowDetails } ) =>
+  shouldLogWorkflow( workflowDetails ) && workflowLog.info( `Started ${workflowDetails.workflowType} workflow`, {
     event: LifecycleEvent.START,
-    workflowId: id,
-    workflowName: name
+    ...serializeWorkflowFields( workflowDetails )
   } )
 );
 
-messageBus.on( BusEventType.WORKFLOW_END, ( { id, name, duration } ) =>
-  shouldLogWorkflowEvent( { name } ) && workflowLog.info( `Ended ${name} workflow`, {
+messageBus.on( BusEventType.WORKFLOW_END, ( { workflowDetails } ) =>
+  shouldLogWorkflow( workflowDetails ) && workflowLog.info( `Ended ${workflowDetails.workflowType} workflow`, {
     event: LifecycleEvent.END,
-    workflowId: id,
-    workflowName: name,
-    durationMs: duration
+    ...serializeWorkflowFields( workflowDetails )
   } )
 );
 
-messageBus.on( BusEventType.WORKFLOW_ERROR, ( { id, name, duration, error } ) =>
-  shouldLogWorkflowEvent( { name } ) && workflowLog.error( `Error ${name} workflow: ${error.constructor.name}`, {
+messageBus.on( BusEventType.WORKFLOW_ERROR, ( { workflowDetails, error } ) =>
+  shouldLogWorkflow( workflowDetails ) && workflowLog.error( `Error ${workflowDetails.workflowType} workflow: ${error.constructor.name}`, {
     event: LifecycleEvent.ERROR,
-    workflowId: id,
-    workflowName: name,
-    durationMs: duration,
+    ...serializeWorkflowFields( workflowDetails ),
     error: error.message
   } )
 );