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

package/src/internal_utils/trace_info.spec.js

@@ -0,0 +1,47 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { TraceInfo } from './trace_info.js';
+
+const inWorkflowContextMock = vi.hoisted( () => vi.fn() );
+const workflowInfoMock = vi.hoisted( () => vi.fn() );
+
+vi.mock( '@temporalio/workflow', () => ( {
+  inWorkflowContext: inWorkflowContextMock,
+  workflowInfo: workflowInfoMock
+} ) );
+
+describe( 'TraceInfo', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+  } );
+
+  it( 'builds trace info from Temporal workflow info in workflow context', () => {
+    inWorkflowContextMock.mockReturnValue( true );
+    workflowInfoMock.mockReturnValue( {
+      workflowId: 'workflow-id',
+      workflowType: 'workflow-type',
+      runId: 'run-id',
+      startTime: new Date( '2026-06-02T09:00:00.000Z' )
+    } );
+
+    expect( TraceInfo.build( { disableTrace: false } ) ).toEqual( {
+      workflowId: 'workflow-id',
+      workflowType: 'workflow-type',
+      runId: 'run-id',
+      startTime: Date.parse( '2026-06-02T09:00:00.000Z' ),
+      disableTrace: false
+    } );
+  } );
+
+  it( 'builds trace info without Temporal fields outside workflow context', () => {
+    inWorkflowContextMock.mockReturnValue( false );
+
+    expect( TraceInfo.build( { disableTrace: true } ) ).toEqual( {
+      workflowId: undefined,
+      workflowType: undefined,
+      runId: undefined,
+      startTime: undefined,
+      disableTrace: true
+    } );
+    expect( workflowInfoMock ).not.toHaveBeenCalled();
+  } );
+} );

package/src/internal_utils/workflow_context.js

@@ -0,0 +1,29 @@
+import { workflowInfo, continueAsNew, inWorkflowContext } from '@temporalio/workflow';
+
+export class WorkflowContext {
+
+  /**
+   * Builds a new context instance
+   * @returns {object} context
+   */
+  static build() {
+    if ( !inWorkflowContext() ) {
+      return {
+        control: {
+          continueAsNew: async () => {},
+          isContinueAsNewSuggested: () => false
+        },
+        info: { workflowId: 'test-workflow', runId: 'test-run' }
+      };
+    }
+
+    const { workflowId, runId } = workflowInfo();
+    return {
+      control: {
+        continueAsNew,
+        isContinueAsNewSuggested: () => workflowInfo().continueAsNewSuggested
+      },
+      info: { workflowId, runId }
+    };
+  }
+};

package/src/internal_utils/workflow_context.spec.js

@@ -0,0 +1,46 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { WorkflowContext } from './workflow_context.js';
+
+const inWorkflowContextMock = vi.hoisted( () => vi.fn() );
+const workflowInfoMock = vi.hoisted( () => vi.fn() );
+const continueAsNewMock = vi.hoisted( () => vi.fn() );
+
+vi.mock( '@temporalio/workflow', () => ( {
+  continueAsNew: continueAsNewMock,
+  inWorkflowContext: inWorkflowContextMock,
+  workflowInfo: workflowInfoMock
+} ) );
+
+describe( 'WorkflowContext', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+  } );
+
+  it( 'builds a test context outside Temporal workflow context', async () => {
+    inWorkflowContextMock.mockReturnValue( false );
+
+    const context = WorkflowContext.build();
+
+    expect( context.info ).toEqual( { workflowId: 'test-workflow', runId: 'test-run' } );
+    expect( context.control.isContinueAsNewSuggested() ).toBe( false );
+    await expect( context.control.continueAsNew() ).resolves.toBeUndefined();
+    expect( workflowInfoMock ).not.toHaveBeenCalled();
+    expect( continueAsNewMock ).not.toHaveBeenCalled();
+  } );
+
+  it( 'builds a workflow context from Temporal workflow info', () => {
+    inWorkflowContextMock.mockReturnValue( true );
+    workflowInfoMock.mockReturnValue( {
+      workflowId: 'workflow-id',
+      runId: 'run-id',
+      continueAsNewSuggested: true
+    } );
+
+    const context = WorkflowContext.build();
+
+    expect( context.info ).toEqual( { workflowId: 'workflow-id', runId: 'run-id' } );
+    expect( context.control.continueAsNew ).toBe( continueAsNewMock );
+    expect( context.control.isContinueAsNewSuggested() ).toBe( true );
+    expect( workflowInfoMock ).toHaveBeenCalledTimes( 2 );
+  } );
+} );

