@output.ai/core 0.4.9 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.4.9",
+  "version": "0.5.1",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {

package/src/index.d.ts

@@ -95,6 +95,17 @@ export type ParallelJobResult<T> =
  ╰─────────╯
 */
 
+/**
+ * Options for a step.
+ */
+export type StepOptions = {
+
+  /**
+   * Temporal activity options for this step.
+   */
+  activityOptions?: TemporalActivityOptions
+};
+
 /**
  * The handler function of a step.
  *
@@ -205,7 +216,7 @@ export type StepFunctionWrapper<StepFunction> =
  * @param params.inputSchema - Zod schema for the `fn` input
  * @param params.outputSchema - Zod schema for the `fn` output
  * @param params.fn - A handler function containing the step code
- * @param params.options - Temporal Activity options
+ * @param params.options - Optional step options.
  * @returns The same handler function set at `fn`
  */
 export declare function step<
@@ -217,7 +228,7 @@ export declare function step<
   inputSchema?: InputSchema;
   outputSchema?: OutputSchema;
   fn: StepFunction<InputSchema, OutputSchema>;
-  options?: TemporalActivityOptions;
+  options?: StepOptions;
 } ): StepFunctionWrapper<StepFunction<InputSchema, OutputSchema>>;
 
 /*
@@ -235,7 +246,7 @@ export declare function step<
 export type WorkflowInvocationConfiguration<Context extends WorkflowContext = WorkflowContext> = {
 
   /**
-   * Native Temporal Activity options
+   * Temporal activity options for this invocation (overrides the workflow's default activity options).
    */
   options?: TemporalActivityOptions,
 
@@ -251,6 +262,22 @@ export type WorkflowInvocationConfiguration<Context extends WorkflowContext = Wo
   context?: DeepPartial<Context>
 };
 
+/**
+ * Options for a workflow.
+ */
+export type WorkflowOptions = {
+
+  /**
+   * Temporal activity options for activities invoked by this workflow.
+   */
+  activityOptions?: TemporalActivityOptions,
+
+  /**
+   * When `true`, disables trace file generation for this workflow. Only has effect when tracing is enabled.
+   */
+  disableTrace?: boolean
+};
+
 /**
  * The second argument passed to the workflow's `fn` function.
  */
@@ -467,7 +494,7 @@ export type WorkflowFunctionWrapper<WorkflowFunction> =
  * @param params.inputSchema - Zod schema for workflow input
  * @param params.outputSchema - Zod schema for workflow output
  * @param params.fn - A function containing the workflow code
- * @param params.options - Temporal Activity options
+ * @param params.options - Optional workflow options.
  * @returns The same handler function set at `fn` with a different signature
  */
 export declare function workflow<
@@ -479,7 +506,7 @@ export declare function workflow<
   inputSchema?: InputSchema;
   outputSchema?: OutputSchema;
   fn: WorkflowFunction<InputSchema, OutputSchema>;
-  options?: TemporalActivityOptions;
+  options?: WorkflowOptions;
 } ): WorkflowFunctionWrapper<WorkflowFunction<InputSchema, OutputSchema>>;
 
 /*
@@ -648,6 +675,17 @@ export class EvaluationBooleanResult extends EvaluationResult {
   constructor( args: EvaluationResultArgs<boolean> );
 }
 
+/**
+ * Options for an evaluator.
+ */
+export type EvaluatorOptions = {
+
+  /**
+   * Temporal activity options for this evaluator.
+   */
+  activityOptions?: TemporalActivityOptions
+};
+
 /**
  * The handler function of an evaluator.
  *
@@ -690,7 +728,7 @@ export type EvaluatorFunctionWrapper<EvaluatorFunction> =
  * @param params.description - Description of the evaluator
  * @param params.inputSchema - Zod schema for the `fn` input
  * @param params.fn - A function containing the evaluator code
- * @param params.options - Temporal Activity options
+ * @param params.options - Optional evaluator options.
  * @returns A wrapper function around the `fn` function
  */
 export declare function evaluator<
@@ -701,7 +739,7 @@ export declare function evaluator<
   description?: string;
   inputSchema: InputSchema;
   fn: EvaluatorFunction<InputSchema, Result>;
