@outputai/core 0.6.0 → 0.6.1-next.383b24b.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/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' );

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

@@ -7,7 +7,7 @@ import { JsonStreamStringify } from 'json-stream-stringify';
 
 const log = createChildLogger( 'S3 Processor' );
 
-const createRedisKey = ( { workflowId, workflowName } ) => `traces/${workflowName}/${workflowId}`;
+const createRedisKey = runId => `traces/${runId}`;
 
 /**
  * Add new entry to list of entries
@@ -44,17 +44,14 @@ const bustEntries = async key => {
 
 /**
  * Return the S3 key for the trace file
- * @param {object} args
- * @param {number} args.startTime
- * @param {string} args.workflowId
- * @param {string} args.workflowName
+ * @param {object} traceInfo
  * @returns
  */
-const getS3Key = ( { startTime, workflowId, workflowName } ) => {
+const getS3Key = ( { startTime, workflowId, workflowType } ) => {
   const isoDate = new Date( startTime ).toISOString();
   const [ year, month, day ] = isoDate.split( /\D/, 3 );
   const timeStamp = isoDate.replace( /[:T.]/g, '-' );
-  return `${workflowName}/${year}/${month}/${day}/${timeStamp}_${workflowId}.json`;
+  return `${workflowType}/${year}/${month}/${day}/${timeStamp}_${workflowId}.json`;
 };
 
 /**
@@ -70,19 +67,19 @@ export const init = async () => {
  *
  * Appends each trace entry to Redis.
  *
- * When the root workflow ends or the entry is an error action, it builds the trace tree and uploads it to S3.
+ * When the root workflow finishes or errors, builds the trace tree and uploads it to S3.
  *
  * @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
  */
-export const exec = async ( { entry, executionContext } ) => {
-  const { workflowName, workflowId, startTime } = executionContext;
-  const cacheKey = createRedisKey( { workflowId, workflowName } );
+export const exec = async ( { entry, traceInfo } ) => {
+  const { workflowId, runId } = traceInfo;
+  const cacheKey = createRedisKey( runId );
 
   await addEntry( entry, cacheKey );
 
-  const isRootWorkflowEnd = entry.id === workflowId && entry.action !== 'start';
+  const isRootWorkflowEnd = entry.id === runId && entry.action !== 'start';
   if ( !isRootWorkflowEnd ) {
     return;
   }
@@ -100,20 +97,13 @@ export const exec = async ( { entry, executionContext } ) => {
     return;
   }
 
-  await upload( {
-    key: getS3Key( { workflowId, workflowName, startTime } ),
-    content: new JsonStreamStringify( content )
-  } );
+  await upload( { key: getS3Key( traceInfo ), content: new JsonStreamStringify( content ) } );
   await bustEntries( cacheKey );
 };
 
 /**
  * Returns where the trace is saved
- * @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} traceInfo - Trace information object
  * @returns {string} The S3 url of the trace file
  */
-export const getDestination = ( { startTime, workflowId, workflowName } ) =>
-  `https://${getVars().remoteS3Bucket}.s3.amazonaws.com/${getS3Key( { workflowId, workflowName, startTime } )}`;
+export const getDestination = traceInfo => `https://${getVars().remoteS3Bucket}.s3.amazonaws.com/${getS3Key( traceInfo )}`;

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

@@ -53,6 +53,14 @@ const streamToString = async stream => {
 };
 
 describe( 'tracing/processors/s3', () => {
+  const startTime = Date.parse( '2020-01-02T03:04:05.678Z' );
+  const traceInfo = {
+    workflowId: 'id1',
+    runId: 'run-1',
+    workflowType: 'WF',
+    startTime
+  };
+
   beforeEach( () => {
     vi.useFakeTimers();
     vi.clearAllMocks();
@@ -72,24 +80,30 @@ describe( 'tracing/processors/s3', () => {
 
   it( 'exec(): accumulates via redis, uploads only on root workflow end', 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', action: 'start', details: {}, timestamp: startTime };
-    const activityStart = { id: 'act-1', name: 'DoSomething', kind: 'step', parentId: 'id1', action: 'start', details: {}, timestamp: startTime + 1 };
-    const workflowEnd = { id: 'id1', action: 'end', details: { ok: true }, timestamp: startTime + 2 };
+    const workflowStart = { id: 'run-1', name: 'WF', kind: 'workflow', action: 'start', details: {}, timestamp: startTime };
+    const activityStart = {
+      id: 'act-1',
+      name: 'DoSomething',
+      kind: 'step',
+      parentId: 'run-1',
+      action: 'start',
+      details: {},
+      timestamp: startTime + 1
+    };
+    const workflowEnd = { id: 'run-1', action: 'end', details: { ok: true }, timestamp: startTime + 2 };
     zRangeMock.mockResolvedValue( [
       JSON.stringify( workflowStart ),
       JSON.stringify( activityStart ),
       JSON.stringify( workflowEnd )
     ] );
 
-    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 exec( { traceInfo, entry: workflowStart } );
+    await exec( { traceInfo, entry: activityStart } );
+    // Root end: id matches runId and not start — triggers the 10s delay before upload
+    const endPromise = exec( { traceInfo, entry: workflowEnd } );
     await vi.advanceTimersByTimeAsync( 10_000 );
     await endPromise;
 
@@ -101,14 +115,13 @@ describe( 'tracing/processors/s3', () => {
     expect( key ).toMatch( /^WF\/2020\/01\/02\// );
     expect( JSON.parse( await streamToString( content ) ).count ).toBe( 3 );
     expect( delMock ).toHaveBeenCalledTimes( 1 );
-    expect( delMock ).toHaveBeenCalledWith( 'traces/WF/id1' );
+    expect( delMock ).toHaveBeenCalledWith( 'traces/run-1' );
   } );
 
   it( 'getDestination(): returns S3 URL using bucket and key from getVars', async () => {
     getVarsMock.mockReturnValue( { remoteS3Bucket: 'my-bucket', redisIncompleteWorkflowsTTL: 3600, traceUploadDelayMs: 10_000 } );
     const { getDestination } = await import( './index.js' );
-    const startTime = Date.parse( '2020-01-02T03:04:05.678Z' );
-    const url = getDestination( { workflowId: 'id1', workflowName: 'WF', startTime } );
+    const url = getDestination( traceInfo );
     expect( getVarsMock ).toHaveBeenCalled();
     expect( url ).toBe(
       'https://my-bucket.s3.amazonaws.com/WF/2020/01/02/2020-01-02-03-04-05-678Z_id1.json'
@@ -117,36 +130,32 @@ describe( 'tracing/processors/s3', () => {
 
   it( 'exec(): sets expiry on the redis key for each entry', 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 = {
-      kind: 'workflow', id: 'id1', name: 'WF', parentId: undefined, action: 'start', details: {}, timestamp: startTime
+      kind: 'workflow', id: 'run-1', name: 'WF', parentId: undefined, action: 'start', details: {}, timestamp: startTime
     };
     zRangeMock.mockResolvedValue( [ JSON.stringify( workflowStart ) ] );
 
-    await exec( { ...ctx, entry: workflowStart } );
+    await exec( { traceInfo, entry: workflowStart } );
 
     expect( redisMulti.expire ).toHaveBeenCalledTimes( 1 );
-    expect( redisMulti.expire ).toHaveBeenCalledWith( 'traces/WF/id1', 3600 );
+    expect( redisMulti.expire ).toHaveBeenCalledWith( 'traces/run-1', 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', action: 'start', details: {}, timestamp: startTime };
+    const workflowStart = { id: 'run-1', name: 'WF', kind: 'workflow', action: 'start', details: {}, timestamp: startTime };
     const stepEndNoParent = { id: 'step-1', action: '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 } );
+    await exec( { traceInfo, entry: workflowStart } );
+    await exec( { traceInfo, entry: stepEndNoParent } );
 
     expect( redisMulti.zAdd ).toHaveBeenCalledTimes( 2 );
     expect( buildTraceTreeMock ).not.toHaveBeenCalled();
@@ -156,17 +165,15 @@ describe( 'tracing/processors/s3', () => {
 
   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( [] );
     const workflowEnd = {
-      kind: 'workflow', id: 'id1', name: 'WF', parentId: undefined, action: 'end', details: {}, timestamp: startTime
+      kind: 'workflow', id: 'run-1', name: 'WF', parentId: undefined, action: 'end', details: {}, timestamp: startTime
     };
     zRangeMock.mockResolvedValue( [ JSON.stringify( workflowEnd ) ] );
     buildTraceTreeMock.mockReturnValueOnce( null );
 
-    const endPromise = exec( { ...ctx, entry: workflowEnd } );
+    const endPromise = exec( { traceInfo, entry: workflowEnd } );
     await vi.advanceTimersByTimeAsync( 10_000 );
     await endPromise;
 

package/src/tracing/trace_attribute.js

@@ -4,7 +4,6 @@ import Decimal from 'decimal.js';
  * All attributes inherit from this
  */
 export class BaseAttribute {
-  date = Date.now();
   type;
 
   constructor( type ) {