package/src/logger/development.js

@@ -0,0 +1,61 @@
+import { format, transports } from 'winston';
+import { isPlainObject, shuffleArray } from '#utils';
+
+/** Available colors enum */
+const Color = {
+  Blue: '033',
+  Green: '030',
+  Orange: '208',
+  Turquoise: '045',
+  Purple: '129',
+  Yellow: '184'
+};
+
+/**
+ * Recursively format object as friendly JSON: { name: "foo", count: 5 }
+ *
+ * @param {any} v - The input value
+ * @returns {string} Formatted result
+ */
+export const formatJson = v => {
+  if ( isPlainObject( v ) ) {
+    const entries = Object.entries( v );
+    return entries.length === 0 ? '{}' :
+      `{ ${entries.map( ( [ k, v ] ) => `${k}: ${formatJson( v )}` ).join( ', ' )} }`;
+  }
+  if ( Array.isArray( v ) ) {
+    return v.length === 0 ? '[]' : `[ ${v.map( p => formatJson( p ) ).join( ', ' )} ]`;
+  }
+  if ( typeof v === 'string' ) {
+    return JSON.stringify( v );
+  }
+  return v;
+};
+
+/** This instance color schema */
+const COLORS = shuffleArray( Object.values( Color ) );
+
+/** Stores all assigned colors per namespace. */
+const assignedColors = new Map();
+
+/**
+ * Get the previous assigned color for this value or if not present, assign a new one and store it
+ * @param {string} v - A text value
+ * @returns {string} The color
+ * */
+const getColor = v =>
+  assignedColors.get( v ) ?? assignedColors.set( v, COLORS[assignedColors.size % COLORS.length] ).get( v );
+
+export const options = {
+  level: 'debug',
+  transports: [ new transports.Console() ],
+  format: format.combine(
+    format.colorize(),
+    format.metadata(),
+    format.printf( ( { level, message, metadata } ) => {
+      const { namespace, ...fields } = metadata;
+      const jsonText = Object.keys( fields ).length > 0 ? formatJson( fields ) : null;
+      return `[${level}] \x1b[38;5;${getColor( namespace )}m${namespace}: ${message}\x1b[0m${jsonText ? ' ' + jsonText : ''}`;
+    } )
+  )
+};

package/src/logger/development.spec.js