-  options?: TemporalActivityOptions;
+  options?: EvaluatorOptions;
 } ): EvaluatorFunctionWrapper<EvaluatorFunction<InputSchema, Result>>;
 
 /*

package/src/interface/validations/static.js

@@ -34,32 +34,42 @@ export const prioritySchema = z.object( {
   priorityKey: z.number().min( 1 ).optional()
 } );
 
-const stepAndWorkflowSchema = z.strictObject( {
+const baseSchema = z.strictObject( {
   name: z.string().regex( /^[a-z_][a-z0-9_]*$/i ),
   description: z.string().optional(),
   inputSchema: z.any().optional().superRefine( refineSchema ),
   outputSchema: z.any().optional().superRefine( refineSchema ),
   fn: z.function(),
-  options: z.strictObject( {
-    activityId: z.string().optional(),
-    cancellationType: z.enum( [ 'TRY_CANCEL', 'WAIT_CANCELLATION_COMPLETED', 'ABANDON' ] ).optional(),
-    heartbeatTimeout: durationSchema.optional(),
-    priority: prioritySchema.optional(),
-    retry: z.strictObject( {
-      initialInterval: durationSchema.optional(),
-      backoffCoefficient: z.number().gte( 1 ).optional(),
-      maximumInterval: durationSchema.optional(),
-      maximumAttempts: z.number().gte( 1 ).int().optional(),
-      nonRetryableErrorTypes: z.array( z.string() ).optional()
-    } ).optional(),
-    scheduleToCloseTimeout: durationSchema.optional(),
-    scheduleToStartTimeout: durationSchema.optional(),
-    startToCloseTimeout: durationSchema.optional(),
-    summary: z.string().optional()
+  options: z.object( {
+    activityOptions: z.strictObject( {
+      activityId: z.string().optional(),
+      cancellationType: z.enum( [ 'TRY_CANCEL', 'WAIT_CANCELLATION_COMPLETED', 'ABANDON' ] ).optional(),
+      heartbeatTimeout: durationSchema.optional(),
+      priority: prioritySchema.optional(),
+      retry: z.strictObject( {
+        initialInterval: durationSchema.optional(),
+        backoffCoefficient: z.number().gte( 1 ).optional(),
+        maximumInterval: durationSchema.optional(),
+        maximumAttempts: z.number().gte( 1 ).int().optional(),
+        nonRetryableErrorTypes: z.array( z.string() ).optional()
+      } ).optional(),
+      scheduleToCloseTimeout: durationSchema.optional(),
+      scheduleToStartTimeout: durationSchema.optional(),
+      startToCloseTimeout: durationSchema.optional(),
+      summary: z.string().optional()
+    } ).optional()
   } ).optional()
 } );
 
-const evaluatorSchema = stepAndWorkflowSchema.omit( { outputSchema: true } );
+const stepSchema = baseSchema;
+
+const workflowSchema = baseSchema.extend( {
+  options: baseSchema.shape.options.unwrap().extend( {
+    disableTrace: z.boolean().optional().default( false )
+  } ).optional()
+} );
+
+const evaluatorSchema = baseSchema.omit( { outputSchema: true } );
 
 const httpRequestSchema = z.object( {
   url: z.url( { protocol: /^https?$/ } ),
@@ -82,7 +92,7 @@ const validateAgainstSchema = ( schema, args ) => {
  * @throws {StaticValidationError} Throws if args are invalid
  */
 export function validateStep( args ) {
-  validateAgainstSchema( stepAndWorkflowSchema, args );
+  validateAgainstSchema( stepSchema, args );
 };
 
 /**
@@ -102,7 +112,7 @@ export function validateEvaluator( args ) {
  * @throws {StaticValidationError} Throws if args are invalid
  */
 export function validateWorkflow( args ) {
-  validateAgainstSchema( stepAndWorkflowSchema, args );
+  validateAgainstSchema( workflowSchema, args );
 };
 
 /**

package/src/interface/validations/static.spec.js

@@ -73,85 +73,92 @@ describe( 'interface/validator', () => {
       expect( () => validateStep( { ...validArgs, fn: 'not-fn' } ) ).toThrow( error );
     } );
 
-    it( 'passes with options.retry (second-level options)', () => {
+    it( 'passes with options.activityOptions.retry (second-level options)', () => {
       const args = {
         ...validArgs,
         options: {
-          retry: {
-            initialInterval: '1s',
-            backoffCoefficient: 2,
-            maximumInterval: '10s',
-            maximumAttempts: 3,
-            nonRetryableErrorTypes: [ 'SomeError' ]
+          activityOptions: {
+            retry: {
+              initialInterval: '1s',
+              backoffCoefficient: 2,
+              maximumInterval: '10s',
+              maximumAttempts: 3,
+              nonRetryableErrorTypes: [ 'SomeError' ]
+            }
           }
         }
       };
       expect( () => validateStep( args ) ).not.toThrow();
     } );
 
-    it( 'passes with options.activityId as string', () => {
-      expect( () => validateStep( { ...validArgs, options: { activityId: 'act-123' } } ) ).not.toThrow();
+    it( 'passes with options.activityOptions.activityId as string', () => {
+      expect( () => validateStep( { ...validArgs, options: { activityOptions: { activityId: 'act-123' } } } ) ).not.toThrow();
     } );
 
-    it( 'rejects non-string options.activityId', () => {
-      expect( () => validateStep( { ...validArgs, options: { activityId: 123 } } ) ).toThrow( StaticValidationError );
+    it( 'rejects non-string options.activityOptions.activityId', () => {
+      expect( () => validateStep( { ...validArgs, options: { activityOptions: { activityId: 123 } } } ) ).toThrow( StaticValidationError );
     } );
 
-    it( 'passes with valid options.cancellationType values', () => {
+    it( 'passes with valid options.activityOptions.cancellationType values', () => {
       for ( const v of [ 'TRY_CANCEL', 'WAIT_CANCELLATION_COMPLETED', 'ABANDON' ] ) {
-        expect( () => validateStep( { ...validArgs, options: { cancellationType: v } } ) ).not.toThrow();
+        expect( () => validateStep( { ...validArgs, options: { activityOptions: { cancellationType: v } } } ) ).not.toThrow();
       }
     } );
 
-    it( 'rejects invalid options.cancellationType', () => {
-      expect( () => validateStep( { ...validArgs, options: { cancellationType: 'INVALID' } } ) ).toThrow( StaticValidationError );
+    it( 'rejects invalid options.activityOptions.cancellationType', () => {
+      const args = { ...validArgs, options: { activityOptions: { cancellationType: 'INVALID' } } };
+      expect( () => validateStep( args ) ).toThrow( StaticValidationError );
     } );
 
-    it( 'accepts duration fields in options', () => {
+    it( 'accepts duration fields in options.activityOptions', () => {
       const options = {
-        heartbeatTimeout: '1s',
-        scheduleToCloseTimeout: '2m',
-        scheduleToStartTimeout: '3m',
-        startToCloseTimeout: '4m'
+        activityOptions: {
+          heartbeatTimeout: '1s',
+          scheduleToCloseTimeout: '2m',
+          scheduleToStartTimeout: '3m',
+          startToCloseTimeout: '4m'
+        }
       };
       expect( () => validateStep( { ...validArgs, options } ) ).not.toThrow();
     } );
 
-    it( 'rejects invalid duration string in heartbeatTimeout', () => {
-      expect( () => validateStep( { ...validArgs, options: { heartbeatTimeout: '5x' } } ) ).toThrow( StaticValidationError );
+    it( 'rejects invalid duration string in options.activityOptions.heartbeatTimeout', () => {
+      expect( () => validateStep( { ...validArgs, options: { activityOptions: { heartbeatTimeout: '5x' } } } ) ).toThrow( StaticValidationError );
     } );
 
-    it( 'passes with options.summary string', () => {
-      expect( () => validateStep( { ...validArgs, options: { summary: 'brief' } } ) ).not.toThrow();
+    it( 'passes with options.activityOptions.summary string', () => {
+      expect( () => validateStep( { ...validArgs, options: { activityOptions: { summary: 'brief' } } } ) ).not.toThrow();
     } );
 
-    it( 'rejects non-string options.summary', () => {
-      expect( () => validateStep( { ...validArgs, options: { summary: 42 } } ) ).toThrow( StaticValidationError );
+    it( 'rejects non-string options.activityOptions.summary', () => {
+      expect( () => validateStep( { ...validArgs, options: { activityOptions: { summary: 42 } } } ) ).toThrow( StaticValidationError );
     } );
 
-    it( 'passes with options.priority valid payload', () => {
+    it( 'passes with options.activityOptions.priority valid payload', () => {
       const options = {
-        priority: {
-          fairnessKey: 'user-1',
-          fairnessWeight: 1.5,
-          priorityKey: 10
+        activityOptions: {
+          priority: {
+            fairnessKey: 'user-1',
+            fairnessWeight: 1.5,
+            priorityKey: 10
+          }
         }
       };
       expect( () => validateStep( { ...validArgs, options } ) ).not.toThrow();
     } );
 
-    it( 'rejects invalid options.priority values', () => {
-      const options = { priority: { fairnessWeight: 0, priorityKey: 0 } };
+    it( 'rejects invalid options.activityOptions.priority values', () => {
+      const options = { activityOptions: { priority: { fairnessWeight: 0, priorityKey: 0 } } };
       expect( () => validateStep( { ...validArgs, options } ) ).toThrow( StaticValidationError );
     } );
 
-    it( 'rejects invalid options.retry values', () => {
-      const options = { retry: { backoffCoefficient: 0.5, maximumAttempts: 0, nonRetryableErrorTypes: [ 1 ] } };
+    it( 'rejects invalid options.activityOptions.retry values', () => {
+      const options = { activityOptions: { retry: { backoffCoefficient: 0.5, maximumAttempts: 0, nonRetryableErrorTypes: [ 1 ] } } };
       expect( () => validateStep( { ...validArgs, options } ) ).toThrow( StaticValidationError );
     } );
 
-    it( 'rejects unknown keys inside options due to strictObject', () => {
-      expect( () => validateStep( { ...validArgs, options: { unknownKey: true } } ) ).toThrow( StaticValidationError );
+    it( 'rejects unknown keys inside options.activityOptions due to strictObject', () => {
+      expect( () => validateStep( { ...validArgs, options: { activityOptions: { unknownKey: true } } } ) ).toThrow( StaticValidationError );
     } );
 
     it( 'rejects unknown top-level keys due to strictObject', () => {
@@ -163,6 +170,25 @@ describe( 'interface/validator', () => {
     it( 'passes for valid args', () => {
       expect( () => validateWorkflow( { ...validArgs } ) ).not.toThrow();
     } );
+
+    it( 'passes with options.disableTrace true', () => {
+      expect( () => validateWorkflow( { ...validArgs, options: { disableTrace: true } } ) ).not.toThrow();
+    } );
+
+    it( 'passes with options.disableTrace false', () => {
+      expect( () => validateWorkflow( { ...validArgs, options: { disableTrace: false } } ) ).not.toThrow();
+    } );
+
+    it( 'passes with options.activityOptions and options.disableTrace', () => {
+      expect( () => validateWorkflow( {
+        ...validArgs,
+        options: { activityOptions: { activityId: 'wf-1' }, disableTrace: true }
+      } ) ).not.toThrow();
+    } );
+
+    it( 'rejects non-boolean options.disableTrace', () => {
+      expect( () => validateWorkflow( { ...validArgs, options: { disableTrace: 'yes' } } ) ).toThrow( StaticValidationError );
+    } );
   } );
 
   describe( 'validateEvaluator', () => {

package/src/interface/workflow.js

@@ -3,7 +3,7 @@ import { proxyActivities, inWorkflowContext, executeChild, workflowInfo, uuid4,
 import { validateWorkflow } from './validations/static.js';
 import { validateWithSchema } from './validations/runtime.js';
 import { SHARED_STEP_PREFIX, ACTIVITY_GET_TRACE_DESTINATIONS, METADATA_ACCESS_SYMBOL } from '#consts';
-import { deepMerge, mergeActivityOptions, setMetadata, toUrlSafeBase64 } from '#utils';
+import { deepMerge, setMetadata, toUrlSafeBase64 } from '#utils';
 import { FatalError, ValidationError } from '#errors';
 
 /**
@@ -38,22 +38,25 @@ class Context {
   }
 };
 
-const defaultActivityOptions = {
-  startToCloseTimeout: '20m',
-  heartbeatTimeout: '5m',
-  retry: {
-    initialInterval: '10s',
-    backoffCoefficient: 2.0,
-    maximumInterval: '2m',
-    maximumAttempts: 3,
-    nonRetryableErrorTypes: [ ValidationError.name, FatalError.name ]
-  }
+const defaultOptions = {
+  activityOptions: {
+    startToCloseTimeout: '20m',
+    heartbeatTimeout: '5m',
+    retry: {
+      initialInterval: '10s',
+      backoffCoefficient: 2.0,
+      maximumInterval: '2m',
+      maximumAttempts: 3,
+      nonRetryableErrorTypes: [ ValidationError.name, FatalError.name ]
+    }
+  },
+  disableTrace: false
 };
 
-export function workflow( { name, description, inputSchema, outputSchema, fn, options } ) {
+export function workflow( { name, description, inputSchema, outputSchema, fn, options = {} } ) {
   validateWorkflow( { name, description, inputSchema, outputSchema, fn, options } );
 
-  const activityOptions = mergeActivityOptions( defaultActivityOptions, options );
+  const { disableTrace, activityOptions } = deepMerge( defaultOptions, options );
   const steps = proxyActivities( activityOptions );
 
   /**
@@ -68,7 +71,7 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
     if ( !inWorkflowContext() ) {
       validateWithSchema( inputSchema, input, `Workflow ${name} input` );
       const context = Context.build( { workflowId: 'test-workflow', continueAsNew: async () => {}, isContinueAsNewSuggested: () => false } );
-      const output = await fn( input, deepMerge( context, extra.context ?? {} ) );
+      const output = await fn( input, deepMerge( context, extra.context ) );
       validateWithSchema( outputSchema, output, `Workflow ${name} output` );
       return output;
     }
@@ -86,6 +89,7 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
     const executionContext = memo.executionContext ?? {
       workflowId,
       workflowName: name,
+      disableTrace,
       startTime: startTime.getTime()
     };
 
@@ -94,8 +98,8 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
       activityOptions: memo.activityOptions ?? activityOptions // Also preserve the original activity options
     } );
 
-    // Run the internal activity to retrieve the workflow trace destinations (if it is root workflow, not nested)
-    const traceDestinations = isRoot ? ( await steps[ACTIVITY_GET_TRACE_DESTINATIONS]( { startTime, workflowId, workflowName: name } ) ) : null;
+    // Run the internal activity to retrieve the workflow trace destinations (only for root workflows, not nested)
+    const traceDestinations = isRoot ? ( await steps[ACTIVITY_GET_TRACE_DESTINATIONS]( executionContext ) ) : null;
     const traceObject = { trace: { destinations: traceDestinations } };
 
     try {
@@ -127,7 +131,7 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
               executionContext,
               parentId: workflowId,
               // new configuration for activities of the child workflow, this will be omitted so it will use what that workflow have defined
-              ...( extra?.options && { activityOptions: mergeActivityOptions( activityOptions, extra.options ) } )
+              ...( extra?.options?.activityOptions && { activityOptions: deepMerge( activityOptions, extra.options.activityOptions ) } )
             }
           } )
       }, input, context );

package/src/interface/workflow.spec.js

@@ -0,0 +1,79 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { z } from 'zod';
+
+const traceDestinationsStepMock = vi.fn().mockResolvedValue( { local: '/tmp/trace' } );
+const proxyActivitiesMock = vi.fn( () => new Proxy( {}, {
+  get: ( _, prop ) => {
+    if ( prop === '__internal#getTraceDestinations' ) {
+      return traceDestinationsStepMock;
+    }
+    return vi.fn();
+  }
+} ) );
+const workflowInfoMock = vi.fn( () => ( {
+  workflowId: 'wf-test-123',
+  workflowType: 'test_wf',
+  memo: {},
+  startTime: new Date( '2025-01-01T00:00:00Z' ),
+  continueAsNewSuggested: false
+} ) );
+
+vi.mock( '@temporalio/workflow', () => ( {
+  proxyActivities: proxyActivitiesMock,
+  inWorkflowContext: () => true,
+  executeChild: vi.fn(),
+  workflowInfo: workflowInfoMock,
+  uuid4: () => 'uuid-mock',
+  ParentClosePolicy: { TERMINATE: 'TERMINATE', ABANDON: 'ABANDON' },
+  continueAsNew: vi.fn()
+} ) );
+
+vi.mock( '#consts', () => ( {
+  SHARED_STEP_PREFIX: '__shared',
+  ACTIVITY_GET_TRACE_DESTINATIONS: '__internal#getTraceDestinations',
+  METADATA_ACCESS_SYMBOL: Symbol( 'metadata' )
+} ) );
+
+describe( 'workflow()', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    workflowInfoMock.mockReturnValue( {
+      workflowId: 'wf-test-123',
+      workflowType: 'test_wf',
+      memo: {},
+      startTime: new Date( '2025-01-01T00:00:00Z' ),
+      continueAsNewSuggested: false
+    } );
+  } );
+
+  it( 'does not throw when options is omitted (disableTrace defaults to false)', async () => {
+    const { workflow } = await import( './workflow.js' );
+
+    const wf = workflow( {
+      name: 'no_options_wf',
+      description: 'Workflow without options',
+      inputSchema: z.object( { value: z.string() } ),
+      outputSchema: z.object( { value: z.string() } ),
+      fn: async ( { value } ) => ( { value } )
+    } );
+
+    const result = await wf( { value: 'hello' } );
+    expect( result.output ).toEqual( { value: 'hello' } );
+  } );
+
+  it( 'respects disableTrace: true when options is provided', async () => {
+    const { workflow } = await import( './workflow.js' );
+
+    const wf = workflow( {
+      name: 'trace_disabled_wf',
+      description: 'Workflow with tracing disabled',
+      inputSchema: z.object( { value: z.string() } ),
+      outputSchema: z.object( { value: z.string() } ),
+      options: { disableTrace: true },
+      fn: async ( { value } ) => ( { value } )
+    } );
+
+    const result = await wf( { value: 'hello' } );
+    expect( result.output ).toEqual( { value: 'hello' } );
+  } );
+} );

package/src/internal_activities/index.js

@@ -1,10 +1,9 @@
 import { FatalError } from '#errors';
 import { fetch } from 'undici';
-import { setMetadata, isStringboolTrue, serializeFetchResponse, serializeBodyAndInferContentType } from '#utils';
+import { setMetadata, serializeFetchResponse, serializeBodyAndInferContentType } from '#utils';
 import { ComponentType } from '#consts';
-import * as localProcessor from '../tracing/processors/local/index.js';
-import * as s3Processor from '../tracing/processors/s3/index.js';
 import { createChildLogger } from '#logger';
+import { getDestinations } from '#tracing';
 
 const log = createChildLogger( 'HttpClient' );
 
@@ -57,17 +56,11 @@ export const sendHttpRequest = async ( { url, method, payload = undefined, heade
 setMetadata( sendHttpRequest, { type: ComponentType.INTERNAL_STEP } );
 
 /**
- * Resolve and return all possible trace destinations based on env var flags
+ * Invokes a trace method that resolves all trace output paths based on the executionContext
  *
- * @param {Object} options
- * @param {Date} startTime - Workflow startTime
- * @param {string} workflowId
- * @param {string} workflowName
- * @returns {object} Information about enabled workflows
+ * @param {object} executionContext
+ * @returns {object} Information about enabled destinations
  */
