@outputai/core 0.10.1-dev.b7b2fbe.0 → 0.10.1-next.14a191e.0

package/src/sdk/runtime/events.d.ts

@@ -2,14 +2,12 @@
  * Tools to interact with Events
  */
 export declare const Event: {
+
   /**
-   * Emits a custom event on the in-process message bus.
-   *
-   * When called inside an Output activity context, the framework automatically
-   * attaches `activityInfo`, `workflowDetails`, and `outputActivityKind` onto the emitted payload.
+   * Emits an event on step message bus.
    *
    * @param eventName - The name of the event to emit
-   * @param payload - An optional payload to send to the event
+   * @param payload - An optional payload to send to the event.
    */
-  emit( eventName: string, payload?: object ): void;
+  emit( eventName: string, payload?: object ): boolean;
 };

package/src/sdk/runtime/events.js

@@ -1,18 +1,5 @@
-import { messageBus } from '#bus';
-import { Storage } from '#async_storage';
+import { stepEventBus } from '#bus';
 
 export const Event = {
-  emit: ( eventName, payload ) => {
-    const ctx = Storage.load();
-
-    messageBus.emit( `external:${eventName}`, {
-      ...payload ?? {},
-      ...( ctx && {
-        activityInfo: ctx.activityInfo,
-        workflowDetails: ctx.workflowDetails,
-        outputActivityKind: ctx.outputActivityKind
-      } )
-    } );
-  }
+  emit: ( eventName, payload ) => stepEventBus.emit( `sdk:${eventName}`, payload )
 };
-

package/src/sdk/runtime/events.spec.js

@@ -1,118 +1,40 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
-const loadMock = vi.hoisted( () => vi.fn() );
 const emitMock = vi.hoisted( () => vi.fn() );
 
-vi.mock( '#async_storage', () => ( {
-  Storage: { load: loadMock }
-} ) );
-
 vi.mock( '#bus', () => ( {
-  messageBus: { emit: emitMock }
+  stepEventBus: { emit: emitMock }
 } ) );
 
 import { Event } from './events.js';
 