@@ -0,0 +1,70 @@
+import { describe, expect, it, vi } from 'vitest';
+
+const LEVEL = Symbol.for( 'level' );
+const MESSAGE = Symbol.for( 'message' );
+
+vi.mock( '#utils', () => ( {
+  isPlainObject: v => Object.prototype.toString.call( v ) === '[object Object]',
+  shuffleArray: v => v
+} ) );
+
+const loadDevelopmentLogger = async () => {
+  vi.resetModules();
+  return import( './development.js' );
+};
+
+describe( 'logger/development', () => {
+  describe( 'formatJson', () => {
+    it( 'formats nested plain objects and arrays', async () => {
+      const { formatJson } = await loadDevelopmentLogger();
+
+      expect( formatJson( {
+        name: 'foo',
+        count: 5,
+        nested: { ok: true },
+        list: [ 1, 'two', { three: 3 } ]
+      } ) ).toBe( '{ name: "foo", count: 5, nested: { ok: true }, list: [ 1, "two", { three: 3 } ] }' );
+    } );
+
+    it( 'formats empty objects and arrays', async () => {
+      const { formatJson } = await loadDevelopmentLogger();
+
+      expect( formatJson( { emptyObject: {}, emptyArray: [] } ) ).toBe( '{ emptyObject: {}, emptyArray: [] }' );
+    } );
+
+    it( 'escapes string values', async () => {
+      const { formatJson } = await loadDevelopmentLogger();
+
+      expect( formatJson( { quote: 'hello "world"' } ) ).toBe( '{ quote: "hello \\"world\\"" }' );
+    } );
+  } );
+
+  describe( 'options.format', () => {
+    it( 'formats level, namespace, message, and metadata fields', async () => {
+      const { options } = await loadDevelopmentLogger();
+      const info = options.format.transform( {
+        [LEVEL]: 'info',
+        level: 'info',
+        message: 'Worker',
+        namespace: 'Telemetry',
+        status: { runState: 'RUNNING' },
+        memory: { heapUsed: 123 }
+      } );
+
+      expect( info[MESSAGE] ).toMatch( /^\[\x1b\[[\d;]+minfo\x1b\[[\d;]+m\] \x1b\[38;5;033mTelemetry: Worker\x1b\[0m /u );
+      expect( info[MESSAGE] ).toContain( '{ status: { runState: "RUNNING" }, memory: { heapUsed: 123 } }' );
+    } );
+
+    it( 'does not append metadata text when only namespace is present', async () => {
+      const { options } = await loadDevelopmentLogger();
+      const info = options.format.transform( {
+        [LEVEL]: 'debug',
+        level: 'debug',
+        message: 'Loading config...',
+        namespace: 'Worker'
+      } );
+
+      expect( info[MESSAGE] ).toMatch( /^\[\x1b\[[\d;]+mdebug\x1b\[[\d;]+m\] \x1b\[38;5;033mWorker: Loading config\.\.\.\x1b\[0m$/u );
+    } );
+  } );
+} );

package/src/logger/index.js

@@ -0,0 +1,14 @@
+import winston from 'winston';
+
+const { options } = await import( process.env.NODE_ENV === 'production' ? './production.js' : './development.js' );
+
+// creates the root winston logger
+const logger = winston.createLogger( options );
+
+/**
+ * Creates a child logger with a specific namespace
+ *
+ * @param {string} namespace - The namespace for this logger (e.g., 'Scanner', 'Tracing')
+ * @returns {winston.Logger} Child logger instance with namespace metadata
+ */
+export const createChildLogger = namespace => logger.child( { namespace } );

package/src/logger/index.spec.js

@@ -0,0 +1,27 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const loadLogger = async nodeEnv => {
+  vi.resetModules();
+  vi.stubEnv( 'NODE_ENV', nodeEnv );
+  return import( './index.js' );
+};
+
+describe( 'logger/index', () => {
+  afterEach( () => {
+    vi.unstubAllEnvs();
+  } );
+
+  it( 'loads the development logger options', async () => {
+    const { createChildLogger } = await loadLogger( 'development' );
+    const log = createChildLogger( 'Test' );
+
+    expect( typeof log.info ).toBe( 'function' );
+  } );
+
+  it( 'loads the production logger options', async () => {
+    const { createChildLogger } = await loadLogger( 'production' );
+    const log = createChildLogger( 'Test' );
+
+    expect( typeof log.info ).toBe( 'function' );
+  } );
+} );

package/src/logger/production.js

@@ -0,0 +1,15 @@
+import { transports, format } from 'winston';
+
+export const options = {
+  level: 'info',
+  transports: [ new transports.Console() ],
+  defaultMeta: {
+    service: 'output-worker',
+    environment: 'production'
+  },
+  format: format.combine(
+    format.timestamp( { format: 'YYYY-MM-DDTHH:mm:ss.SSSZ' } ),
+    format.errors( { stack: true } ),
+    format.json()
+  )
+};

package/src/logger/production.spec.js

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest';
+import { options } from './production.js';
+
+const LEVEL = Symbol.for( 'level' );
+const MESSAGE = Symbol.for( 'message' );
+
+describe( 'logger/production', () => {
+  it( 'uses info level and default production metadata', () => {
+    expect( options.level ).toBe( 'info' );
+    expect( options.defaultMeta ).toEqual( {
+      service: 'output-worker',
+      environment: 'production'
+    } );
+  } );
+
+  it( 'formats logs as JSON with timestamp and metadata fields', () => {
+    const info = options.format.transform( {
+      [LEVEL]: 'info',
+      level: 'info',
+      message: 'Worker',
+      namespace: 'Telemetry',
+      status: { runState: 'RUNNING' }
+    } );
+
+    const output = JSON.parse( info[MESSAGE] );
+
+    expect( output ).toMatchObject( {
+      level: 'info',
+      message: 'Worker',
+      namespace: 'Telemetry',
+      status: { runState: 'RUNNING' }
+    } );
+    expect( output.timestamp ).toEqual( expect.stringMatching( /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}[+-]\d{2}:\d{2}$/u ) );
+  } );
+
+  it( 'includes error stack when formatting Error messages', () => {
+    const error = new Error( 'boom' );
+    const info = options.format.transform( {
+      [LEVEL]: 'error',
+      level: 'error',
+      message: error
+    } );
+
+    const output = JSON.parse( info[MESSAGE] );
+
+    expect( output ).toMatchObject( {
+      level: 'error',
+      message: 'boom'
+    } );
+    expect( output.stack ).toContain( 'Error: boom' );
+  } );
+} );

package/src/tracing/internal_interface.js

@@ -32,7 +32,7 @@ export { EventAction };
  * @param {string} args.name - The human-friendly name of the Event: query, request, create.
  * @param {any} args.details - Arbitrary data to add to this event, it will be used as the "input" field.
  * @param {string} args.parentId - The parent Event, used to build a tree.
- * @param {object} args.executionContext - The original execution context from the workflow
+ * @param {object} args.traceInfo - The trace information object, propagated from the root-most workflow.
  * @returns {void}
  */
 export const addEventStart = options => addEventAction( EventAction.START, options );
@@ -45,7 +45,7 @@ export const addEventStart = options => addEventAction( EventAction.START, optio
  * @param {object} args
  * @param {string} args.id - The id of the event to conclude.
  * @param {any} args.details - Arbitrary data to add to the event; it is used as the "output" field.
- * @param {object} args.executionContext - The original execution context from the workflow
+ * @param {object} args.traceInfo - The trace information object, propagated from the root-most workflow.
  * @returns {void}
  */
 export const addEventEnd = options => addEventAction( EventAction.END, options );
@@ -58,7 +58,7 @@ export const addEventEnd = options => addEventAction( EventAction.END, options )
  * @param {object} args
  * @param {string} args.id - The id of the event to conclude.
  * @param {any} args.details - Arbitrary data to add to the event; it is used as the "error" field.
- * @param {object} args.executionContext - The original execution context from the workflow
+ * @param {object} args.traceInfo - The trace information object, propagated from the root-most workflow.
  * @returns {void}
  */
 export const addEventError = options => addEventAction( EventAction.ERROR, options );
@@ -71,7 +71,7 @@ export const addEventError = options => addEventAction( EventAction.ERROR, optio
  * @param {object} args
  * @param {string} args.id - The id of the event to attach the attribute to.
  * @param {object} args.details - The attribute to add to this event, must be in `{ name: string, value: any }` format.
- * @param {object} args.executionContext - The original execution context from the workflow
+ * @param {object} args.traceInfo - The trace information object, propagated from the root-most workflow.
  * @returns {void}
  */
 export const addEventAttribute = options => addEventAction( EventAction.ADD_ATTR, options );

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

@@ -19,10 +19,10 @@ const tempTraceFilesDir = join( __dirname, 'temp', 'traces' );
 /**
  * Builds the temp file path to accumulate trace entries
  *
- * @param {object} executionContext - The execution context around a given trace entry
+ * @param {object} traceInfo - Trace information object
  * @returns {string}
  */
-const createTempFilePath = ( { workflowId, startTime } ) => join( tempTraceFilesDir, `${startTime}_${workflowId}.trace` );
+const createTempFilePath = ( { startTime, runId } ) => join( tempTraceFilesDir, `${startTime}_${runId}.trace` );
 
 /**
  * Adds a trace entry to the accumulation file.
@@ -49,18 +49,18 @@ const cleanupOldTempFiles = ( threshold = Date.now() - tempFilesTTL ) =>
 
 /**
  * Resolves the deep folder structure that stores a workflow trace.
- * @param {string} workflowName - Name of the workflow
+ * @param {string} workflowType
  * @returns {string}
  */
-const resolveTraceFolder = workflowName => join( 'runs', workflowName );
+const resolveTraceFolder = workflowType => join( 'runs', workflowType );
 
 /**
  * Resolves the local file system path for ALL file I/O operations (read/write)
  * Uses the project root path
- * @param {string} workflowName - The name of the workflow
+ * @param {string} workflowType
  * @returns {string} The local filesystem path for file operations
  */
-const resolveIOPath = workflowName => join( callerDir, 'logs', resolveTraceFolder( workflowName ) );
+const resolveIOPath = workflowType => join( callerDir, 'logs', resolveTraceFolder( workflowType ) );
 
 /**
  * Resolves the file path to be reported as the trace destination.
@@ -71,19 +71,17 @@ const resolveIOPath = workflowName => join( callerDir, 'logs', resolveTraceFolde
  *
  * If the env variable is not present, it falls back to the same value used to write files locally.
  *
- * @param {string} workflowName - The name of the workflow
+ * @param {string} workflowType - The name of the workflow
  * @returns {string} The path to report, reflecting the actual filesystem
  */
-const resolveReportPath = workflowName => process.env.OUTPUT_TRACE_HOST_PATH ?
-  join( process.env.OUTPUT_TRACE_HOST_PATH, resolveTraceFolder( workflowName ) ) :
-  resolveIOPath( workflowName );
+const resolveReportPath = workflowType => process.env.OUTPUT_TRACE_HOST_PATH ?
+  join( process.env.OUTPUT_TRACE_HOST_PATH, resolveTraceFolder( workflowType ) ) :
+  resolveIOPath( workflowType );
 
 /**
  * Builds the actual trace filename
  *
- * @param {object} options
- * @param {number} options.startTime
- * @param {string} options.workflowId
+ * @param {object} traceInfo - The trace information object
  * @returns {string}
  */
 const buildTraceFilename = ( { startTime, workflowId } ) => {
@@ -108,15 +106,15 @@ export const init = () => {
  *
  * @param {object} args
  * @param {object} args.entry - The trace entry to append.
- * @param {object} args.executionContext - Execution info: workflowId, workflowName, startTime
+ * @param {object} args.traceInfo - Trace information object
  * @returns {void}
  */
-export const exec = async ( { entry, executionContext } ) => {
-  const { workflowId, workflowName, startTime } = executionContext;
-  const tempFilePath = createTempFilePath( executionContext );
+export const exec = async ( { entry, traceInfo } ) => {
+  const { runId, workflowType } = traceInfo;
+  const tempFilePath = createTempFilePath( traceInfo );
   addEntry( entry, tempFilePath );
 
-  const isRootWorkflowEnd = entry.id === workflowId && entry.action !== 'start';
+  const isRootWorkflowEnd = entry.id === runId && entry.action !== 'start';
   const isError = entry.action === 'error';
 
   if ( !isRootWorkflowEnd && !isError ) {
@@ -124,8 +122,8 @@ export const exec = async ( { entry, executionContext } ) => {
   }
 
   const content = buildTraceTree( getEntries( tempFilePath ) );
-  const dir = resolveIOPath( workflowName );
-  const path = join( dir, buildTraceFilename( { startTime, workflowId } ) );
+  const dir = resolveIOPath( workflowType );
+  const path = join( dir, buildTraceFilename( traceInfo ) );
 
   mkdirSync( dir, { recursive: true } );
 
@@ -140,11 +138,8 @@ export const exec = async ( { entry, executionContext } ) => {
  *
  * This uses the optional OUTPUT_TRACE_HOST_PATH to return values relative to the host OS, not the container, if applicable.
  *
- * @param {object} executionContext
- * @param {string} executionContext.startTime - The start time of the workflow
- * @param {string} executionContext.workflowId - The id of the workflow execution
- * @param {string} executionContext.workflowName - The name of the workflow
+ * @param {object} info
  * @returns {string} The absolute path where the trace will be saved
  */
-export const getDestination = ( { startTime, workflowId, workflowName } ) =>
-  join( resolveReportPath( workflowName ), buildTraceFilename( { workflowId, startTime } ) );
+export const getDestination = traceInfo =>
+  join( resolveReportPath( traceInfo.workflowType ), buildTraceFilename( traceInfo ) );

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

@@ -52,12 +52,20 @@ vi.mock( 'json-stream-stringify', async () => {
 const buildTraceTreeMock = vi.fn( entries => ( { count: entries.length } ) );
 vi.mock( '../../tools/build_trace_tree.js', () => ( { default: buildTraceTreeMock } ) );
 
-/** Flush happens when the root id matches workflowId and action is not 'start', or when action is 'error'. */
-const rootStart = ( workflowId, ts ) => ( { id: workflowId, action: 'start', timestamp: ts } );
-const rootEnd = ( workflowId, ts ) => ( { id: workflowId, action: 'end', timestamp: ts } );
+/** Flush happens when the root id matches runId and action is not 'start', or when action is 'error'. */
+const rootStart = ( runId, ts ) => ( { id: runId, action: 'start', timestamp: ts } );
+const rootEnd = ( runId, ts ) => ( { id: runId, action: 'end', timestamp: ts } );
 const childTick = ( id, ts ) => ( { id, action: 'tick', timestamp: ts } );
 
 describe( 'tracing/processors/local', () => {
+  const startTime = Date.parse( '2020-01-02T03:04:05.678Z' );
+  const traceInfo = {
+    workflowId: 'id1',
+    runId: 'run-1',
+    workflowType: 'WF',
+    startTime
+  };
+
   beforeEach( () => {
     vi.clearAllMocks();
     store.files.clear();
@@ -81,13 +89,9 @@ describe( 'tracing/processors/local', () => {
     const { exec, init } = await import( './index.js' );
     init();
 
-    const startTime = Date.parse( '2020-01-02T03:04:05.678Z' );
-    const workflowId = 'id1';
-    const ctx = { executionContext: { workflowId, workflowName: 'WF', startTime } };
-
-    await exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
-    await exec( { ...ctx, entry: childTick( 'child-1', startTime + 1 ) } );
-    await exec( { ...ctx, entry: rootEnd( workflowId, startTime + 2 ) } );
+    await exec( { traceInfo, entry: rootStart( traceInfo.runId, startTime ) } );
+    await exec( { traceInfo, entry: childTick( 'child-1', startTime + 1 ) } );
+    await exec( { traceInfo, entry: rootEnd( traceInfo.runId, startTime + 2 ) } );
 
     expect( buildTraceTreeMock ).toHaveBeenCalledTimes( 1 );
     expect( buildTraceTreeMock.mock.calls[0][0] ).toHaveLength( 3 );
@@ -103,12 +107,8 @@ describe( 'tracing/processors/local', () => {
     const { exec, init } = await import( './index.js' );
     init();
 
-    const startTime = Date.parse( '2020-01-02T03:04:05.678Z' );
-    const workflowId = 'id1';
-    const ctx = { executionContext: { workflowId, workflowName: 'WF', startTime } };
-
-    await exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
-    await exec( { ...ctx, entry: childTick( 'child-1', startTime + 1 ) } );
+    await exec( { traceInfo, entry: rootStart( traceInfo.runId, startTime ) } );
+    await exec( { traceInfo, entry: childTick( 'child-1', startTime + 1 ) } );
 
     expect( buildTraceTreeMock ).not.toHaveBeenCalled();
     expect( writeFileSyncMock ).not.toHaveBeenCalled();
@@ -120,12 +120,8 @@ describe( 'tracing/processors/local', () => {
     const { exec, init } = await import( './index.js' );
     init();
 
-    const startTime = Date.parse( '2020-01-02T03:04:05.678Z' );
-    const workflowId = 'id1';
-    const ctx = { executionContext: { workflowId, workflowName: 'WF', startTime } };
-
-    await exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
-    await exec( { ...ctx, entry: { id: 'step-1', action: 'error', timestamp: startTime + 1 } } );
+    await exec( { traceInfo, entry: rootStart( traceInfo.runId, startTime ) } );
+    await exec( { traceInfo, entry: { id: 'step-1', action: 'error', timestamp: startTime + 1 } } );
 
     expect( buildTraceTreeMock ).toHaveBeenCalledTimes( 1 );
     expect( buildTraceTreeMock.mock.calls[0][0] ).toHaveLength( 2 );
@@ -136,11 +132,11 @@ describe( 'tracing/processors/local', () => {
   it( 'getDestination(): returns absolute path under callerDir logs', async () => {
     const { getDestination } = await import( './index.js' );
 
-    const startTime = Date.parse( '2020-01-02T03:04:05.678Z' );
-    const workflowId = 'workflow-id-123';
-    const workflowName = 'test-workflow';
-
-    const destination = getDestination( { startTime, workflowId, workflowName } );
+    const destination = getDestination( {
+      ...traceInfo,
+      workflowId: 'workflow-id-123',
+      workflowType: 'test-workflow'
+    } );
 
     expect( destination ).toMatch( /^\/|^[A-Z]:\\/i );
     expect( destination ).toBe(
@@ -155,12 +151,8 @@ describe( 'tracing/processors/local', () => {
 
     init();
 
-    const startTime = Date.parse( '2020-01-02T03:04:05.678Z' );
-    const workflowId = 'id1';
-    const ctx = { executionContext: { workflowId, workflowName: 'WF', startTime } };
-
-    await exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
-    await exec( { ...ctx, entry: rootEnd( workflowId, startTime + 1 ) } );
+    await exec( { traceInfo, entry: rootStart( traceInfo.runId, startTime ) } );
+    await exec( { traceInfo, entry: rootEnd( traceInfo.runId, startTime + 1 ) } );
 
     expect( createWriteStreamMock ).toHaveBeenCalledTimes( 1 );
     const [ writtenPath ] = createWriteStreamMock.mock.calls[0];
@@ -174,11 +166,11 @@ describe( 'tracing/processors/local', () => {
 
     process.env.OUTPUT_TRACE_HOST_PATH = '/host/path/logs';
 
-    const startTime = Date.parse( '2020-01-02T03:04:05.678Z' );
-    const workflowId = 'workflow-id-123';
-    const workflowName = 'test-workflow';
-
-    const destination = getDestination( { startTime, workflowId, workflowName } );
+    const destination = getDestination( {
+      ...traceInfo,
+      workflowId: 'workflow-id-123',
+      workflowType: 'test-workflow'
+    } );
 
     expect( destination ).toBe( '/host/path/logs/runs/test-workflow/2020-01-02-03-04-05-678Z_workflow-id-123.json' );
   } );
@@ -190,15 +182,17 @@ describe( 'tracing/processors/local', () => {
 
     init();
 
-    const startTime = Date.parse( '2020-01-02T03:04:05.678Z' );
-    const workflowId = 'workflow-id-123';
-    const workflowName = 'test-workflow';
-    const ctx = { executionContext: { workflowId, workflowName, startTime } };
+    const testTraceInfo = {
+      ...traceInfo,
+      workflowId: 'workflow-id-123',
+      runId: 'run-123',
+      workflowType: 'test-workflow'
+    };
 
-    await exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
-    await exec( { ...ctx, entry: rootEnd( workflowId, startTime + 1 ) } );
+    await exec( { traceInfo: testTraceInfo, entry: rootStart( testTraceInfo.runId, startTime ) } );
+    await exec( { traceInfo: testTraceInfo, entry: rootEnd( testTraceInfo.runId, startTime + 1 ) } );
 
-    const destination = getDestination( { startTime, workflowId, workflowName } );
+    const destination = getDestination( testTraceInfo );
 
     const [ writtenPath ] = createWriteStreamMock.mock.calls[0];
     expect( writtenPath ).not.toContain( '/Users/ben/project' );