-export const getTraceDestinations = ( { startTime, workflowId, workflowName } ) => ( {
-  local: isStringboolTrue( process.env.OUTPUT_TRACE_LOCAL_ON ) ? localProcessor.getDestination( { startTime, workflowId, workflowName } ) : null,
-  remote: isStringboolTrue( process.env.OUTPUT_TRACE_REMOTE_ON ) ? s3Processor.getDestination( { startTime, workflowId, workflowName } ) : null
-} );
+export const getTraceDestinations = executionContext => getDestinations( executionContext );
 
 setMetadata( getTraceDestinations, { type: ComponentType.INTERNAL_STEP } );

package/src/tracing/internal_interface.js

@@ -1,9 +1,9 @@
-import { addEventPhase, init } from './trace_engine.js';
+import { addEventPhase, init, getDestinations } from './trace_engine.js';
 
 /**
  * Init method, if not called, no processors are attached and trace functions are dummy
  */
-export { init };
+export { init, getDestinations };
 
 /**
  * Trace nomenclature

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

@@ -101,10 +101,10 @@ export const exec = ( { 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} args
- * @param {string} args.startTime - The start time of the workflow
- * @param {string} args.workflowId - The id of the workflow execution
- * @param {string} args.workflowName - The name of the workflow
+ * @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
  * @returns {string} The absolute path where the trace will be saved
  */
 export const getDestination = ( { startTime, workflowId, workflowName } ) =>

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

