@output.ai/core 0.5.12 → 0.5.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.5.12",
+  "version": "0.5.13",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {
@@ -23,6 +23,10 @@
     "./context": {
       "types": "./src/context/index.d.ts",
       "import": "./src/context/index.js"
+    },
+    "./event_hub": {
+      "types": "./src/event_hub/index.d.ts",
+      "import": "./src/event_hub/index.js"
     }
   },
   "files": [

package/src/consts.js

@@ -1,17 +1,32 @@
-export const ACTIVITY_SEND_HTTP_REQUEST = '__internal#sendHttpRequest';
 export const ACTIVITY_GET_TRACE_DESTINATIONS = '__internal#getTraceDestinations';
+export const ACTIVITY_OPTIONS_FILENAME = '__activity_options.js';
+export const ACTIVITY_SEND_HTTP_REQUEST = '__internal#sendHttpRequest';
 export const METADATA_ACCESS_SYMBOL = Symbol( '__metadata' );
 export const SHARED_STEP_PREFIX = '$shared';
-export const WORKFLOWS_INDEX_FILENAME = '__workflows_entrypoint.js';
-export const ACTIVITY_OPTIONS_FILENAME = '__activity_options.js';
 export const WORKFLOW_CATALOG = '$catalog';
+export const WORKFLOWS_INDEX_FILENAME = '__workflows_entrypoint.js';
+
 export const ComponentType = {
   EVALUATOR: 'evaluator',
   INTERNAL_STEP: 'internal_step',
-  STEP: 'step'
+  STEP: 'step',
+  WORKFLOW: 'workflow'
 };
+
 export const LifecycleEvent = {
   START: 'start',
   END: 'end',
   ERROR: 'error'
 };
+
+export const BusEventType = {
+  WORKFLOW_START: 'workflow:start',
+  WORKFLOW_END: 'workflow:end',
+  WORKFLOW_ERROR: 'workflow:error',
+
+  ACTIVITY_START: 'activity:start',
+  ACTIVITY_END: 'activity:end',
+  ACTIVITY_ERROR: 'activity:error',
+
+  RUNTIME_ERROR: 'runtime_error'
+};

package/src/event_hub/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Emits a custom event
+ *
+ * @param eventName - The name of the event to emit
+ * @param payload - An optional payload to send to the event
+ */
+export declare function emit( eventName: string, payload?: unknown ): void;

package/src/event_hub/index.js

@@ -0,0 +1,6 @@
+import { messageBus } from '#bus';
+
+export const emit = ( eventName, payload ) => {
+  messageBus.emit( `external:${eventName}`, payload );
+};
+

package/src/hooks/index.d.ts

@@ -13,8 +13,16 @@ export interface ErrorHookPayload {
 }
 
 /**
- * Register a handler invoked on workflow, activity or runtime errors.
+ * Register a handler to be invoked on workflow, activity or runtime errors.
  *
  * @param handler - Function called with the error payload.
  */
 export declare function onError( handler: ( payload: ErrorHookPayload ) => void ): void;
+
+/**
+ * Register a handler to be invoked when a given event happens
+ *
+ * @param eventName - The name of the event to subscribe
+ * @param handler - Function called with the event payload
+ */
+export declare function on( eventName: string, handler: ( payload: object ) => void ): void;

package/src/hooks/index.js

@@ -1,4 +1,5 @@
 import { messageBus } from '#bus';
+import { BusEventType } from '#consts';
 import { createChildLogger } from '#logger';
 
 const log = createChildLogger( 'Hooks' );
@@ -12,10 +13,20 @@ export const onError = handler => {
     }
   };
 
-  messageBus.on( 'activity:error', async ( { workflowName, activityName, error } ) =>
-    invokeHandler( { source: 'activity', workflowName, activityName, error } ) );
-  messageBus.on( 'workflow:error', async ( { workflowName, error } ) =>
-    invokeHandler( { source: 'workflow', workflowName, error } ) );
-  messageBus.on( 'runtime:error', async ( { error } ) =>
+  messageBus.on( BusEventType.ACTIVITY_ERROR, async ( { name, workflowName, error } ) =>
+    invokeHandler( { source: 'activity', activityName: name, workflowName, error } ) );
+  messageBus.on( BusEventType.WORKFLOW_ERROR, async ( { name, error } ) =>
+    invokeHandler( { source: 'workflow', workflowName: name, error } ) );
+  messageBus.on( BusEventType.RUNTIME_ERROR, async ( { error } ) =>
     invokeHandler( { source: 'runtime', error } ) );
 };
+
+export const on = ( eventName, handler ) => {
+  messageBus.on( `external:${eventName}`, async payload => {
+    try {
+      await handler( payload );
+    } catch ( error ) {
+      log.error( `on(${eventName}) hook error`, { error } );
+    }
+  } );
+};

package/src/interface/webhook.js