-// `eventId` stamping is the bus layer's responsibility (see bus.spec.js).
-// Assertions here use `objectContaining` so they don't have to know about that enrichment.
 describe( 'Event.emit', () => {
   beforeEach( () => {
     vi.clearAllMocks();
   } );
 
-  it( 'forwards activityInfo, workflowDetails, and outputActivityKind from storage', () => {
-    const activityInfo = {
-      activityId: 'act-1',
-      activityType: 'step',
-      workflowExecution: { workflowId: 'wf-1', runId: 'run-1' },
-      workflowType: 'workflow'
-    };
-    const workflowDetails = {
-      workflowId: 'wf-1',
-      runId: 'run-1',
-      workflowType: 'workflow'
-    };
-    loadMock.mockReturnValue( {
-      activityInfo,
-      workflowDetails,
-      outputActivityKind: 'step'
-    } );
+  it( 'forwards class instance payloads unchanged', () => {
+    class Payload {
+      value = 'test';
+    }
+    const payload = new Payload();
 
-    Event.emit( 'cost:llm:request', { modelId: 'gpt-4o' } );
+    Event.emit( 'test:event', payload );
 
-    expect( emitMock ).toHaveBeenCalledWith( 'external:cost:llm:request', expect.objectContaining( {
-      activityInfo,
-      workflowDetails,
-      outputActivityKind: 'step',
-      modelId: 'gpt-4o'
-    } ) );
+    expect( emitMock ).toHaveBeenCalledWith( 'sdk:test:event', payload );
   } );
 
-  it( 'emits payload without context when storage is missing', () => {
-    loadMock.mockReturnValue( undefined );
+  it( 'emits plain object payloads on the SDK event channel', () => {
+    const payload = { modelId: 'gpt-4o' };
 
-    Event.emit( 'foo:bar', { x: 1 } );
+    Event.emit( 'cost:llm:request', payload );
 
-    expect( emitMock ).toHaveBeenCalledWith( 'external:foo:bar', { x: 1 } );
+    expect( emitMock ).toHaveBeenCalledWith( 'sdk:cost:llm:request', payload );
   } );
 
-  it( 'handles missing payload', () => {
-    const activityInfo = {
-      activityId: 'act-2',
-      activityType: 'step',
-      workflowExecution: { workflowId: 'wf-2', runId: 'run-2' },
-      workflowType: 'workflow'
-    };
-    const workflowDetails = {
-      workflowId: 'wf-2',
-      runId: 'run-2',
-      workflowType: 'workflow'
-    };
-    loadMock.mockReturnValue( {
-      activityInfo,
-      workflowDetails,
-      outputActivityKind: 'step'
-    } );
-
+  it( 'forwards a missing payload as undefined', () => {
     Event.emit( 'lifecycle:start' );
 
-    expect( emitMock ).toHaveBeenCalledWith( 'external:lifecycle:start', expect.objectContaining( {
-      activityInfo,
-      workflowDetails,
-      outputActivityKind: 'step'
-    } ) );
-  } );
-
-  it( 'does not let payload override activityInfo, workflowDetails, or outputActivityKind', () => {
-    const activityInfo = {
-      activityId: 'act-3',
-      activityType: 'step',
-      workflowExecution: { workflowId: 'wf-3', runId: 'run-3' },
-      workflowType: 'workflow'
-    };
-    const workflowDetails = {
-      workflowId: 'wf-3',
-      runId: 'run-3',
-      workflowType: 'workflow'
-    };
-    loadMock.mockReturnValue( {
-      activityInfo,
-      workflowDetails,
-      outputActivityKind: 'step'
-    } );
-
-    Event.emit( 'cost:http:request', {
-      activityInfo: { activityId: 'should-be-overridden' },
-      workflowDetails: { workflowId: 'should-be-overridden' },
-      outputActivityKind: 'should-be-overridden',
-      url: 'https://example.com'
-    } );
-
-    expect( emitMock ).toHaveBeenCalledWith( 'external:cost:http:request', expect.objectContaining( {
-      activityInfo,
-      workflowDetails,
-      outputActivityKind: 'step',
-      url: 'https://example.com'
-    } ) );
+    expect( emitMock ).toHaveBeenCalledWith( 'sdk:lifecycle:start', undefined );
   } );
 } );

package/src/worker/configs.js

@@ -36,8 +36,6 @@ const envVarSchema = z.object( {
   OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 2 * 60 * 1000 ) ), // 2min
   // Whether to send activity heartbeats (enabled by default)
   OUTPUT_ACTIVITY_HEARTBEAT_ENABLED: z.transform( v => v === undefined ? true : isStringboolTrue( v ) ),
-  // Time to allow for hooks to flush before shutdown
-  OUTPUT_PROCESS_FAILURE_SHUTDOWN_DELAY: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 3000 ) ),
   // Set temporal worker shutdown force time
   TEMPORAL_SHUTDOWN_FORCE_TIME: durationSchema,
   // Set temporal worker shutdown grace time
@@ -70,7 +68,6 @@ export const catalogId = envVars.OUTPUT_CATALOG_ID;
 export const workerTelemetryIntervalMs = envVars.OUTPUT_WORKER_TELEMETRY_INTERVAL_MS;
 export const activityHeartbeatIntervalMs = envVars.OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS;
 export const activityHeartbeatEnabled = envVars.OUTPUT_ACTIVITY_HEARTBEAT_ENABLED;
-export const processFailureShutdownDelay = envVars.OUTPUT_PROCESS_FAILURE_SHUTDOWN_DELAY;
 export const shutdownForceTime = envVars.TEMPORAL_SHUTDOWN_FORCE_TIME;
 export const shutdownGraceTime = envVars.TEMPORAL_SHUTDOWN_GRACE_TIME;
 export const grpcProxy = envVars.TEMPORAL_GRPC_PROXY;

package/src/worker/global_functions.js

@@ -1,4 +1,4 @@
-import { messageBus } from '#bus';
+import { mainEventBus } from '#bus';
 import { ACTIVITY_LOGGER_SYMBOL, BusEventType } from '#consts';
 import { activityInfo as activityInfoFn } from '@temporalio/activity';
 import { assignImmutableProperty } from '#helpers/object';
@@ -9,6 +9,6 @@ import { assignImmutableProperty } from '#helpers/object';
 export const bindGlobalFunctions = () => {
   /** Defines the activity logger function, accessible in activity context via logger interface */
   assignImmutableProperty( globalThis, ACTIVITY_LOGGER_SYMBOL, ( { level, message, metadata } ) =>
-    messageBus.emit( BusEventType.ACTIVITY_LOG, { level, message, metadata, activityInfo: activityInfoFn() } )
+    mainEventBus.emit( BusEventType.ACTIVITY_LOG, { level, message, metadata, activityInfo: activityInfoFn() } )
   );
 };

package/src/worker/global_functions.spec.js

@@ -10,7 +10,7 @@ const {
   }
 } ) );
 
-const messageBusMock = vi.hoisted( () => ( {
+const mainEventBusMock = vi.hoisted( () => ( {
   emit: vi.fn()
 } ) );
 const activityInfoMock = vi.hoisted( () => vi.fn( () => ( {
@@ -19,7 +19,7 @@ const activityInfoMock = vi.hoisted( () => vi.fn( () => ( {
 } ) ) );
 
 vi.mock( '#consts', () => ( { ACTIVITY_LOGGER_SYMBOL, BusEventType } ) );
-vi.mock( '#bus', () => ( { messageBus: messageBusMock } ) );
+vi.mock( '#bus', () => ( { mainEventBus: mainEventBusMock } ) );
 vi.mock( '@temporalio/activity', () => ( {
   activityInfo: activityInfoMock
 } ) );
@@ -42,7 +42,7 @@ describe( 'worker/global_functions', () => {
     } );
 
     expect( activityInfoMock ).toHaveBeenCalledTimes( 1 );
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.ACTIVITY_LOG, {
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.ACTIVITY_LOG, {
       level: 'debug',
       message: 'activity detail',
       metadata,

package/src/worker/index.js

@@ -12,8 +12,8 @@ import { initInterceptors } from './interceptors/index.js';
 import { createChildLogger } from '#logger';
 import { setupInterruptionHandler } from './interruption.js';
 import { CatalogJob } from './catalog_workflow/catalog_job.js';
-import { bootstrapFetchProxy } from './proxy.js';
-import { messageBus } from '#bus';
+import { mainEventBus } from '#bus';
+import { flushPendingHooks } from '#hooks/pending_hooks';
 import { BusEventType } from '#consts';
 import { setupTelemetry } from './telemetry.js';
 import { TemporalConnectionMonitor } from './connection_monitor.js';
@@ -60,8 +60,7 @@ const execute = async () => {
   log.info( 'Loading activities...', { callerDir } );
   const { activities } = await loadActivities( callerDir, workflows );
 
-  messageBus.emit( BusEventType.WORKER_BEFORE_START );
-  bootstrapFetchProxy();
+  mainEventBus.emit( BusEventType.WORKER_BEFORE_START );
 
   log.info( 'Initializing tracing...' );
   await initTracing();
@@ -214,13 +213,18 @@ execute()
         .catch( e => log.warn( 'Connection close error', { error: e.message } ) );
     }
   } )
-  .then( () => log.info( 'Bye' ) )
-  .catch( error => {
+  .then( async () => {
+    log.info( 'Flushing hook callbacks...' );
+    await flushPendingHooks();
+    log.info( 'Bye' );
+  } )
+  .catch( async error => {
     log.error( 'Fatal error', { error: error.message, stack: error.stack } );
 
-    messageBus.emit( BusEventType.RUNTIME_ERROR, { error } );
+    mainEventBus.emit( BusEventType.RUNTIME_ERROR, { error } );
 
-    const timeToFlushEvent = configs.processFailureShutdownDelay;
-    log.info( `Exiting in ${timeToFlushEvent}ms` );
-    setTimeout( () => process.exit( 1 ), timeToFlushEvent );
+    log.info( 'Flushing hook callbacks...' );
+    await flushPendingHooks();
+    log.info( 'Exiting...' );
+    setTimeout( () => process.exit( 1 ) );
   } );

package/src/worker/index.spec.js

@@ -6,8 +6,9 @@ const {
   configValues,
   connectionMonitorInstance,
   createCatalogMock,
+  flushPendingHooksMock,
   initInterceptorsMock,
-  messageBusMock,
+  mainEventBusMock,
   mockConnection,
   mockLog,
   mockWorker,
@@ -46,7 +47,6 @@ const {
     maxConcurrentActivityTaskPolls: 5,
     maxConcurrentWorkflowTaskPolls: 5,
     workerTuner: undefined,
-    processFailureShutdownDelay: 0,
     shutdownForceTime: undefined,
     shutdownGraceTime: undefined
   };
@@ -105,12 +105,13 @@ const {
     connectionMonitorInstance,
     createCatalogMock: vi.fn().mockReturnValue( { workflows: [], activities: {} } ),
     createWorkflowsEntryPointMock: vi.fn().mockReturnValue( '/fake/workflows/path.js' ),
+    flushPendingHooksMock: vi.fn().mockResolvedValue( undefined ),
     hashSourceCodeMock: vi.fn().mockResolvedValue( 'catalog-hash' ),
     initInterceptorsMock: vi.fn().mockReturnValue( [] ),
     loadActivitiesMock: vi.fn().mockResolvedValue( {} ),
     loadHooksMock: vi.fn().mockResolvedValue( undefined ),
     loadWorkflowsMock: vi.fn().mockResolvedValue( [] ),
-    messageBusMock: { emit: vi.fn(), on: vi.fn() },
+    mainEventBusMock: { emit: vi.fn(), on: vi.fn() },
     mockConnection: { close: vi.fn().mockResolvedValue( undefined ) },
     mockLog: { error: vi.fn(), info: vi.fn(), warn: vi.fn() },
     mockWorker,
@@ -128,7 +129,8 @@ vi.mock( '#consts', async importOriginal => {
 } );
 const initTracing = vi.fn().mockResolvedValue( undefined );
 vi.mock( '#tracing', () => ( { init: initTracing } ) );
-vi.mock( '#bus', () => ( { messageBus: messageBusMock } ) );
+vi.mock( '#bus', () => ( { mainEventBus: mainEventBusMock } ) );
+vi.mock( '#hooks/pending_hooks', () => ( { flushPendingHooks: flushPendingHooksMock } ) );
 
 const loadWorkflowsMock = vi.fn().mockResolvedValue( { workflows: [], entrypoint: '/fake/workflows/path.js' } );
 const loadActivitiesMock = vi.fn().mockResolvedValue( { activities: {} } );
@@ -145,7 +147,6 @@ vi.mock( './sinks.js', () => ( { sinks: {} } ) );
 vi.mock( './catalog_workflow/index.js', () => ( { createCatalog: createCatalogMock } ) );
 vi.mock( './bundler_options.js', () => ( { webpackConfigHook: vi.fn() } ) );
 vi.mock( './interceptors/index.js', () => ( { initInterceptors: initInterceptorsMock } ) );
-vi.mock( './proxy.js', () => ( { bootstrapFetchProxy: vi.fn() } ) );
 vi.mock( './telemetry.js', () => ( { setupTelemetry: setupTelemetryMock } ) );
 vi.mock( './interruption.js', () => ( { setupInterruptionHandler: setupInterruptionHandlerMock } ) );
 vi.mock( './global_functions.js', () => ( { bindGlobalFunctions: bindGlobalFunctionsMock } ) );
@@ -262,6 +263,7 @@ describe( 'worker/index', () => {
     expect( catalogJobInstance.run ).toHaveBeenCalled();
 
     await settleWorker();
+    await vi.waitFor( () => expect( flushPendingHooksMock ).toHaveBeenCalledOnce() );
     expect( mockLog.info ).toHaveBeenCalledWith( 'Bye' );
   } );
 
@@ -357,8 +359,11 @@ describe( 'worker/index', () => {
         error: 'Big Failure'
       } ) );
     } );
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
     await vi.waitFor( () => expect( exitMock ).toHaveBeenCalledWith( 1 ) );
+    expect( flushPendingHooksMock ).toHaveBeenCalledOnce();
+    expect( mainEventBusMock.emit.mock.invocationCallOrder[0] ).toBeLessThan( flushPendingHooksMock.mock.invocationCallOrder[0] );
+    expect( flushPendingHooksMock.mock.invocationCallOrder[0] ).toBeLessThan( exitMock.mock.invocationCallOrder[0] );
   } );
 
   it( 'throws connection monitor errors after graceful shutdown', async () => {
@@ -378,7 +383,7 @@ describe( 'worker/index', () => {
     } );
     expect( mockWorker.shutdown ).toHaveBeenCalledOnce();
     expect( catalogJobInstance.interrupt ).toHaveBeenCalledOnce();
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
   } );
 
   it( 'throws catalog job errors after graceful shutdown', async () => {
@@ -398,7 +403,7 @@ describe( 'worker/index', () => {
     } );
     expect( mockWorker.shutdown ).toHaveBeenCalledOnce();
     expect( connectionMonitorInstance.stop ).toHaveBeenCalledOnce();
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
   } );
 
   it( 'cleans up partial startup failures after connecting', async () => {

package/src/worker/interceptors/activity.js

@@ -4,7 +4,7 @@ import * as Tracing from '#tracing';
 import { headersToObject } from './headers.js';
 import { ACTIVITY_WRAPPER_VERSION_FIELD, BusEventType, METADATA_ACCESS_SYMBOL } from '#consts';
 import { activityHeartbeatEnabled, activityHeartbeatIntervalMs } from '../configs.js';
-import { messageBus } from '#bus';
+import { mainEventBus } from '#bus';
 import { aggregateAttributes } from '#helpers/aggregations';
 import { buildApplicationFailureWithDetails } from '#helpers/errors';
 
@@ -68,7 +68,7 @@ export class ActivityExecutionInterceptor {
       addAttribute
     };
 
-    messageBus.emit( BusEventType.ACTIVITY_START, { activityInfo, workflowDetails, outputActivityKind } );
+    mainEventBus.emit( BusEventType.ACTIVITY_START, { activityInfo, workflowDetails, outputActivityKind } );
     Tracing.addEventStart( { id: activityId, name: activityType, kind: outputActivityKind, parentId: runId, details: input.args[0], traceInfo } );
 
     try {
@@ -79,14 +79,14 @@ export class ActivityExecutionInterceptor {
 
       const aggregations = state.attributes.length > 0 ? aggregateAttributes( state.attributes ) : null;
 
-      messageBus.emit( BusEventType.ACTIVITY_END, { activityInfo, aggregations, workflowDetails, outputActivityKind } );
+      mainEventBus.emit( BusEventType.ACTIVITY_END, { activityInfo, aggregations, workflowDetails, outputActivityKind } );
       Tracing.addEventEnd( { id: activityId, details: output, traceInfo } );
 
       return { [ACTIVITY_WRAPPER_VERSION_FIELD]: 1, output, aggregations };
 
     } catch ( error ) {
       const aggregations = state.attributes.length > 0 ? aggregateAttributes( state.attributes ) : null;
-      messageBus.emit( BusEventType.ACTIVITY_ERROR, { activityInfo, aggregations, workflowDetails, outputActivityKind, error } );
+      mainEventBus.emit( BusEventType.ACTIVITY_ERROR, { activityInfo, aggregations, workflowDetails, outputActivityKind, error } );
       Tracing.addEventError( { id: activityId, details: error, traceInfo } );
 
       throw aggregations ? buildApplicationFailureWithDetails( error, { aggregations } ) : error;

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

@@ -61,8 +61,8 @@ vi.mock( './headers.js', () => ( {
   headersToObject: () => ( { traceInfo: traceInfoMock, workflowDetails: workflowDetailsMock } )
 } ) );
 
-const messageBusEmitMock = vi.fn();
-vi.mock( '#bus', () => ( { messageBus: { emit: messageBusEmitMock } } ) );
+const mainEventBusEmitMock = vi.fn();
+vi.mock( '#bus', () => ( { mainEventBus: { emit: mainEventBusEmitMock } } ) );
 
 vi.mock( '#consts', async importOriginal => {
   const actual = await importOriginal();
@@ -135,11 +135,11 @@ describe( 'ActivityExecutionInterceptor', () => {
       aggregations: null,
       [ACTIVITY_WRAPPER_VERSION_FIELD]: 1
     } );
-    expect( messageBusEmitMock ).toHaveBeenCalledWith(
+    expect( mainEventBusEmitMock ).toHaveBeenCalledWith(
       BusEventType.ACTIVITY_START,
       { activityInfo: activityInfoMock, workflowDetails: workflowDetailsMock, outputActivityKind: 'step' }
     );
-    expect( messageBusEmitMock ).toHaveBeenCalledWith(
+    expect( mainEventBusEmitMock ).toHaveBeenCalledWith(
       BusEventType.ACTIVITY_END,
       { activityInfo: activityInfoMock, aggregations: null, workflowDetails: workflowDetailsMock, outputActivityKind: 'step' }
     );
@@ -178,7 +178,7 @@ describe( 'ActivityExecutionInterceptor', () => {
       [ACTIVITY_WRAPPER_VERSION_FIELD]: 1
     } );
 
-    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_END, expect.any( Object ) );
+    expect( mainEventBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_END, expect.any( Object ) );
     expect( addEventEndMock ).toHaveBeenCalledWith( { id: 'act-1', details: { result: 'sync' }, traceInfo: traceInfoMock } );
     expect( addEventErrorMock ).not.toHaveBeenCalled();
   } );
@@ -198,7 +198,7 @@ describe( 'ActivityExecutionInterceptor', () => {
       [ACTIVITY_WRAPPER_VERSION_FIELD]: 1
     } );
 
-    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_END, {
+    expect( mainEventBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_END, {
       activityInfo: activityInfoMock,
       aggregations: httpRequestAggregations,
       workflowDetails: workflowDetailsMock,
@@ -226,7 +226,7 @@ describe( 'ActivityExecutionInterceptor', () => {
       } ],
       cause: error
     } );
-    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, {
+    expect( mainEventBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, {
       activityInfo: activityInfoMock,
       aggregations: httpRequestAggregations,
       workflowDetails: workflowDetailsMock,
@@ -318,8 +318,8 @@ 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( mainEventBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_START, expect.any( Object ) );
+    expect( mainEventBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, {
       activityInfo: activityInfoMock,
       aggregations: null,
       workflowDetails: workflowDetailsMock,

package/src/worker/log_hooks.js

@@ -1,4 +1,4 @@
-import { messageBus } from '#bus';
+import { mainEventBus } from '#bus';
 import { createChildLogger } from '#logger';
 import { ACTIVITY_GET_TRACE_DESTINATIONS, BusEventType, LifecycleEvent, WORKFLOW_CATALOG } from '#consts';
 
@@ -25,21 +25,21 @@ const serializedActivityFields = activityInfo => ( {
 
 const shouldLogActivity = activityInfo => activityInfo.activityType !== ACTIVITY_GET_TRACE_DESTINATIONS;
 
-messageBus.on( BusEventType.ACTIVITY_START, ( { activityInfo, outputActivityKind } ) =>
+mainEventBus.on( BusEventType.ACTIVITY_START, ( { activityInfo, outputActivityKind } ) =>
   shouldLogActivity( activityInfo ) && activityLog.info( `Started ${activityInfo.activityType} ${outputActivityKind}`, {
     event: LifecycleEvent.START,
     ...serializedActivityFields( activityInfo )
   } )
 );
 
-messageBus.on( BusEventType.ACTIVITY_END, ( { activityInfo, outputActivityKind } ) =>
+mainEventBus.on( BusEventType.ACTIVITY_END, ( { activityInfo, outputActivityKind } ) =>
   shouldLogActivity( activityInfo ) && activityLog.info( `Ended ${activityInfo.activityType} ${outputActivityKind}`, {
     event: LifecycleEvent.END,
     ...serializedActivityFields( activityInfo )
   } )
 );
 
-messageBus.on( BusEventType.ACTIVITY_ERROR, ( { activityInfo, outputActivityKind, error } ) =>
+mainEventBus.on( BusEventType.ACTIVITY_ERROR, ( { activityInfo, outputActivityKind, error } ) =>
   shouldLogActivity( activityInfo ) && activityLog.error( `Error ${activityInfo.activityType} ${outputActivityKind}: ${error.constructor.name}`, {
     event: LifecycleEvent.ERROR,
     ...serializedActivityFields( activityInfo ),
@@ -47,7 +47,7 @@ messageBus.on( BusEventType.ACTIVITY_ERROR, ( { activityInfo, outputActivityKind
   } )
 );
 
-messageBus.on( BusEventType.ACTIVITY_LOG, ( { level, message, metadata, activityInfo } ) =>
+mainEventBus.on( BusEventType.ACTIVITY_LOG, ( { level, message, metadata, activityInfo } ) =>
   activityLog[level]( message, {
     ...metadata ?? {},
     ...serializedActivityFields( activityInfo )
@@ -68,21 +68,21 @@ const serializeWorkflowFields = workflowDetails => ( {
 
 const shouldLogWorkflow = workflowDetails => workflowDetails.workflowType !== WORKFLOW_CATALOG;
 
-messageBus.on( BusEventType.WORKFLOW_START, ( { workflowDetails } ) =>
+mainEventBus.on( BusEventType.WORKFLOW_START, ( { workflowDetails } ) =>
   shouldLogWorkflow( workflowDetails ) && workflowLog.info( `Started ${workflowDetails.workflowType} workflow`, {
     event: LifecycleEvent.START,
     ...serializeWorkflowFields( workflowDetails )
   } )
 );
 
-messageBus.on( BusEventType.WORKFLOW_END, ( { workflowDetails } ) =>
+mainEventBus.on( BusEventType.WORKFLOW_END, ( { workflowDetails } ) =>
   shouldLogWorkflow( workflowDetails ) && workflowLog.info( `Ended ${workflowDetails.workflowType} workflow`, {
     event: LifecycleEvent.END,
     ...serializeWorkflowFields( workflowDetails )
   } )
 );
 
-messageBus.on( BusEventType.WORKFLOW_ERROR, ( { workflowDetails, error } ) =>
+mainEventBus.on( BusEventType.WORKFLOW_ERROR, ( { workflowDetails, error } ) =>
   shouldLogWorkflow( workflowDetails ) && workflowLog.error( `Error ${workflowDetails.workflowType} workflow: ${error.constructor.name}`, {
     event: LifecycleEvent.ERROR,
     ...serializeWorkflowFields( workflowDetails ),
@@ -90,7 +90,7 @@ messageBus.on( BusEventType.WORKFLOW_ERROR, ( { workflowDetails, error } ) =>
   } )
 );
 
-messageBus.on( BusEventType.WORKFLOW_LOG, ( { level, message, metadata, workflowDetails } ) =>
+mainEventBus.on( BusEventType.WORKFLOW_LOG, ( { level, message, metadata, workflowDetails } ) =>
   workflowLog[level]( message, {
     ...metadata ?? {},
     ...serializeWorkflowFields( workflowDetails )

package/src/worker/log_hooks.spec.js

@@ -22,14 +22,14 @@ const createChildLoggerMock = vi.hoisted( () =>
 );
 
 const onHandlers = vi.hoisted( () => ( {} ) );
-const messageBusMock = vi.hoisted( () => ( {
+const mainEventBusMock = vi.hoisted( () => ( {
   on: vi.fn( ( eventType, handler ) => {
     onHandlers[eventType] = handler;
   } )
 } ) );
 
 vi.mock( '#logger', () => ( { createChildLogger: createChildLoggerMock } ) );
-vi.mock( '#bus', () => ( { messageBus: messageBusMock } ) );
+vi.mock( '#bus', () => ( { mainEventBus: mainEventBusMock } ) );
 
 import './log_hooks.js';
 

package/src/worker/sinks.js

@@ -1,6 +1,6 @@
 import { BusEventType, ComponentType } from '#consts';
 import * as Tracing from '#tracing';
-import { messageBus } from '#bus';
+import { mainEventBus } from '#bus';
 import { createWorkflowDetails } from '#helpers/temporal_context';
 
 // This sink allow for sandbox Temporal environment to send trace logs back to the main thread.
@@ -12,15 +12,15 @@ export const sinks = {
   workflow: {
     log: {
       fn: ( workflowInfo, { level, message, metadata } ) => {
-        messageBus.emit( BusEventType.WORKFLOW_LOG, { level, message, metadata, workflowDetails: createWorkflowDetails( workflowInfo ) } );
+        mainEventBus.emit( BusEventType.WORKFLOW_LOG, { level, message, metadata, workflowDetails: createWorkflowDetails( workflowInfo ) } );
       },
       callDuringReplay: false
     },
     start: {
       fn: ( workflowInfo, input ) => {
         const { runId, workflowType, memo: { traceInfo }, parent } = workflowInfo;
-        messageBus.emit( BusEventType.WORKFLOW_START, { workflowDetails: createWorkflowDetails( workflowInfo ) } );
-        if ( traceInfo ) { // internal workflows (catalog) do not have this info
+        mainEventBus.emit( BusEventType.WORKFLOW_START, { workflowDetails: createWorkflowDetails( workflowInfo ) } );
+        if ( traceInfo ) {
           Tracing.addEventStart( {
             id: runId,
             kind: ComponentType.WORKFLOW,
@@ -37,8 +37,8 @@ export const sinks = {
     end: {
       fn: ( workflowInfo, output ) => {
         const { runId, memo: { traceInfo } } = workflowInfo;
-        messageBus.emit( BusEventType.WORKFLOW_END, { workflowDetails: createWorkflowDetails( workflowInfo ) } );
-        if ( traceInfo ) { // internal workflows (catalog) do not have this info
+        mainEventBus.emit( BusEventType.WORKFLOW_END, { workflowDetails: createWorkflowDetails( workflowInfo ) } );
+        if ( traceInfo ) {
           Tracing.addEventEnd( { id: runId, details: output, traceInfo } );
         }
       },
@@ -48,8 +48,8 @@ export const sinks = {
     error: {
       fn: ( workflowInfo, error ) => {
         const { runId, memo: { traceInfo } } = workflowInfo;
-        messageBus.emit( BusEventType.WORKFLOW_ERROR, { workflowDetails: createWorkflowDetails( workflowInfo ), error } );
-        if ( traceInfo ) { // internal workflows (catalog) do not have this info
+        mainEventBus.emit( BusEventType.WORKFLOW_ERROR, { workflowDetails: createWorkflowDetails( workflowInfo ), error } );
+        if ( traceInfo ) {
           Tracing.addEventError( { id: runId, details: error, traceInfo } );
         }
       },