@@ -104,10 +104,10 @@ export const exec = async ( { entry, executionContext } ) => {
 
 /**
  * Returns where the trace is saved
- * @param {object} args
- * @param {string} args.startTime - The start time of the workflow
- * @param {string} args.workflowId - The id of the workflow execution
- * @param {string} args.workflowName - The name of the workflow
+ * @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
  * @returns {string} The S3 url of the trace file
  */
 export const getDestination = ( { startTime, workflowId, workflowName } ) =>

package/src/tracing/trace_engine.js

@@ -12,24 +12,41 @@ const log = createChildLogger( 'Tracing' );
 const traceBus = new EventEmitter();
 const processors = [
   {
-    isOn: isStringboolTrue( process.env.OUTPUT_TRACE_LOCAL_ON ),
+    enabled: isStringboolTrue( process.env.OUTPUT_TRACE_LOCAL_ON ),
     name: 'LOCAL',
     init: localProcessor.init,
-    exec: localProcessor.exec
+    exec: localProcessor.exec,
+    getDestination: localProcessor.getDestination
   },
   {
-    isOn: isStringboolTrue( process.env.OUTPUT_TRACE_REMOTE_ON ),
+    enabled: isStringboolTrue( process.env.OUTPUT_TRACE_REMOTE_ON ),
     name: 'REMOTE',
     init: s3Processor.init,
-    exec: s3Processor.exec
+    exec: s3Processor.exec,
+    getDestination: localProcessor.getDestination
   }
 ];
 
+/**
+ * Returns the destinations for a given execution context
+ *
+ * @param {object} executionContext
+ * @param {string} executionContext.startTime
+ * @param {string} executionContext.workflowId
+ * @param {string} executionContext.workflowName
+ * @param {boolean} executionContext.disableTrace
+ * @returns {object} A trace destinations object: { [dest-name]: 'path' }
+ */
+export const getDestinations = executionContext =>
+  processors.reduce( ( o, p ) =>
+    Object.assign( o, { [p.name.toLowerCase()]: p.enabled && !executionContext.disableTrace ? p.getDestination( executionContext ) : null } )
+  , {} );
+
 /**
  * Starts processors based on env vars and attach them to the main bus to listen trace events
  */
 export const init = async () => {
-  for ( const p of processors.filter( p => p.isOn ) ) {
+  for ( const p of processors.filter( p => p.enabled ) ) {
     await p.init();
     traceBus.addListener( 'entry', async ( ...args ) => {
       try {
@@ -54,8 +71,8 @@ const serializeDetails = details => details instanceof Error ? serializeError( d
  * @returns {void}
  */
 export const addEventPhase = ( phase, { kind, name, id, parentId, details, executionContext } ) => {
-  // Ignores internal steps in the actual trace files
-  if ( kind !== ComponentType.INTERNAL_STEP ) {
+  // Ignores internal steps in the actual trace files, ignore trace if the flag is true
+  if ( kind !== ComponentType.INTERNAL_STEP && !executionContext.disableTrace ) {
     traceBus.emit( 'entry', {
       executionContext,
       entry: { kind, phase, name, id, parentId, phase, timestamp: Date.now(), details: serializeDetails( details ) }

package/src/tracing/trace_engine.spec.js

@@ -7,16 +7,20 @@ vi.mock( '#async_storage', () => ( {
 
 const localInitMock = vi.fn( async () => {} );
 const localExecMock = vi.fn();
+const localGetDestinationMock = vi.fn( () => '/local/path.json' );
 vi.mock( './processors/local/index.js', () => ( {
   init: localInitMock,
-  exec: localExecMock
+  exec: localExecMock,
+  getDestination: localGetDestinationMock
 } ) );
 
 const s3InitMock = vi.fn( async () => {} );
 const s3ExecMock = vi.fn();
+const s3GetDestinationMock = vi.fn( () => 'https://bucket.s3.amazonaws.com/key.json' );
 vi.mock( './processors/s3/index.js', () => ( {
   init: s3InitMock,
-  exec: s3ExecMock
+  exec: s3ExecMock,
+  getDestination: s3GetDestinationMock
 } ) );
 
 async function loadTraceEngine() {
@@ -42,13 +46,17 @@ describe( 'tracing/trace_engine', () => {
     expect( localInitMock ).toHaveBeenCalledTimes( 1 );
     expect( s3InitMock ).not.toHaveBeenCalled();
 
-    addEventPhase( 'start', { kind: 'step', name: 'N', id: '1', parentId: 'p', details: { ok: true } } );
+    const executionContext = { disableTrace: false };
+    addEventPhase( 'start', {
+      kind: 'step', name: 'N', id: '1', parentId: 'p', details: { ok: true }, executionContext
+    } );
     expect( localExecMock ).toHaveBeenCalledTimes( 1 );
     const payload = localExecMock.mock.calls[0][0];
     expect( payload.entry.name ).toBe( 'N' );
     expect( payload.entry.kind ).toBe( 'step' );
     expect( payload.entry.phase ).toBe( 'start' );
     expect( payload.entry.details ).toEqual( { ok: true } );
+    expect( payload.executionContext ).toBe( executionContext );
   } );
 
   it( 'addEventPhase() emits an entry consumed by processors', async () => {
@@ -56,7 +64,10 @@ describe( 'tracing/trace_engine', () => {
     const { init, addEventPhase } = await loadTraceEngine();
     await init();
 
-    addEventPhase( 'end', { kind: 'workflow', name: 'W', id: '2', parentId: 'p2', details: 'done' } );
+    addEventPhase( 'end', {
+      kind: 'workflow', name: 'W', id: '2', parentId: 'p2', details: 'done',
+      executionContext: { disableTrace: false }
+    } );
     expect( localExecMock ).toHaveBeenCalledTimes( 1 );
     const payload = localExecMock.mock.calls[0][0];
     expect( payload.entry.name ).toBe( 'W' );
@@ -64,21 +75,49 @@ describe( 'tracing/trace_engine', () => {
     expect( payload.entry.details ).toBe( 'done' );
   } );
 
+  it( 'addEventPhase() does not emit when executionContext.disableTrace is true', async () => {
+    process.env.OUTPUT_TRACE_LOCAL_ON = '1';
+    const { init, addEventPhase } = await loadTraceEngine();
+    await init();
+
+    addEventPhase( 'start', {
+      kind: 'step', name: 'X', id: '1', parentId: 'p', details: {},
+      executionContext: { disableTrace: true }
+    } );
+    expect( localExecMock ).not.toHaveBeenCalled();
+  } );
+
   it( 'addEventPhaseWithContext() uses storage when available', async () => {
     process.env.OUTPUT_TRACE_LOCAL_ON = 'true';
-    storageLoadMock.mockReturnValue( { parentId: 'ctx-p', executionContext: { runId: 'r1' } } );
+    storageLoadMock.mockReturnValue( {
+      parentId: 'ctx-p',
+      executionContext: { runId: 'r1', disableTrace: false }
+    } );
     const { init, addEventPhaseWithContext } = await loadTraceEngine();
     await init();
 
     addEventPhaseWithContext( 'tick', { kind: 'step', name: 'S', id: '3', details: 1 } );
     expect( localExecMock ).toHaveBeenCalledTimes( 1 );
     const payload = localExecMock.mock.calls[0][0];
-    expect( payload.executionContext ).toEqual( { runId: 'r1' } );
+    expect( payload.executionContext ).toEqual( { runId: 'r1', disableTrace: false } );
     expect( payload.entry.parentId ).toBe( 'ctx-p' );
     expect( payload.entry.name ).toBe( 'S' );
     expect( payload.entry.phase ).toBe( 'tick' );
   } );
 
+  it( 'addEventPhaseWithContext() does not emit when storage executionContext.disableTrace is true', async () => {
+    process.env.OUTPUT_TRACE_LOCAL_ON = '1';
+    storageLoadMock.mockReturnValue( {
+      parentId: 'ctx-p',
+      executionContext: { runId: 'r1', disableTrace: true }
+    } );
+    const { init, addEventPhaseWithContext } = await loadTraceEngine();
+    await init();
+
+    addEventPhaseWithContext( 'tick', { kind: 'step', name: 'S', id: '3', details: 1 } );
+    expect( localExecMock ).not.toHaveBeenCalled();
+  } );
+
   it( 'addEventPhaseWithContext() is a no-op when storage is absent', async () => {
     process.env.OUTPUT_TRACE_LOCAL_ON = '1';
     storageLoadMock.mockReturnValue( undefined );
@@ -88,4 +127,24 @@ describe( 'tracing/trace_engine', () => {
     addEventPhaseWithContext( 'noop', { kind: 'step', name: 'X', id: '4', details: null } );
     expect( localExecMock ).not.toHaveBeenCalled();
   } );
+
+  it( 'getDestinations() returns null for each value when executionContext.disableTrace is true', async () => {
+    process.env.OUTPUT_TRACE_LOCAL_ON = '1';
+    process.env.OUTPUT_TRACE_REMOTE_ON = '1';
+    const { getDestinations } = await loadTraceEngine();
+    const result = getDestinations( { workflowId: 'w1', workflowName: 'WF', startTime: 1, disableTrace: true } );
+    expect( result ).toEqual( { local: null, remote: null } );
+    expect( localGetDestinationMock ).not.toHaveBeenCalled();
+    expect( s3GetDestinationMock ).not.toHaveBeenCalled();
+  } );
+
+  it( 'getDestinations() returns processor destinations when disableTrace is false', async () => {
+    process.env.OUTPUT_TRACE_LOCAL_ON = '1';
+    process.env.OUTPUT_TRACE_REMOTE_ON = '0';
+    const { getDestinations } = await loadTraceEngine();
+    const executionContext = { workflowId: 'w1', workflowName: 'WF', startTime: 1, disableTrace: false };
+    const result = getDestinations( executionContext );
+    expect( result ).toEqual( { local: '/local/path.json', remote: null } );
+    expect( localGetDestinationMock ).toHaveBeenCalledWith( executionContext );
+  } );
 } );

package/src/utils/index.d.ts

@@ -33,14 +33,6 @@ export function throws( error: Error ): void;
  */
 export function setMetadata( target: object, value: object ): void;
 
-/**
- * Merge two temporal activity options
- */
-export function mergeActivityOptions(
-  base?: import( '@temporalio/workflow' ).ActivityOptions,
-  ext?: import( '@temporalio/workflow' ).ActivityOptions
-): import( '@temporalio/workflow' ).ActivityOptions;
-
 /** Represents a {Response} serialized to plain object  */
 export type SerializedFetchResponse = {
   /** The response url */

package/src/utils/utils.js

@@ -37,17 +37,6 @@ export const throws = e => {
 export const setMetadata = ( target, values ) =>
   Object.defineProperty( target, METADATA_ACCESS_SYMBOL, { value: values, writable: false, enumerable: false, configurable: false } );
 
-/**
- * Merge two temporal activity options
- * @param {import('@temporalio/workflow').ActivityOptions} base
- * @param {import('@temporalio/workflow').ActivityOptions} ext
- * @returns {import('@temporalio/workflow').ActivityOptions}
- */
-export const mergeActivityOptions = ( base = {}, ext = {} ) =>
-  Object.entries( ext ).reduce( ( options, [ k, v ] ) =>
-    Object.assign( options, { [k]: typeof v === 'object' ? mergeActivityOptions( options[k], v ) : v } )
-  , clone( base ) );
-
 /**
  * Returns true if string value is stringbool and true
  * @param {string} v
@@ -179,6 +168,7 @@ export const shuffleArray = arr => arr
  * - Object "b" fields that don't exist on object "a" will be created;
  * - Object "a" fields that don't exist on object "b" will not be touched;
  *
+ * If "b" isn't an object, a new object equal to "a" is returned
  *
  * @param {object} a - The base object
  * @param {object} b - The target object
@@ -189,7 +179,7 @@ export const deepMerge = ( a, b ) => {
     throw new Error( 'Parameter "a" is not an object.' );
   }
   if ( !isPlainObject( b ) ) {
-    throw new Error( 'Parameter "b" is not an object.' );
+    return clone( a );
   }
   return Object.entries( b ).reduce( ( obj, [ k, v ] ) =>
     Object.assign( obj, { [k]: isPlainObject( v ) && isPlainObject( a[k] ) ? deepMerge( a[k], v ) : v } )

package/src/utils/utils.spec.js

@@ -2,7 +2,6 @@ import { describe, it, expect } from 'vitest';
 import { Readable } from 'node:stream';
 import {
   clone,
-  mergeActivityOptions,
   serializeBodyAndInferContentType,
   serializeFetchResponse,
   deepMerge,
@@ -223,50 +222,6 @@ describe( 'serializeBodyAndInferContentType', () => {
   } );
 } );
 
-describe( 'mergeActivityOptions', () => {
-  it( 'recursively merges nested objects', () => {
-    const base = {
-      taskQueue: 'q1',
-      retry: { maximumAttempts: 3, backoffCoefficient: 2 }
-    };
-    const ext = {
-      retry: { maximumAttempts: 5, initialInterval: '1s' }
-    };
-
-    const result = mergeActivityOptions( base, ext );
-
-    expect( result ).toEqual( {
-      taskQueue: 'q1',
-      retry: { maximumAttempts: 5, backoffCoefficient: 2, initialInterval: '1s' }
-    } );
-  } );
-
-  it( 'omitted properties in second do not overwrite first', () => {
-    const base = {
-      taskQueue: 'q2',
-      retry: { initialInterval: '2s', backoffCoefficient: 2 }
-    };
-    const ext = {
-      retry: { backoffCoefficient: 3 }
-    };
-
-    const result = mergeActivityOptions( base, ext );
-
-    expect( result.retry.initialInterval ).toBe( '2s' );
-    expect( result.retry.backoffCoefficient ).toBe( 3 );
-    expect( result.taskQueue ).toBe( 'q2' );
-  } );
-
-  it( 'handles omitted second argument by returning a clone', () => {
-    const base = { taskQueue: 'q3', retry: { maximumAttempts: 2 } };
-
-    const result = mergeActivityOptions( base );
-
-    expect( result ).toEqual( base );
-    expect( result ).not.toBe( base );
-  } );
-} );
-
 describe( 'deepMerge', () => {
   it( 'Overwrites properties in object "a"', () => {
     const a = {
@@ -316,13 +271,43 @@ describe( 'deepMerge', () => {
     } );
   } );
 
-  it( 'Throw error on non iterable object types', () => {
-    expect( () => deepMerge( Function, Function ) ).toThrow( Error );
-    expect( () => deepMerge( () => {}, () => {} ) ).toThrow( Error );
-    expect( () => deepMerge( 'a', 'a' ) ).toThrow( Error );
-    expect( () => deepMerge( true, true ) ).toThrow( Error );
-    expect( () => deepMerge( /a/, /a/ ) ).toThrow( Error );
-    expect( () => deepMerge( [], [] ) ).toThrow( Error );
+  it( 'Merge object is a clone', () => {
+    const a = {
+      a: 1
+    };
+    const b = {
+      b: 1
+    };
+    const result = deepMerge( a, b );
+    a.a = 2;
+    b.b = 2;
+    expect( result.a ).toEqual( 1 );
+  } );
+
+  it( 'Returns copy of "a" if "b" is not an object', () => {
+    const a = {
+      a: 1
+    };
+    expect( deepMerge( a, null ) ).toEqual( { a: 1 } );
+    expect( deepMerge( a, undefined ) ).toEqual( { a: 1 } );
+  } );
+
+  it( 'Copy of object "a" is a clone', () => {
+    const a = {
+      a: 1
+    };
+    const result = deepMerge( a, null );
+    a.a = 2;
+    expect( result.a ).toEqual( 1 );
+  } );
+
+  it( 'Throws when first argument is not a plain object', () => {
+    expect( () => deepMerge( Function ) ).toThrow( Error );
+    expect( () => deepMerge( () => {} ) ).toThrow( Error );
+    expect( () => deepMerge( 'a' ) ).toThrow( Error );
+    expect( () => deepMerge( true ) ).toThrow( Error );
+    expect( () => deepMerge( /a/ ) ).toThrow( Error );
+    expect( () => deepMerge( [] ) ).toThrow( Error );
     expect( () => deepMerge( class Foo {}, class Foo {} ) ).toThrow( Error );
     expect( () => deepMerge( Number.constructor, Number.constructor ) ).toThrow( Error );
     expect( () => deepMerge( Number.constructor.prototype, Number.constructor.prototype ) ).toThrow( Error );
@@ -377,6 +362,8 @@ describe( 'isPlainObject', () => {
   } );
 
   it( 'Returns false for primitives', () => {
+    expect( isPlainObject( null ) ).toBe( false );
+    expect( isPlainObject( undefined ) ).toBe( false );
     expect( isPlainObject( false ) ).toBe( false );
     expect( isPlainObject( true ) ).toBe( false );
     expect( isPlainObject( 1 ) ).toBe( false );

package/src/worker/interceptors/workflow.js

@@ -1,7 +1,7 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
 import { workflowInfo, proxySinks, ApplicationFailure, ContinueAsNew } from '@temporalio/workflow';
 import { memoToHeaders } from '../sandboxed_utils.js';
-import { mergeActivityOptions } from '#utils';
+import { deepMerge } from '#utils';
 import { METADATA_ACCESS_SYMBOL } from '#consts';
 // this is a dynamic generated file with activity configs overwrites
 import stepOptions from '../temp/__activity_options.js';
@@ -22,7 +22,7 @@ class HeadersInjectionInterceptor {
     // apply per-invocation options passed as second argument by rewritten calls
     const options = stepOptions[input.activityType];
     if ( options ) {
-      input.options = mergeActivityOptions( memo.activityOptions, options );
+      input.options = deepMerge( memo.activityOptions, options );
     }
     return next( input );
   }

package/src/worker/loader.js

@@ -72,7 +72,7 @@ export async function loadActivities( rootDir, workflows ) {
       const activityKey = generateActivityKey( { namespace: workflowName, activityName: metadata.name } );
       activities[activityKey] = fn;
       // propagate the custom options set on the step()/evaluator() constructor
-      activityOptionsMap[activityKey] = metadata.options ?? undefined;
+      activityOptionsMap[activityKey] = metadata.options?.activityOptions ?? undefined;
     }
   }
 
@@ -82,7 +82,7 @@ export async function loadActivities( rootDir, workflows ) {
     // The namespace for shared activities is fixed
     const activityKey = generateActivityKey( { namespace: SHARED_STEP_PREFIX, activityName: metadata.name } );
     activities[activityKey] = fn;
-    activityOptionsMap[activityKey] = metadata.options ?? undefined;
+    activityOptionsMap[activityKey] = metadata.options?.activityOptions ?? undefined;
   }
 
   // writes down the activity option overrides

package/src/worker/loader.spec.js

@@ -37,9 +37,13 @@ describe( 'worker/loader', () => {
   it( 'loadActivities returns map including system activity and writes options file', async () => {
     const { loadActivities } = await import( './loader.js' );
 
-    // First call: workflow directory scan
+    // First call: workflow directory scan (options.activityOptions propagated to activity options file)
     importComponentsMock.mockImplementationOnce( async function *() {
-      yield { fn: () => {}, metadata: { name: 'Act1', options: { retry: { maximumAttempts: 3 } } }, path: '/a/steps.js' };
+      yield {
+        fn: () => {},
+        metadata: { name: 'Act1', options: { activityOptions: { retry: { maximumAttempts: 3 } } } },
+        path: '/a/steps.js'
+      };
     } );
     // Second call: shared activities scan (no results)
     importComponentsMock.mockImplementationOnce( async function *() {} );
@@ -49,7 +53,7 @@ describe( 'worker/loader', () => {
     expect( activities['A#Act1'] ).toBeTypeOf( 'function' );
     expect( activities['__internal#sendHttpRequest'] ).toBe( sendHttpRequestMock );
 
-    // options file written with the collected map
+    // options file written with the collected activityOptions map
     expect( writeFileSyncMock ).toHaveBeenCalledTimes( 1 );
     const [ writtenPath, contents ] = writeFileSyncMock.mock.calls[0];
     expect( writtenPath ).toMatch( /temp\/__activity_options\.js$/ );
@@ -60,6 +64,22 @@ describe( 'worker/loader', () => {
     expect( mkdirSyncMock ).toHaveBeenCalled();
   } );
 
+  it( 'loadActivities omits activity options when component has no options or no activityOptions', async () => {
+    const { loadActivities } = await import( './loader.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { fn: () => {}, metadata: { name: 'NoOptions' }, path: '/a/steps.js' };
+      yield { fn: () => {}, metadata: { name: 'EmptyOptions', options: {} }, path: '/a/steps2.js' };
+    } );
+    importComponentsMock.mockImplementationOnce( async function *() {} );
+
+    await loadActivities( '/root', [ { name: 'A', path: '/a/workflow.js' } ] );
+    const written = JSON.parse(
+      writeFileSyncMock.mock.calls[0][1].replace( /^export default\s*/, '' ).replace( /;\s*$/, '' )
+    );
+    expect( written['A#NoOptions'] ).toBeUndefined();
+    expect( written['A#EmptyOptions'] ).toBeUndefined();
+  } );
+
   it( 'loadWorkflows returns array of workflows with metadata', async () => {
     const { loadWorkflows } = await import( './loader.js' );