@@ -51,11 +51,11 @@ export async function sendPostRequestAndAwaitWebhook( { url, payload = undefined
   const resumeSignal = defineSignal( 'resume' );
 
   const traceId = `${workflowId}-${url}-${uuid4()}`;
-  sinks.trace.addEventStart( { id: traceId, name: 'resume', kind: 'webhook' } );
+  sinks.trace.start( { id: traceId, name: 'resume', kind: 'webhook' } );
 
   setHandler( resumeSignal, webhookPayload => {
     if ( !resumeTrigger.resolved ) {
-      sinks.trace.addEventEnd( { id: traceId, details: webhookPayload } );
+      sinks.trace.end( { id: traceId, details: webhookPayload } );
       resumeTrigger.resolve( webhookPayload );
     }
   } );

package/src/interface/webhook.spec.js

@@ -21,7 +21,7 @@ const setHandlerMock = ( signal, fn ) => {
 };
 
 const workflowInfoMock = vi.fn( () => ( { workflowId: 'wf-123' } ) );
-const sinks = { trace: { addEventStart: vi.fn(), addEventEnd: vi.fn() } };
+const sinks = { trace: { start: vi.fn(), end: vi.fn() } };
 const proxySinksMock = vi.fn( async () => sinks );
 
 class TestTrigger {

package/src/tracing/processors/s3/index.js

@@ -78,7 +78,7 @@ export const exec = async ( { entry, executionContext } ) => {
 
   await addEntry( entry, cacheKey );
 
-  const isRootWorkflowEnd = !entry.parentId && entry.phase !== 'start';
+  const isRootWorkflowEnd = entry.id === workflowId && entry.phase !== 'start';
   if ( !isRootWorkflowEnd ) {
     return;
   }

package/src/tracing/processors/s3/index.spec.js

@@ -50,36 +50,31 @@ describe( 'tracing/processors/s3', () => {
     const startTime = Date.parse( '2020-01-02T03:04:05.678Z' );
     const ctx = { executionContext: { workflowId: 'id1', workflowName: 'WF', startTime } };
 
-    // multi().exec() just needs to resolve for addEntry calls
     redisMulti.exec.mockResolvedValue( [] );
 
-    // zRange is only called once at the end to get all entries
+    const workflowStart = { id: 'id1', name: 'WF', kind: 'workflow', phase: 'start', details: {}, timestamp: startTime };
+    const activityStart = { id: 'act-1', name: 'DoSomething', kind: 'step', parentId: 'id1', phase: 'start', details: {}, timestamp: startTime + 1 };
+    const workflowEnd = { id: 'id1', phase: 'end', details: { ok: true }, timestamp: startTime + 2 };
     zRangeMock.mockResolvedValue( [
-      JSON.stringify( { name: 'A', phase: 'start', timestamp: startTime } ),
-      JSON.stringify( { name: 'A', phase: 'tick', timestamp: startTime + 1 } ),
-      JSON.stringify( { name: 'A', phase: 'end', timestamp: startTime + 2 } )
+      JSON.stringify( workflowStart ),
+      JSON.stringify( activityStart ),
+      JSON.stringify( workflowEnd )
     ] );
 
-    await exec( { ...ctx, entry: { name: 'A', phase: 'start', timestamp: startTime, parentId: 'root' } } );
-    await exec( { ...ctx, entry: { name: 'A', phase: 'tick', timestamp: startTime + 1, parentId: 'root' } } );
-    // Root end: no parentId and not start — triggers the 10s delay before upload
-    const endPromise = exec( { ...ctx, entry: { name: 'A', phase: 'end', timestamp: startTime + 2 } } );
+    await exec( { ...ctx, entry: workflowStart } );
+    await exec( { ...ctx, entry: activityStart } );
+    // Root end: id matches workflowId and not start — triggers the 10s delay before upload
+    const endPromise = exec( { ...ctx, entry: workflowEnd } );
     await vi.advanceTimersByTimeAsync( 10_000 );
     await endPromise;
 
-    // Accumulation happened 3 times
     expect( redisMulti.zAdd ).toHaveBeenCalledTimes( 3 );
-
-    // Tree is only built once at the end (not on every event)
     expect( buildTraceTreeMock ).toHaveBeenCalledTimes( 1 );
     expect( zRangeMock ).toHaveBeenCalledTimes( 1 );
-
-    // Only last call triggers upload
     expect( uploadMock ).toHaveBeenCalledTimes( 1 );
     const { key, content } = uploadMock.mock.calls[0][0];
     expect( key ).toMatch( /^WF\/2020\/01\/02\// );
     expect( JSON.parse( content.trim() ).count ).toBe( 3 );
-
     expect( delMock ).toHaveBeenCalledTimes( 1 );
     expect( delMock ).toHaveBeenCalledWith( 'traces/WF/id1' );
   } );
@@ -101,24 +96,52 @@ describe( 'tracing/processors/s3', () => {
     const ctx = { executionContext: { workflowId: 'id1', workflowName: 'WF', startTime } };
 
     redisMulti.exec.mockResolvedValue( [] );
-    zRangeMock.mockResolvedValue( [ JSON.stringify( { phase: 'start', timestamp: startTime } ) ] );
+    const workflowStart = {
+      kind: 'workflow', id: 'id1', name: 'WF', parentId: undefined, phase: 'start', details: {}, timestamp: startTime
+    };
+    zRangeMock.mockResolvedValue( [ JSON.stringify( workflowStart ) ] );
 
-    await exec( { ...ctx, entry: { phase: 'start', timestamp: startTime, parentId: 'root' } } );
+    await exec( { ...ctx, entry: workflowStart } );
 
     expect( redisMulti.expire ).toHaveBeenCalledTimes( 1 );
     expect( redisMulti.expire ).toHaveBeenCalledWith( 'traces/WF/id1', 3600 );
   } );
 
+  it( 'exec(): does not treat a non-root end (e.g. step without parentId) as root workflow end — regression for wrong root detection', async () => {
+    const { exec } = await import( './index.js' );
+    const startTime = Date.parse( '2020-01-02T03:04:05.678Z' );
+    const ctx = { executionContext: { workflowId: 'id1', workflowName: 'WF', startTime } };
+
+    redisMulti.exec.mockResolvedValue( [] );
+    const workflowStart = { id: 'id1', name: 'WF', kind: 'workflow', phase: 'start', details: {}, timestamp: startTime };
+    const stepEndNoParent = { id: 'step-1', phase: 'end', details: { done: true }, timestamp: startTime + 1 };
+    zRangeMock.mockResolvedValue( [
+      JSON.stringify( workflowStart ),
+      JSON.stringify( stepEndNoParent )
+    ] );
+
+    await exec( { ...ctx, entry: workflowStart } );
+    await exec( { ...ctx, entry: stepEndNoParent } );
+
+    expect( redisMulti.zAdd ).toHaveBeenCalledTimes( 2 );
+    expect( buildTraceTreeMock ).not.toHaveBeenCalled();
+    expect( uploadMock ).not.toHaveBeenCalled();
+    expect( delMock ).not.toHaveBeenCalled();
+  } );
+
   it( 'exec(): when buildTraceTree returns null (incomplete tree), does not upload or bust cache', async () => {
     const { exec } = await import( './index.js' );
     const startTime = Date.parse( '2020-01-02T03:04:05.678Z' );
     const ctx = { executionContext: { workflowId: 'id1', workflowName: 'WF', startTime } };
 
     redisMulti.exec.mockResolvedValue( [] );
-    zRangeMock.mockResolvedValue( [ JSON.stringify( { id: 'wf', phase: 'end', timestamp: startTime } ) ] );
+    const workflowEnd = {
+      kind: 'workflow', id: 'id1', name: 'WF', parentId: undefined, phase: 'end', details: {}, timestamp: startTime
+    };
+    zRangeMock.mockResolvedValue( [ JSON.stringify( workflowEnd ) ] );
     buildTraceTreeMock.mockReturnValueOnce( null );
 
-    const endPromise = exec( { ...ctx, entry: { id: 'wf', phase: 'end', timestamp: startTime } } );
+    const endPromise = exec( { ...ctx, entry: workflowEnd } );
     await vi.advanceTimersByTimeAsync( 10_000 );
     await endPromise;
 

package/src/tracing/tools/build_trace_tree.spec.js

@@ -29,7 +29,7 @@ this can indicate it timed out or was interrupted.>>' );
     const entries = [
       { kind: 'wf', id: 'r', parentId: undefined, phase: 'start', name: 'root', details: {}, timestamp: 100 },
       { kind: 'step', id: 's', parentId: 'r', phase: 'start', name: 'step', details: {}, timestamp: 200 },
-      { kind: 'step', id: 's', parentId: 'r', phase: 'error', name: 'step', details: { message: 'failed' }, timestamp: 300 }
+      { id: 's', phase: 'error', details: { message: 'failed' }, timestamp: 300 }
     ];
     const result = buildTraceTree( entries );
     expect( result ).not.toBeNull();
@@ -44,7 +44,7 @@ this can indicate it timed out or was interrupted.>>' );
       { kind: 'workflow', phase: 'start', name: 'wf', id: 'wf', parentId: undefined, details: { a: 1 }, timestamp: 1000 },
       // evaluator start/stop
       { kind: 'evaluator', phase: 'start', name: 'eval', id: 'eval', parentId: 'wf', details: { z: 0 }, timestamp: 1500 },
-      { kind: 'evaluator', phase: 'end', name: 'eval', id: 'eval', parentId: 'wf', details: { z: 1 }, timestamp: 1600 },
+      { id: 'eval', phase: 'end', details: { z: 1 }, timestamp: 1600 },
       // step1 start
       { kind: 'step', phase: 'start', name: 'step-1', id: 's1', parentId: 'wf', details: { x: 1 }, timestamp: 2000 },
       // IO under step1
@@ -53,15 +53,15 @@ this can indicate it timed out or was interrupted.>>' );
       { kind: 'step', phase: 'start', name: 'step-2', id: 's2', parentId: 'wf', details: { x: 2 }, timestamp: 2400 },
       // IO under step2
       { kind: 'IO', phase: 'start', name: 'test-2', id: 'io2', parentId: 's2', details: { y: 3 }, timestamp: 2500 },
-      { kind: 'IO', phase: 'end', name: 'test-2', id: 'io2', parentId: 's2', details: { y: 4 }, timestamp: 2600 },
+      { id: 'io2', phase: 'end', details: { y: 4 }, timestamp: 2600 },
       // IO under step1 ends
-      { kind: 'IO', phase: 'end', name: 'test-1', id: 'io1', parentId: 's1', details: { y: 5 }, timestamp: 2700 },
+      { id: 'io1', phase: 'end', details: { y: 5 }, timestamp: 2700 },
       // step1 end
-      { kind: 'step', phase: 'end', name: 'step-1', id: 's1', parentId: 'wf', details: { done: true }, timestamp: 2800 },
+      { id: 's1', phase: 'end', details: { done: true }, timestamp: 2800 },
       // step2 end
-      { kind: 'step', phase: 'end', name: 'step-2', id: 's2', parentId: 'wf', details: { done: true }, timestamp: 2900 },
+      { id: 's2', phase: 'end', details: { done: true }, timestamp: 2900 },
       // workflow end
-      { kind: 'workflow', phase: 'end', name: 'wf', id: 'wf', parentId: undefined, details: { ok: true }, timestamp: 3000 }
+      { id: 'wf', phase: 'end', details: { ok: true }, timestamp: 3000 }
     ];
 
     const result = buildTraceTree( entries );

package/src/worker/index.js

@@ -10,6 +10,8 @@ import { createChildLogger } from '#logger';
 import { registerShutdown } from './shutdown.js';
 import { startCatalog } from './start_catalog.js';
 import { messageBus } from '#bus';
+import './log_hooks.js';
+import { BusEventType } from '#consts';
 
 const log = createChildLogger( 'Worker' );
 
@@ -81,7 +83,7 @@ const callerDir = process.argv[2];
   process.exit( 0 );
 } )().catch( error => {
   log.error( 'Fatal error', { message: error.message, stack: error.stack } );
-  messageBus.emit( 'runtime:error', { error } );
+  messageBus.emit( BusEventType.RUNTIME_ERROR, { error } );
   log.info( `Exiting in ${configs.processFailureShutdownDelay}ms` );
   setTimeout( () => process.exit( 1 ), configs.processFailureShutdownDelay );
 } );

package/src/worker/index.spec.js

@@ -3,7 +3,10 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 const mockLog = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
 vi.mock( '#logger', () => ( { createChildLogger: () => mockLog } ) );
 
-vi.mock( '#consts', () => ( { WORKFLOW_CATALOG: 'catalog' } ) );
+vi.mock( '#consts', async importOriginal => {
+  const actual = await importOriginal();
+  return { ...actual };
+} );
 
 vi.mock( '#tracing', () => ( { init: vi.fn().mockResolvedValue( undefined ) } ) );
 
@@ -52,6 +55,8 @@ vi.mock( './start_catalog.js', () => ( { startCatalog: startCatalogMock } ) );
 const registerShutdownMock = vi.fn();
 vi.mock( './shutdown.js', () => ( { registerShutdown: registerShutdownMock } ) );
 
+vi.mock( './log_hooks.js', () => ( {} ) );
+
 const runState = { resolve: null };
 const runPromise = new Promise( r => {
   runState.resolve = r;

package/src/worker/interceptors/activity.js

@@ -1,13 +1,11 @@
 import { Context } from '@temporalio/activity';
 import { Storage } from '#async_storage';
-import { addEventStart, addEventEnd, addEventError } from '#tracing';
+import * as Tracing from '#tracing';
 import { headersToObject } from '../sandboxed_utils.js';
-import { LifecycleEvent, METADATA_ACCESS_SYMBOL } from '#consts';
+import { BusEventType, METADATA_ACCESS_SYMBOL } from '#consts';
 import { activityHeartbeatEnabled, activityHeartbeatIntervalMs } from '../configs.js';
-import { createChildLogger } from '#logger';
 import { messageBus } from '#bus';
 
-const log = createChildLogger( 'Activity' );
 /*
   This interceptor wraps every activity execution with cross-cutting concerns:
 
@@ -31,16 +29,14 @@ export class ActivityExecutionInterceptor {
   };
 
   async execute( input, next ) {
-    const { workflowExecution: { workflowId }, activityId, activityType, workflowType: workflowName } = Context.current().info;
-    const { executionContext } = headersToObject( input.headers );
-    const { type: kind } = this.activities?.[activityType]?.[METADATA_ACCESS_SYMBOL];
-
     const startDate = Date.now();
-    const logContext = { workflowName, workflowId, stepId: activityId, stepName: activityType };
-    const traceArguments = { kind, id: activityId, parentId: workflowId, name: activityType, executionContext };
+    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 workflowFilename = this.workflowsMap.get( workflowName ).path;
 
-    log.info( `Started ${activityType} ${kind}`, { event: LifecycleEvent.START, kind, ...logContext } );
-    addEventStart( { details: input.args[0], ...traceArguments } );
+    messageBus.emit( BusEventType.ACTIVITY_START, { id, name, kind, workflowId, workflowName } );
+    Tracing.addEventStart( { id, name, kind, parentId: workflowId, details: input.args[0], executionContext } );
 
     const intervals = { heartbeat: null };
     try {
@@ -48,25 +44,17 @@ export class ActivityExecutionInterceptor {
       intervals.heartbeat = activityHeartbeatEnabled && setInterval( () => Context.current().heartbeat(), activityHeartbeatIntervalMs );
 
       // Wraps the execution with accessible metadata for the activity
-      const output = await Storage.runWithContext( async _ => next( input ), {
-        parentId: activityId,
-        executionContext,
-        workflowFilename: this.workflowsMap.get( workflowName ).path
-      } );
+      const output = await Storage.runWithContext( async _ => next( input ), { parentId: id, executionContext, workflowFilename } );
 
-      log.info( `Ended ${activityType} ${kind}`, { event: LifecycleEvent.END, kind, ...logContext, durationMs: Date.now() - startDate } );
-      addEventEnd( { details: output, ...traceArguments } );
+      messageBus.emit( BusEventType.ACTIVITY_END, { id, name, kind, workflowId, workflowName, duration: Date.now() - startDate } );
+      Tracing.addEventEnd( { id, details: output, executionContext } );
       return output;
 
     } catch ( error ) {
-      log.error( `Error ${activityType} ${kind}: ${error.message}`, {
-        event: LifecycleEvent.ERROR, kind, ...logContext, durationMs: Date.now() - startDate, error: error.message
-      } );
-      addEventError( { details: error, ...traceArguments } );
+      messageBus.emit( BusEventType.ACTIVITY_ERROR, { id, name, kind, workflowId, workflowName, duration: Date.now() - startDate, error } );
+      Tracing.addEventError( { id, details: error, executionContext } );
 
-      messageBus.emit( 'activity:error', { error, workflowName, activityName: activityType } );
       throw error;
-
     } finally {
       clearInterval( intervals.heartbeat );
     }

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

@@ -1,4 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { BusEventType } from '#consts';
 
 const METADATA_ACCESS_SYMBOL = vi.hoisted( () => Symbol( '__metadata' ) );
 
@@ -39,6 +40,9 @@ vi.mock( '../sandboxed_utils.js', () => ( {
   headersToObject: () => ( { executionContext: { workflowId: 'wf-1' } } )
 } ) );
 
+const messageBusEmitMock = vi.fn();
+vi.mock( '#bus', () => ( { messageBus: { emit: messageBusEmitMock } } ) );
+
 vi.mock( '#consts', async importOriginal => {
   const actual = await importOriginal();
   return {
@@ -93,6 +97,12 @@ describe( 'ActivityExecutionInterceptor', () => {
     const output = await promise;
 
     expect( output ).toEqual( { result: 'ok' } );
+    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( addEventErrorMock ).not.toHaveBeenCalled();
@@ -116,6 +126,11 @@ describe( 'ActivityExecutionInterceptor', () => {
     vi.advanceTimersByTime( 0 );
 
     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( addEventStartMock ).toHaveBeenCalledOnce();
     expect( addEventErrorMock ).toHaveBeenCalledOnce();
     expect( addEventEndMock ).not.toHaveBeenCalled();

package/src/worker/interceptors/workflow.js

@@ -32,10 +32,10 @@ const sinks = proxySinks();
 
 class WorkflowExecutionInterceptor {
   async execute( input, next ) {
-    sinks.trace.addWorkflowEventStart( input.args[0] );
+    sinks.workflow.start( input.args[0] );
     try {
       const output = await next( input );
-      sinks.trace.addWorkflowEventEnd( output );
+      sinks.workflow.end( output );
       return output;
     } catch ( error ) {
       /*
@@ -44,11 +44,11 @@ class WorkflowExecutionInterceptor {
        * a new trace file will be generated
        */
       if ( error instanceof ContinueAsNew ) {
-        sinks.trace.addWorkflowEventEnd( '<continued_as_new>' );
+        sinks.workflow.end( '<continued_as_new>' );
         throw error;
       }
 
-      sinks.trace.addWorkflowEventError( error );
+      sinks.workflow.error( error );
       const failure = new ApplicationFailure( error.message, error.constructor.name, undefined, undefined, error );
 
       /*

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

@@ -0,0 +1,167 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const METADATA_ACCESS_SYMBOL = vi.hoisted( () => Symbol( '__metadata' ) );
+
+const workflowInfoMock = vi.fn();
+const workflowStartMock = vi.fn();
+const workflowEndMock = vi.fn();
+const workflowErrorMock = vi.fn();
+vi.mock( '@temporalio/workflow', () => ( {
+  workflowInfo: ( ...args ) => workflowInfoMock( ...args ),
+  proxySinks: () => ( {
+    workflow: { start: workflowStartMock, end: workflowEndMock, error: workflowErrorMock }
+  } ),
+  ApplicationFailure: class ApplicationFailure {
+    constructor( message, type, nonRetryable, cause, originalError ) {
+      this.message = message;
+      this.type = type;
+      this.nonRetryable = nonRetryable;
+      this.cause = cause;
+      this.originalError = originalError;
+      this.details = undefined;
+    }
+  },
+  ContinueAsNew: class ContinueAsNew extends Error {
+    constructor() {
+      super( 'ContinueAsNew' );
+      this.name = 'ContinueAsNew';
+    }
+  }
+} ) );
+
+const memoToHeadersMock = vi.fn( memo => ( memo ? { ...memo, __asHeaders: true } : {} ) );
+vi.mock( '../sandboxed_utils.js', () => ( { memoToHeaders: ( ...args ) => memoToHeadersMock( ...args ) } ) );
+
+const deepMergeMock = vi.fn( ( a, b ) => ( { ...( a || {} ), ...( b || {} ) } ) );
+vi.mock( '#utils', () => ( { deepMerge: ( ...args ) => deepMergeMock( ...args ) } ) );
+
+vi.mock( '#consts', async importOriginal => {
+  const actual = await importOriginal();
+  return {
+    ...actual, get METADATA_ACCESS_SYMBOL() {
+      return METADATA_ACCESS_SYMBOL;
+    }
+  };
+} );
+
+const stepOptionsDefault = {};
+vi.mock( '../temp/__activity_options.js', () => ( { default: stepOptionsDefault } ) );
+
+describe( 'workflow interceptors', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    workflowInfoMock.mockReturnValue( { workflowType: 'MyWorkflow', memo: { executionContext: { id: 'ctx-1' } } } );
+  } );
+
+  describe( 'HeadersInjectionInterceptor', () => {
+    it( 'assigns memo as headers via memoToHeaders and calls next', async () => {
+      const { interceptors } = await import( './workflow.js' );
+      const { outbound } = interceptors();
+      const interceptor = outbound[0];
+      const input = { headers: { existing: 'header' }, activityType: 'MyWorkflow#step1' };
+      const next = vi.fn().mockResolvedValue( 'result' );
+
+      memoToHeadersMock.mockReturnValue( { executionContext: { id: 'ctx-1' } } );
+
+      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( next ).toHaveBeenCalledWith( input );
+      expect( out ).toBe( 'result' );
+    } );
+
+    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 } }
+      } );
+      memoToHeadersMock.mockReturnValue( {} );
+      deepMergeMock.mockReturnValue( { heartbeatTimeout: 10, scheduleToCloseTimeout: 60 } );
+
+      const { interceptors } = await import( './workflow.js' );
+      const { outbound } = interceptors();
+      const interceptor = outbound[0];
+      const input = { headers: {}, activityType: 'MyWorkflow#step1' };
+      const next = vi.fn().mockResolvedValue( undefined );
+
+      await interceptor.scheduleActivity( input, next );
+
+      expect( deepMergeMock ).toHaveBeenCalledWith( { heartbeatTimeout: 10 }, { scheduleToCloseTimeout: 60 } );
+      expect( input.options ).toEqual( { heartbeatTimeout: 10, scheduleToCloseTimeout: 60 } );
+      delete stepOptionsDefault['MyWorkflow#step1'];
+    } );
+  } );
+
+  describe( 'WorkflowExecutionInterceptor', () => {
+    it( 'calls sinks.workflow.start, next, then sinks.workflow.end on success', async () => {
+      const { interceptors } = await import( './workflow.js' );
+      const { inbound } = interceptors();
+      const interceptor = inbound[0];
+      const input = { args: [ { input: 'data' } ] };
+      const next = vi.fn().mockResolvedValue( { output: 'ok' } );
+
+      const result = await interceptor.execute( input, next );
+
+      expect( workflowStartMock ).toHaveBeenCalledWith( { input: 'data' } );
+      expect( next ).toHaveBeenCalledWith( input );
+      expect( workflowEndMock ).toHaveBeenCalledWith( { output: 'ok' } );
+      expect( result ).toEqual( { output: 'ok' } );
+      expect( workflowErrorMock ).not.toHaveBeenCalled();
+    } );
+
+    it( 'calls sinks.workflow.error and throws ApplicationFailure on error', async () => {
+      const { interceptors } = await import( './workflow.js' );
+      const { inbound } = interceptors();
+      const interceptor = inbound[0];
+      const input = { args: [ {} ] };
+      const err = new Error( 'workflow failed' );
+      const next = vi.fn().mockRejectedValue( err );
+
+      await expect( interceptor.execute( input, next ) ).rejects.toMatchObject( {
+        message: 'workflow failed',
+        type: 'Error',
+        originalError: err
+      } );
+      expect( workflowStartMock ).toHaveBeenCalled();
+      expect( workflowErrorMock ).toHaveBeenCalledWith( err );
+      expect( workflowEndMock ).not.toHaveBeenCalled();
+    } );
+
+    it( 'sets failure.details from error metadata when present', async () => {
+      const { interceptors } = await import( './workflow.js' );
+      const { ApplicationFailure } = await import( '@temporalio/workflow' );
+      const { inbound } = interceptors();
+      const interceptor = inbound[0];
+      const meta = { code: 'CUSTOM' };
+      const err = new Error( 'custom' );
+      err[METADATA_ACCESS_SYMBOL] = meta;
+      const next = vi.fn().mockRejectedValue( err );
+
+      const error = await ( async () => {
+        try {
+          await interceptor.execute( { args: [ {} ] }, next );
+          return null;
+        } catch ( error ) {
+          return error;
+        }
+      } )();
+      expect( error ).toBeInstanceOf( ApplicationFailure );
+      expect( error.details ).toEqual( [ meta ] );
+    } );
+
+    it( 'on ContinueAsNew calls sinks.trace.addWorkflowEventEnd and rethrows', async () => {
+      const { ContinueAsNew } = await import( '@temporalio/workflow' );
+      const { interceptors } = await import( './workflow.js' );
+      const { inbound } = interceptors();
+      const interceptor = inbound[0];
+      const continueErr = new ContinueAsNew();
+      const next = vi.fn().mockRejectedValue( continueErr );
+
+      await expect( interceptor.execute( { args: [ {} ] }, next ) ).rejects.toThrow( ContinueAsNew );
+      expect( workflowEndMock ).toHaveBeenCalledWith( '<continued_as_new>' );
+      expect( workflowErrorMock ).not.toHaveBeenCalled();
+    } );
+  } );
+} );

package/src/worker/log_hooks.js

@@ -0,0 +1,95 @@
+import { messageBus } from '#bus';
+import { createChildLogger } from '#logger';
+import { BusEventType, ComponentType, LifecycleEvent, WORKFLOW_CATALOG } from '#consts';
+
+const activityLog = createChildLogger( 'Activity' );
+const workflowLog = createChildLogger( 'Workflow' );
+
+/**
+ * Intercepts internal bus events for activity and workflow lifecycle and log them
+ */
+
+/*
+╔═════════════════╗
+║ Activity events ║
+╚═════════════════╝
+*/
+
+/**
+ * Returns true if activity event should be logged
+ */
+const shouldLogActivityEvent = ( { kind } ) => kind !== ComponentType.INTERNAL_STEP;
+
+messageBus.on( BusEventType.ACTIVITY_START, ( { id, name, kind, workflowId, workflowName } ) =>
+  shouldLogActivityEvent( { kind } ) && activityLog.info( `Started ${name} ${kind}`, {
+    event: LifecycleEvent.START,
+    activityId: id,
+    activityName: name,
+    activityKind: kind,
+    workflowId,
+    workflowName
+  } )
+);
+
+messageBus.on( BusEventType.ACTIVITY_END, ( { id, name, kind, workflowId, workflowName, duration } ) =>
+  shouldLogActivityEvent( { kind } ) && activityLog.info( `Ended ${name} ${kind}`, {
+    event: LifecycleEvent.END,
+    activityId: id,
+    activityName: name,
+    activityKind: kind,
+    workflowId,
+    workflowName,
+    durationMs: duration
+  } )
+);
+
+messageBus.on( BusEventType.ACTIVITY_ERROR, ( { id, name, kind, workflowId, workflowName, duration, error } ) =>
+  shouldLogActivityEvent( { kind } ) && activityLog.error( `Error ${name} ${kind}: ${error.constructor.name}`, {
+    event: LifecycleEvent.ERROR,
+    activityId: id,
+    activityName: name,
+    activityKind: kind,
+    workflowId,
+    workflowName,
+    durationMs: duration,
+    error: error.message
+  } )
+);
+
+/*
+╔═════════════════╗
+║ Workflow events ║
+╚═════════════════╝
+*/
+
+/**
+ * Returns true if activity event should be logged
+ */
+const shouldLogWorkflowEvent = ( { name } ) => name !== WORKFLOW_CATALOG;
+
+messageBus.on( BusEventType.WORKFLOW_START, ( { id, name } ) =>
+  shouldLogWorkflowEvent( { name } ) && workflowLog.info( `Started ${name} workflow`, {
+    event: LifecycleEvent.START,
+    workflowId: id,
+    workflowName: name
+  } )
+);
+
+messageBus.on( BusEventType.WORKFLOW_END, ( { id, name, duration } ) =>
+  shouldLogWorkflowEvent( { name } ) && workflowLog.info( `Ended ${name} workflow`, {
+    event: LifecycleEvent.END,
+    workflowId: id,
+    workflowName: name,
+    durationMs: duration
+  } )
+);
+
+messageBus.on( BusEventType.WORKFLOW_ERROR, ( { id, name, duration, error } ) =>
+  shouldLogWorkflowEvent( { name } ) && workflowLog.error( `Error ${name} workflow: ${error.constructor.name}`, {
+    event: LifecycleEvent.ERROR,
+    workflowId: id,
+    workflowName: name,
+    durationMs: duration,
+    error: error.message
+  } )
+);

package/src/worker/log_hooks.spec.js

@@ -0,0 +1,217 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+  BusEventType,
+  ComponentType,
+  LifecycleEvent,
+  WORKFLOW_CATALOG
+} from '#consts';
+
+const activityLogMock = vi.hoisted( () => ( { info: vi.fn(), error: vi.fn() } ) );
+const workflowLogMock = vi.hoisted( () => ( { info: vi.fn(), error: vi.fn() } ) );
+const createChildLoggerMock = vi.hoisted( () =>
+  vi.fn( name => ( name === 'Activity' ? activityLogMock : workflowLogMock ) )
+);
+
+const onHandlers = vi.hoisted( () => ( {} ) );
+const messageBusMock = vi.hoisted( () => ( {
+  on: vi.fn( ( eventType, handler ) => {
+    onHandlers[eventType] = handler;
+  } )
+} ) );
+
+vi.mock( '#logger', () => ( { createChildLogger: createChildLoggerMock } ) );
+vi.mock( '#bus', () => ( { messageBus: messageBusMock } ) );
+
+import './log_hooks.js';
+
+describe( 'log_hooks', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+  } );
+
+  describe( 'activity events', () => {
+    const basePayload = {
+      id: 'act-1',
+      name: 'myWorkflow#myStep',
+      kind: 'step',
+      workflowId: 'wf-1',
+      workflowName: 'myWorkflow'
+    };
+
+    it( 'ACTIVITY_START logs full message and second arg', () => {
+      onHandlers[BusEventType.ACTIVITY_START]( basePayload );
+
+      expect( activityLogMock.info ).toHaveBeenCalledTimes( 1 );
+      expect( activityLogMock.info ).toHaveBeenCalledWith(
+        'Started myWorkflow#myStep step',
+        {
+          event: LifecycleEvent.START,
+          activityId: 'act-1',
+          activityName: 'myWorkflow#myStep',
+          activityKind: 'step',
+          workflowId: 'wf-1',
+          workflowName: 'myWorkflow'
+        }
+      );
+    } );
+
+    it( 'ACTIVITY_START does not log when kind is INTERNAL_STEP', () => {
+      onHandlers[BusEventType.ACTIVITY_START]( {
+        ...basePayload,
+        kind: ComponentType.INTERNAL_STEP
+      } );
+
+      expect( activityLogMock.info ).not.toHaveBeenCalled();
+    } );
+
+    it( 'ACTIVITY_END logs full message and second arg', () => {
+      onHandlers[BusEventType.ACTIVITY_END]( { ...basePayload, duration: 42 } );
+
+      expect( activityLogMock.info ).toHaveBeenCalledTimes( 1 );
+      expect( activityLogMock.info ).toHaveBeenCalledWith(
+        'Ended myWorkflow#myStep step',
+        {
+          event: LifecycleEvent.END,
+          activityId: 'act-1',
+          activityName: 'myWorkflow#myStep',
+          activityKind: 'step',
+          workflowId: 'wf-1',
+          workflowName: 'myWorkflow',
+          durationMs: 42
+        }
+      );
+    } );
+
+    it( 'ACTIVITY_END does not log when kind is INTERNAL_STEP', () => {
+      onHandlers[BusEventType.ACTIVITY_END]( {
+        ...basePayload,
+        kind: ComponentType.INTERNAL_STEP,
+        duration: 10
+      } );
+
+      expect( activityLogMock.info ).not.toHaveBeenCalled();
+    } );
+
+    it( 'ACTIVITY_ERROR logs full message and second arg', () => {
+      const err = new Error( 'step failed' );
+      onHandlers[BusEventType.ACTIVITY_ERROR]( {
+        ...basePayload,
+        duration: 100,
+        error: err
+      } );
+
+      expect( activityLogMock.error ).toHaveBeenCalledTimes( 1 );
+      expect( activityLogMock.error ).toHaveBeenCalledWith(
+        'Error myWorkflow#myStep step: Error',
+        {
+          event: LifecycleEvent.ERROR,
+          activityId: 'act-1',
+          activityName: 'myWorkflow#myStep',
+          activityKind: 'step',
+          workflowId: 'wf-1',
+          workflowName: 'myWorkflow',
+          durationMs: 100,
+          error: 'step failed'
+        }
+      );
+    } );
+
+    it( 'ACTIVITY_ERROR does not log when kind is INTERNAL_STEP', () => {
+      onHandlers[BusEventType.ACTIVITY_ERROR]( {
+        ...basePayload,
+        kind: ComponentType.INTERNAL_STEP,
+        duration: 5,
+        error: new Error( 'x' )
+      } );
+
+      expect( activityLogMock.error ).not.toHaveBeenCalled();
+    } );
+  } );
+
+  describe( 'workflow events', () => {
+    const basePayload = { id: 'wf-1', name: 'myWorkflow' };
+
+    it( 'WORKFLOW_START logs full message and second arg', () => {
+      onHandlers[BusEventType.WORKFLOW_START]( basePayload );
+
+      expect( workflowLogMock.info ).toHaveBeenCalledTimes( 1 );
+      expect( workflowLogMock.info ).toHaveBeenCalledWith(
+        'Started myWorkflow workflow',
+        {
+          event: LifecycleEvent.START,
+          workflowId: 'wf-1',
+          workflowName: 'myWorkflow'
+        }
+      );
+    } );
+
+    it( 'WORKFLOW_START does not log when name is WORKFLOW_CATALOG', () => {
+      onHandlers[BusEventType.WORKFLOW_START]( {
+        id: 'cat-1',
+        name: WORKFLOW_CATALOG
+      } );
+
+      expect( workflowLogMock.info ).not.toHaveBeenCalled();
+    } );
+
+    it( 'WORKFLOW_END logs full message and second arg', () => {
+      onHandlers[BusEventType.WORKFLOW_END]( {
+        ...basePayload,
+        duration: 200
+      } );
+
+      expect( workflowLogMock.info ).toHaveBeenCalledTimes( 1 );
+      expect( workflowLogMock.info ).toHaveBeenCalledWith(
+        'Ended myWorkflow workflow',
+        {
+          event: LifecycleEvent.END,
+          workflowId: 'wf-1',
+          workflowName: 'myWorkflow',
+          durationMs: 200
+        }
+      );
+    } );
+
+    it( 'WORKFLOW_END does not log when name is WORKFLOW_CATALOG', () => {
+      onHandlers[BusEventType.WORKFLOW_END]( {
+        id: 'cat-1',
+        name: WORKFLOW_CATALOG,
+        duration: 50
+      } );
+
+      expect( workflowLogMock.info ).not.toHaveBeenCalled();
+    } );
+
+    it( 'WORKFLOW_ERROR logs full message and second arg', () => {
+      const err = new TypeError( 'workflow boom' );
+      onHandlers[BusEventType.WORKFLOW_ERROR]( {
+        ...basePayload,
+        duration: 150,
+        error: err
+      } );
+
+      expect( workflowLogMock.error ).toHaveBeenCalledTimes( 1 );
+      expect( workflowLogMock.error ).toHaveBeenCalledWith(
+        'Error myWorkflow workflow: TypeError',
+        {
+          event: LifecycleEvent.ERROR,
+          workflowId: 'wf-1',
+          workflowName: 'myWorkflow',
+          durationMs: 150,
+          error: 'workflow boom'
+        }
+      );
+    } );
+
+    it( 'WORKFLOW_ERROR does not log when name is WORKFLOW_CATALOG', () => {
+      onHandlers[BusEventType.WORKFLOW_ERROR]( {
+        id: 'cat-1',
+        name: WORKFLOW_CATALOG,
+        duration: 1,
+        error: new Error( 'x' )
+      } );
+
+      expect( workflowLogMock.error ).not.toHaveBeenCalled();
+    } );
+  } );
+} );

package/src/worker/sinks.js

@@ -1,109 +1,74 @@
-import { LifecycleEvent, WORKFLOW_CATALOG } from '#consts';
-import { addEventStart, addEventEnd, addEventError } from '#tracing';
-import { createChildLogger } from '#logger';
+import { BusEventType, ComponentType } from '#consts';
+import * as Tracing from '#tracing';
 import { messageBus } from '#bus';
 
-const log = createChildLogger( 'Workflow' );
-
-/**
- * Adds a workflow trace event
- *
- * @param {function} method - Trace function to call
- * @param {object} workflowInfo - Temporal workflowInfo object
- * @param {object} details - The details to attach to the event
- */
-const addWorkflowEvent = ( method, workflowInfo, details ) => {
-  const { workflowId: id, workflowType: name, memo: { parentId, executionContext } } = workflowInfo;
-  if ( name === WORKFLOW_CATALOG ) {
-    return;
-  } // ignore internal catalog events
-  method( { id, kind: 'workflow', name, details, parentId, executionContext } );
-};
-
-/**
- * Logs the internal workflow event
- *
- * @param {LifecycleEvent} event
- * @param {Object} workflowInfo
- * @returns {void}
- */
-const logWorkflowEvent = ( event, workflowInfo, error ) => {
-  const { workflowId, workflowType: workflowName, startTime } = workflowInfo;
-  // exclude internal catalog
-  if ( workflowName === WORKFLOW_CATALOG ) {
-    return;
-  }
-
-  if ( event === LifecycleEvent.START ) {
-    log.info( `Started ${workflowName} workflow`, { event, workflowName, workflowId } );
-  } else if ( event === LifecycleEvent.END ) {
-    log.info( `Ended ${workflowName} workflow`, { event, workflowName, workflowId, durationMs: Date.now() - startTime.getTime() } );
-  } else if ( event === LifecycleEvent.ERROR ) {
-    log.error( `Error ${workflowName} workflow: ${error.message}`, {
-      event,
-      workflowName,
-      workflowId,
-      durationMs: Date.now() - startTime.getTime(),
-      error: error.message
-    } );
-  }
-};
-
-/**
- * Start a trace event with given configuration
- *
- * @param {function} method - Trace function to call
- * @param {object} workflowInfo - Temporal workflowInfo object
- * @param {object} options - Trace options, like id, kind, name and details
- */
-const addEvent = ( method, workflowInfo, options ) => {
-  const { id, name, kind, details } = options;
-  const { workflowId, memo: { executionContext } } = workflowInfo;
-  method( { id, kind, name, details, parentId: workflowId, executionContext } );
-};
-
 // This sink allow for sandbox Temporal environment to send trace logs back to the main thread.
 export const sinks = {
-  trace: {
-    addWorkflowEventStart: {
-      fn: ( workflowInfo, details ) => {
-        logWorkflowEvent( LifecycleEvent.START, workflowInfo );
-        addWorkflowEvent( addEventStart, workflowInfo, details );
+
+  /**
+   * Workflow lifecycle sinks
+   */
+  workflow: {
+    start: {
+      fn: ( workflowInfo, input ) => {
+        const { workflowId: id, workflowType: name, memo: { parentId, executionContext } } = workflowInfo;
+        messageBus.emit( BusEventType.WORKFLOW_START, { id, name } );
+        if ( executionContext ) { // filters out internal workflows
+          Tracing.addEventStart( { id, kind: ComponentType.WORKFLOW, name, details: input, parentId, executionContext } );
+        }
       },
       callDuringReplay: false
     },
 
-    addWorkflowEventEnd: {
-      fn: ( workflowInfo, details ) => {
-        logWorkflowEvent( LifecycleEvent.END, workflowInfo );
-        addWorkflowEvent( addEventEnd, workflowInfo, details );
+    end: {
+      fn: ( workflowInfo, output ) => {
+        const { workflowId: id, workflowType: name, startTime, memo: { executionContext } } = workflowInfo;
+        messageBus.emit( BusEventType.WORKFLOW_END, { id, name, duration: Date.now() - startTime.getTime() } );
+        if ( executionContext ) { // filters out internal workflows
+          Tracing.addEventEnd( { id, details: output, executionContext } );
+        }
       },
       callDuringReplay: false
     },
 
-    addWorkflowEventError: {
+    error: {
       fn: ( workflowInfo, error ) => {
-        logWorkflowEvent( LifecycleEvent.ERROR, workflowInfo, error );
-        addWorkflowEvent( addEventError, workflowInfo, error );
-        messageBus.emit( 'workflow:error', { error, workflowName: workflowInfo.workflowType } );
+        const { workflowId: id, workflowType: name, startTime, memo: { executionContext } } = workflowInfo;
+        messageBus.emit( BusEventType.WORKFLOW_ERROR, { id, name, error, duration: Date.now() - startTime.getTime() } );
+        if ( executionContext ) { // filters out internal workflows
+          Tracing.addEventError( { id, details: error, executionContext } );
+        }
       },
       callDuringReplay: false
-    },
+    }
+  },
 
-    addEventStart: {
-      fn: ( ...args ) => addEvent( addEventStart, ...args ),
+  /**
+   * Generic trace sinks
+   */
+  trace: {
+    start: {
+      fn: ( workflowInfo, { id, name, kind, details } ) => {
+        const { memo: { executionContext, parentId } } = workflowInfo;
+        Tracing.addEventStart( { id, kind, name, details, parentId, executionContext } );
+      },
       callDuringReplay: false
     },
 
-    addEventEnd: {
-      fn: ( ...args ) => addEvent( addEventEnd, ...args ),
+    end: {
+      fn: ( workflowInfo, { id, details } ) => {
+        const { memo: { executionContext } } = workflowInfo;
+        Tracing.addEventEnd( { id, details, executionContext } );
+      },
       callDuringReplay: false
     },
 
-    addEventError: {
-      fn: ( ...args ) => addEvent( addEventError, ...args ),
+    error: {
+      fn: ( workflowInfo, { id, details } ) => {
+        const { memo: { executionContext } } = workflowInfo;
+        Tracing.addEventError( { id, details, executionContext } );
+      },
       callDuringReplay: false
-
     }
   }
 };