@outputai/core 0.10.1-next.b7b2fbe.0 → 0.10.1-next.bf95a6f.0

package/src/worker/loader/workflows.js

@@ -1,7 +1,7 @@
 import { EOL } from 'node:os';
 import { writeFileInTempDir, findWorkflowsInNodeModules, importComponents, matchFiles } from './tools.js';
 import { staticMatchers } from './matchers.js';
-import { WORKFLOWS_INDEX_FILENAME, WORKFLOW_CATALOG } from '#consts';
+import { WORKFLOWS_INDEX_FILENAME, WORKFLOW_CATALOG, WORKFLOW_OPTIONS_FILENAME } from '#consts';
 import { createChildLogger } from '#logger';
 import { ValidationError } from '#errors';
 
@@ -38,6 +38,7 @@ const createWorkflowsEntrypoint = workflows => {
  * @typedef LoadWorkflowsResult
  * @property {Workflow[]} workflows - Loaded workflows
  * @property {string} entrypoint - Index file loading all workflows
+ * @property {string} optionsFile - File exporting options for each workflow and their aliases
  */
 /**
  * Scan and find workflow.js files and import them.
@@ -47,6 +48,8 @@ const createWorkflowsEntrypoint = workflows => {
  */
 export async function loadWorkflows( rootDir ) {
   const workflowNames = new Set();
+  const workflowOptions = new Map();
+
   const workflows = [];
   const localWorkflows = matchFiles( rootDir, [ staticMatchers.workflowFile ] );
   const externalWorkflows = findWorkflowsInNodeModules( rootDir );
@@ -55,7 +58,7 @@ export async function loadWorkflows( rootDir ) {
     if ( staticMatchers.workflowPathHasShared( path ) ) {
       throw new ValidationError( 'Workflow directory can\'t be named "shared"' );
     }
-    const { name, aliases } = metadata;
+    const { name, aliases, options } = metadata;
     if ( workflowNames.has( name ) ) {
       throw new ValidationError( `Workflow name "${name}" conflicts with another workflow or alias. \
 Workflow names and aliases must be unique.` );
@@ -64,6 +67,8 @@ Workflow names and aliases must be unique.` );
       throw new ValidationError( `Workflow name "${name}" is reserved for the internal catalog workflow.` );
     }
     workflowNames.add( name );
+    workflowOptions.set( name, { disableTrace: options?.disableTrace ?? false } );
+
     for ( const alias of aliases ?? [] ) {
       if ( workflowNames.has( alias ) ) {
         throw new ValidationError( `Workflow "${name}" alias "${alias}" conflicts with another workflow or alias. \
@@ -73,10 +78,18 @@ Workflow names and aliases must be unique.` );
         throw new ValidationError( `Workflow "${name}" alias "${alias}" is reserved for the internal catalog workflow.` );
       }
       workflowNames.add( alias );
+      workflowOptions.set( alias, { disableTrace: options?.disableTrace ?? false } );
     }
 
     log.info( name, { path, aliases, ...( external && { external } ) } );
     workflows.push( { ...metadata, path, external } );
   }
-  return { workflows, entrypoint: createWorkflowsEntrypoint( workflows ) };
+
+  workflowOptions.set( WORKFLOW_CATALOG, { disableTrace: true } );
+
+  // writes down the static workflow options, currently only disable trace
+  const optionsContent = `export default ${JSON.stringify( Object.fromEntries( workflowOptions ), undefined, 2 )};`;
+  const optionsFile = writeFileInTempDir( optionsContent, WORKFLOW_OPTIONS_FILENAME );
+
+  return { workflows, entrypoint: createWorkflowsEntrypoint( workflows ), optionsFile };
 };

package/src/worker/loader/workflows.spec.js

@@ -6,7 +6,7 @@ vi.mock( '#consts', () => ( {
   WORKFLOWS_INDEX_FILENAME: '__workflows_entrypoint.js',
   WORKFLOW_CATALOG: 'catalog',
   ACTIVITY_OPTIONS_FILENAME: '__activity_options.js',
-  SHARED_STEP_PREFIX: '$shared'
+  WORKFLOW_OPTIONS_FILENAME: '__workflow_options.js'
 } ) );
 
 const { importComponentsMock, findWorkflowsInNodeModulesMock, matchFilesMock, writeFileInTempDirMock } = vi.hoisted( () => ( {
@@ -45,7 +45,7 @@ describe( 'loadWorkflows', () => {
     matchFilesMock.mockReset();
     matchFilesMock.mockReturnValue( [] );
     writeFileInTempDirMock.mockReset();
-    writeFileInTempDirMock.mockReturnValue( '/tmp/__workflows_entrypoint.js' );
+    writeFileInTempDirMock.mockImplementation( ( _, filename ) => `/tmp/${filename}` );
     workflowPathHasSharedMock.mockReset();
     workflowPathHasSharedMock.mockReturnValue( false );
   } );
@@ -59,9 +59,10 @@ describe( 'loadWorkflows', () => {
       yield { metadata: { name: 'Flow1', description: 'd' }, path: '/b/workflow.js' };
     } );
 
-    const { workflows, entrypoint } = await loadWorkflows( '/root' );
+    const { workflows, entrypoint, optionsFile } = await loadWorkflows( '/root' );
     expect( workflows ).toEqual( [ { name: 'Flow1', description: 'd', path: '/b/workflow.js', external: false } ] );
     expect( entrypoint ).toBe( '/tmp/__workflows_entrypoint.js' );
+    expect( optionsFile ).toBe( '/tmp/__workflow_options.js' );
     expect( importComponentsMock ).toHaveBeenNthCalledWith( 1, localFiles );
     expect( findWorkflowsInNodeModulesMock ).toHaveBeenCalledOnce();
     expect( findWorkflowsInNodeModulesMock ).toHaveBeenCalledWith( '/root' );
@@ -245,12 +246,42 @@ describe( 'loadWorkflows', () => {
     const { entrypoint } = await loadWorkflows( '/root' );
 
     expect( entrypoint ).toBe( '/tmp/__workflows_entrypoint.js' );
-    expect( writeFileInTempDirMock ).toHaveBeenCalledTimes( 1 );
-    const [ contents, filename ] = writeFileInTempDirMock.mock.calls[0];
+    expect( writeFileInTempDirMock ).toHaveBeenCalledTimes( 2 );
+    const [ contents, filename ] = writeFileInTempDirMock.mock.calls.find( ( [ , calledFilename ] ) =>
+      calledFilename === '__workflows_entrypoint.js'
+    );
     expect( filename ).toBe( '__workflows_entrypoint.js' );
     expect( contents ).toContain( 'export { default as W } from \'/abs/wf.js\';' );
     expect( contents ).toContain( 'export { default as W_old } from \'/abs/wf.js\';' );
     expect( contents ).toContain( 'export { default as W_legacy } from \'/abs/wf.js\';' );
     expect( contents ).toContain( 'export { default as catalog }' );
   } );
+
+  it( 'writes trace options for workflow names, aliases, and the catalog workflow', async () => {
+    const { loadWorkflows } = await import( './workflows.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield {
+        metadata: { name: 'Traced', aliases: [ 'Traced_old' ] },
+        path: '/abs/traced.js'
+      };
+      yield {
+        metadata: { name: 'Untraced', aliases: [ 'Untraced_old' ], options: { disableTrace: true } },
+        path: '/abs/untraced.js'
+      };
+    } );
+
+    await loadWorkflows( '/root' );
+
+    const [ contents, filename ] = writeFileInTempDirMock.mock.calls.find( ( [ , calledFilename ] ) =>
+      calledFilename === '__workflow_options.js'
+    );
+    expect( filename ).toBe( '__workflow_options.js' );
+    expect( contents ).toBe( `export default ${JSON.stringify( {
+      Traced: { disableTrace: false },
+      Traced_old: { disableTrace: false },
+      Untraced: { disableTrace: true },
+      Untraced_old: { disableTrace: true },
+      catalog: { disableTrace: true }
+    }, undefined, 2 )};` );
+  } );
 } );

package/src/worker/log_hooks.js

@@ -1,6 +1,7 @@
-import { messageBus } from '#bus';
+import { mainEventBus } from '#bus';
 import { createChildLogger } from '#logger';
 import { ACTIVITY_GET_TRACE_DESTINATIONS, BusEventType, LifecycleEvent, WORKFLOW_CATALOG } from '#consts';
+import { serializeError } from '#helpers/error_serializer';
 
 const activityLog = createChildLogger( 'Activity' );
 const workflowLog = createChildLogger( 'Workflow' );
@@ -25,29 +26,30 @@ 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 } ) =>
-  shouldLogActivity( activityInfo ) && activityLog.error( `Error ${activityInfo.activityType} ${outputActivityKind}: ${error.constructor.name}`, {
-    event: LifecycleEvent.ERROR,
-    ...serializedActivityFields( activityInfo ),
-    error: error.message
-  } )
+mainEventBus.on( BusEventType.ACTIVITY_ERROR, ( { activityInfo, outputActivityKind, error } ) =>
+  shouldLogActivity( activityInfo ) &&
+    activityLog.error( `Error ${activityInfo.activityType} ${outputActivityKind}: ${error.name ?? error.constructor.name}`, {
+      event: LifecycleEvent.ERROR,
+      ...serializedActivityFields( activityInfo ),
+      error: serializeError( error, { dropKeys: [ 'stack' ] } )
+    } )
 );
 
-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,29 +70,30 @@ 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 } ) =>
-  shouldLogWorkflow( workflowDetails ) && workflowLog.error( `Error ${workflowDetails.workflowType} workflow: ${error.constructor.name}`, {
-    event: LifecycleEvent.ERROR,
-    ...serializeWorkflowFields( workflowDetails ),
-    error: error.message
-  } )
+mainEventBus.on( BusEventType.WORKFLOW_ERROR, ( { workflowDetails, error } ) =>
+  shouldLogWorkflow( workflowDetails ) &&
+    workflowLog.error( `Error ${workflowDetails.workflowType} workflow: ${error.name ?? error.constructor.name}`, {
+      event: LifecycleEvent.ERROR,
+      ...serializeWorkflowFields( workflowDetails ),
+      error: serializeError( error, { dropKeys: [ 'stack' ] } )
+    } )
 );
 
-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,19 @@ const createChildLoggerMock = vi.hoisted( () =>
 );
 
 const onHandlers = vi.hoisted( () => ( {} ) );
-const messageBusMock = vi.hoisted( () => ( {
+const mainEventBusMock = vi.hoisted( () => ( {
   on: vi.fn( ( eventType, handler ) => {
     onHandlers[eventType] = handler;
   } )
 } ) );
+const serializeErrorMock = vi.hoisted( () => vi.fn( error => ( {
+  name: error.name,
+  message: error.message
+} ) ) );
 
 vi.mock( '#logger', () => ( { createChildLogger: createChildLoggerMock } ) );
-vi.mock( '#bus', () => ( { messageBus: messageBusMock } ) );
+vi.mock( '#bus', () => ( { mainEventBus: mainEventBusMock } ) );
+vi.mock( '#helpers/error_serializer', () => ( { serializeError: serializeErrorMock } ) );
 
 import './log_hooks.js';
 
@@ -104,6 +109,7 @@ describe( 'log_hooks', () => {
 
     it( 'ACTIVITY_ERROR logs full message and second arg', () => {
       const err = new Error( 'step failed' );
+      err.name = 'ProviderError';
       onHandlers[BusEventType.ACTIVITY_ERROR]( {
         ...basePayload,
         duration: 100,
@@ -112,7 +118,7 @@ describe( 'log_hooks', () => {
 
       expect( activityLogMock.error ).toHaveBeenCalledTimes( 1 );
       expect( activityLogMock.error ).toHaveBeenCalledWith(
-        'Error myWorkflow#myStep step: Error',
+        'Error myWorkflow#myStep step: ProviderError',
         {
           event: LifecycleEvent.ERROR,
           activityId: 'act-1',
@@ -120,9 +126,10 @@ describe( 'log_hooks', () => {
           workflowId: 'wf-1',
           workflowType: 'myWorkflow',
           runId: 'run-1',
-          error: 'step failed'
+          error: { name: 'ProviderError', message: 'step failed' }
         }
       );
+      expect( serializeErrorMock ).toHaveBeenCalledWith( err, { dropKeys: [ 'stack' ] } );
     } );
 
     it( 'ACTIVITY_ERROR does not log trace destination activity', () => {
@@ -229,7 +236,7 @@ describe( 'log_hooks', () => {
     } );
 
     it( 'WORKFLOW_ERROR logs full message and second arg', () => {
-      const err = new TypeError( 'workflow boom' );
+      const err = { name: 'TypeError', message: 'workflow boom' };
       onHandlers[BusEventType.WORKFLOW_ERROR]( {
         ...basePayload,
         duration: 150,
@@ -244,9 +251,10 @@ describe( 'log_hooks', () => {
           workflowId: 'wf-1',
           workflowType: 'myWorkflow',
           runId: 'run-1',
-          error: 'workflow boom'
+          error: { name: 'TypeError', message: 'workflow boom' }
         }
       );
+      expect( serializeErrorMock ).toHaveBeenCalledWith( err, { dropKeys: [ 'stack' ] } );
     } );
 
     it( 'WORKFLOW_ERROR does not log when workflowType is WORKFLOW_CATALOG', () => {

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 } );
         }
       },

package/src/worker/sinks.spec.js

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { BusEventType, ComponentType } from '#consts';
 
-const messageBusMock = vi.hoisted( () => ( {
+const mainEventBusMock = vi.hoisted( () => ( {
   emit: vi.fn()
 } ) );
 
@@ -15,7 +15,7 @@ const createWorkflowDetailsMock = vi.hoisted( () => vi.fn( workflowInfo => ( {
   runId: workflowInfo.runId
 } ) ) );
 
-vi.mock( '#bus', () => ( { messageBus: messageBusMock } ) );
+vi.mock( '#bus', () => ( { mainEventBus: mainEventBusMock } ) );
 vi.mock( '#tracing', () => ( {
   addEventStart: addEventStartMock,
   addEventEnd: addEventEndMock,
@@ -69,7 +69,7 @@ describe( 'worker/sinks', () => {
     } );
 
     expect( createWorkflowDetailsMock ).toHaveBeenCalledWith( workflowInfo );
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_LOG, {
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_LOG, {
       level: 'info',
       message: 'workflow detail',
       metadata,
@@ -83,7 +83,7 @@ describe( 'worker/sinks', () => {
 
     sinks.workflow.start.fn( workflowInfo, input );
 
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_START, { workflowDetails } );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_START, { workflowDetails } );
     expect( addEventStartMock ).toHaveBeenCalledWith( {
       id: 'run-1',
       kind: ComponentType.WORKFLOW,
@@ -99,7 +99,7 @@ describe( 'worker/sinks', () => {
 
     sinks.workflow.start.fn( { ...workflowInfo, memo: {} }, { value: 'input' } );
 
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_START, { workflowDetails } );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_START, { workflowDetails } );
     expect( addEventStartMock ).not.toHaveBeenCalled();
   } );
 
@@ -109,7 +109,7 @@ describe( 'worker/sinks', () => {
 
     sinks.workflow.end.fn( workflowInfo, output );
 
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_END, { workflowDetails } );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_END, { workflowDetails } );
     expect( addEventEndMock ).toHaveBeenCalledWith( {
       id: 'run-1',
       details: output,
@@ -122,7 +122,7 @@ describe( 'worker/sinks', () => {
 
     sinks.workflow.end.fn( { ...workflowInfo, memo: {} }, { value: 'output' } );
 
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_END, { workflowDetails } );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_END, { workflowDetails } );
     expect( addEventEndMock ).not.toHaveBeenCalled();
   } );
 
@@ -132,7 +132,7 @@ describe( 'worker/sinks', () => {
 
     sinks.workflow.error.fn( workflowInfo, error );
 
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_ERROR, { workflowDetails, error } );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_ERROR, { workflowDetails, error } );
     expect( addEventErrorMock ).toHaveBeenCalledWith( {
       id: 'run-1',
       details: error,
@@ -146,7 +146,7 @@ describe( 'worker/sinks', () => {
 
     sinks.workflow.error.fn( { ...workflowInfo, memo: {} }, error );
 
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_ERROR, { workflowDetails, error } );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_ERROR, { workflowDetails, error } );
     expect( addEventErrorMock ).not.toHaveBeenCalled();
   } );
 

package/src/worker/telemetry.js

@@ -1,3 +1,4 @@
+import { serializeError } from '#helpers/error_serializer';
 import { createChildLogger } from '#logger';
 import { workerTelemetryIntervalMs } from './configs.js';
 
@@ -18,7 +19,7 @@ export const setupTelemetry = ( { worker } ) => {
         }
       } );
     } catch ( error ) {
-      log.warn( 'Failure', { error: error.message } );
+      log.warn( 'Failure', { error: serializeError( error, { dropKeys: [ 'stack' ] } ) } );
     }
   }, workerTelemetryIntervalMs ).unref();
 };

package/src/worker/temporal_logger.js

@@ -0,0 +1,33 @@
+import { DefaultLogger, makeTelemetryFilterString, Runtime } from '@temporalio/worker';
+import { createChildLogger } from '#logger';
+
+const log = createChildLogger( 'Temporal' );
+const OMITTED_MESSAGES = [ 'Activity failed', 'Workflow failed' ];
+
+const temporalLevelToInternalLevelMap = {
+  TRACE: 'debug',
+  DEBUG: 'debug',
+  INFO: 'info',
+  WARN: 'warn',
+  ERROR: 'error'
+};
+
+export const setupTemporalLogger = () => {
+  const level = process.env.OUTPUT_TEMPORAL_LOG_LEVEL?.toUpperCase() ?? 'INFO';
+
+  Runtime.install( {
+    logger: new DefaultLogger( level, entry => {
+      // Already reported by Output activity logs and traces.
+      if ( OMITTED_MESSAGES.includes( entry.message ) ) {
+        return;
+      }
+      log.log( temporalLevelToInternalLevelMap[entry.level], entry.message, entry.meta );
+    } ),
+    telemetryOptions: {
+      logging: {
+        forward: {},
+        filter: makeTelemetryFilterString( { core: level, other: level } )
+      }
+    }
+  } );
+};

package/src/worker/temporal_logger.spec.js

@@ -0,0 +1,90 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const {
+  defaultLoggerMock,
+  logMock,
+  makeTelemetryFilterStringMock,
+  runtimeInstallMock
+} = vi.hoisted( () => ( {
+  defaultLoggerMock: vi.fn( function ( level, callback ) {
+    this.level = level;
+    this.callback = callback;
+  } ),
+  logMock: { log: vi.fn() },
+  makeTelemetryFilterStringMock: vi.fn().mockReturnValue( 'temporal-filter' ),
+  runtimeInstallMock: vi.fn()
+} ) );
+
+vi.mock( '@temporalio/worker', () => ( {
+  DefaultLogger: defaultLoggerMock,
+  makeTelemetryFilterString: makeTelemetryFilterStringMock,
+  Runtime: { install: runtimeInstallMock }
+} ) );
+vi.mock( '#logger', () => ( { createChildLogger: () => logMock } ) );
+
+import { setupTemporalLogger } from './temporal_logger.js';
+
+describe( 'setupTemporalLogger', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    vi.stubEnv( 'OUTPUT_TEMPORAL_LOG_LEVEL', undefined );
+  } );
+
+  afterEach( () => {
+    vi.unstubAllEnvs();
+  } );
+
+  it( 'forwards Temporal SDK and Core logs through the application logger', () => {
+    setupTemporalLogger();
+
+    expect( makeTelemetryFilterStringMock ).toHaveBeenCalledWith( { core: 'INFO', other: 'INFO' } );
+    expect( defaultLoggerMock ).toHaveBeenCalledWith( 'INFO', expect.any( Function ) );
+    expect( runtimeInstallMock ).toHaveBeenCalledWith( {
+      logger: expect.any( defaultLoggerMock ),
+      telemetryOptions: {
+        logging: {
+          forward: {},
+          filter: 'temporal-filter'
+        }
+      }
+    } );
+
+    const [ entryCallback ] = defaultLoggerMock.mock.calls[0].slice( 1 );
+    entryCallback( { level: 'WARN', message: 'Worker warning', meta: { taskQueue: 'default' } } );
+
+    expect( logMock.log ).toHaveBeenCalledWith( 'warn', 'Worker warning', { taskQueue: 'default' } );
+  } );
+
+  it.each( [
+    [ 'TRACE', 'debug' ],
+    [ 'DEBUG', 'debug' ],
+    [ 'INFO', 'info' ],
+    [ 'WARN', 'warn' ],
+    [ 'ERROR', 'error' ]
+  ] )( 'maps Temporal %s logs to the %s application level', ( temporalLevel, internalLevel ) => {
+    setupTemporalLogger();
+    const [ entryCallback ] = defaultLoggerMock.mock.calls[0].slice( 1 );
+
+    entryCallback( { level: temporalLevel, message: `${temporalLevel} event`, meta: { source: 'test' } } );
+
+    expect( logMock.log ).toHaveBeenCalledWith( internalLevel, `${temporalLevel} event`, { source: 'test' } );
+  } );
+
+  it( 'applies a case-insensitive configured log level to SDK and Core logs', () => {
+    vi.stubEnv( 'OUTPUT_TEMPORAL_LOG_LEVEL', 'debug' );
+
+    setupTemporalLogger();
+
+    expect( defaultLoggerMock ).toHaveBeenCalledWith( 'DEBUG', expect.any( Function ) );
+    expect( makeTelemetryFilterStringMock ).toHaveBeenCalledWith( { core: 'DEBUG', other: 'DEBUG' } );
+  } );
+
+  it.each( [ 'Activity failed', 'Workflow failed' ] )( 'omits redundant "%s" events', message => {
+    setupTemporalLogger();
+    const [ entryCallback ] = defaultLoggerMock.mock.calls[0].slice( 1 );
+
+    entryCallback( { level: 'WARN', message, meta: { error: new Error( 'failed' ) } } );
+
+    expect( logMock.log ).not.toHaveBeenCalled();
+  } );
+} );

package/src/worker/webpack_loaders/consts.js

@@ -7,3 +7,9 @@ export const ComponentFile = {
   STEPS: 'steps',
   WORKFLOW: 'workflow'
 };
+
+export const ComponentFactory = {
+  EVALUATOR: 'evaluator',
+  STEP: 'step',
+  WORKFLOW: 'workflow'
+};