@output.ai/core 0.5.3 → 0.5.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {
@@ -40,7 +40,7 @@
     "stacktrace-parser": "0.1.11",
     "undici": "7.18.2",
     "winston": "3.17.0",
-    "zod": "4.1.12"
+    "zod": "^4.3.6"
   },
   "license": "Apache-2.0",
   "publishConfig": {

package/src/consts.js

@@ -15,8 +15,3 @@ export const LifecycleEvent = {
   END: 'end',
   ERROR: 'error'
 };
-export const LifecycleEventLogMessage = {
-  [LifecycleEvent.START]: 'Start',
-  [LifecycleEvent.END]: 'End',
-  [LifecycleEvent.ERROR]: 'Error'
-};

package/src/tracing/trace_engine.js

@@ -23,7 +23,7 @@ const processors = [
     name: 'REMOTE',
     init: s3Processor.init,
     exec: s3Processor.exec,
-    getDestination: localProcessor.getDestination
+    getDestination: s3Processor.getDestination
   }
 ];
 

package/src/tracing/trace_engine.spec.js

@@ -87,6 +87,18 @@ describe( 'tracing/trace_engine', () => {
     expect( localExecMock ).not.toHaveBeenCalled();
   } );
 
+  it( 'addEventPhase() does not emit when kind is INTERNAL_STEP', async () => {
+    process.env.OUTPUT_TRACE_LOCAL_ON = '1';
+    const { init, addEventPhase } = await loadTraceEngine();
+    await init();
+
+    addEventPhase( 'start', {
+      kind: 'internal_step', name: 'Internal', id: '1', parentId: 'p', details: {},
+      executionContext: { disableTrace: false }
+    } );
+    expect( localExecMock ).not.toHaveBeenCalled();
+  } );
+
   it( 'addEventPhaseWithContext() uses storage when available', async () => {
     process.env.OUTPUT_TRACE_LOCAL_ON = 'true';
     storageLoadMock.mockReturnValue( {
@@ -128,23 +140,60 @@ describe( 'tracing/trace_engine', () => {
     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();
+  describe( 'getDestinations()', () => {
     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 );
+
+    it( 'returns null for both when traces are off (env vars unset)', async () => {
+      const { getDestinations } = await loadTraceEngine();
+      const result = getDestinations( executionContext );
+      expect( result ).toEqual( { local: null, remote: null } );
+      expect( localGetDestinationMock ).not.toHaveBeenCalled();
+      expect( s3GetDestinationMock ).not.toHaveBeenCalled();
+    } );
+
+    it( 'returns null for both 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( { ...executionContext, disableTrace: true } );
+      expect( result ).toEqual( { local: null, remote: null } );
+      expect( localGetDestinationMock ).not.toHaveBeenCalled();
+      expect( s3GetDestinationMock ).not.toHaveBeenCalled();
+    } );
+
+    it( 'returns both destinations when both traces are on', async () => {
+      process.env.OUTPUT_TRACE_LOCAL_ON = '1';
+      process.env.OUTPUT_TRACE_REMOTE_ON = 'true';
+      const { getDestinations } = await loadTraceEngine();
+      const result = getDestinations( executionContext );
+      expect( result ).toEqual( {
+        local: '/local/path.json',
+        remote: 'https://bucket.s3.amazonaws.com/key.json'
+      } );
+      expect( localGetDestinationMock ).toHaveBeenCalledTimes( 1 );
+      expect( localGetDestinationMock ).toHaveBeenCalledWith( executionContext );
+      expect( s3GetDestinationMock ).toHaveBeenCalledTimes( 1 );
+      expect( s3GetDestinationMock ).toHaveBeenCalledWith( executionContext );
+    } );
+
+    it( 'returns local only when local trace on and remote off', async () => {
+      process.env.OUTPUT_TRACE_LOCAL_ON = '1';
+      process.env.OUTPUT_TRACE_REMOTE_ON = '0';
+      const { getDestinations } = await loadTraceEngine();
+      const result = getDestinations( executionContext );
+      expect( result ).toEqual( { local: '/local/path.json', remote: null } );
+      expect( localGetDestinationMock ).toHaveBeenCalledWith( executionContext );
+      expect( s3GetDestinationMock ).not.toHaveBeenCalled();
+    } );
+
+    it( 'returns remote only when local trace off and remote on', async () => {
+      process.env.OUTPUT_TRACE_LOCAL_ON = '0';
+      process.env.OUTPUT_TRACE_REMOTE_ON = 'true';
+      const { getDestinations } = await loadTraceEngine();
+      const result = getDestinations( executionContext );
+      expect( result ).toEqual( { local: null, remote: 'https://bucket.s3.amazonaws.com/key.json' } );
+      expect( localGetDestinationMock ).not.toHaveBeenCalled();
+      expect( s3GetDestinationMock ).toHaveBeenCalledWith( executionContext );
+    } );
   } );
 } );

package/src/worker/interceptors/activity.js

@@ -2,7 +2,7 @@ import { Context } from '@temporalio/activity';
 import { Storage } from '#async_storage';
 import { addEventStart, addEventEnd, addEventError } from '#tracing';
 import { headersToObject } from '../sandboxed_utils.js';
-import { LifecycleEventLogMessage, LifecycleEvent, METADATA_ACCESS_SYMBOL } from '#consts';
+import { LifecycleEvent, METADATA_ACCESS_SYMBOL } from '#consts';
 import { activityHeartbeatEnabled, activityHeartbeatIntervalMs } from '../configs.js';
 import { createChildLogger } from '#logger';
 
@@ -37,7 +37,7 @@ export class ActivityExecutionInterceptor {
     const logContext = { workflowName, workflowId, stepId: activityId, stepName: activityType };
     const traceArguments = { kind, id: activityId, parentId: workflowId, name: activityType, executionContext };
 
-    log.info( LifecycleEventLogMessage[LifecycleEvent.START], logContext );
+    log.info( `Started ${activityType} ${kind}`, { event: LifecycleEvent.START, kind, ...logContext } );
     addEventStart( { details: input.args[0], ...traceArguments } );
 
     const intervals = { heartbeat: null };
@@ -47,12 +47,14 @@ export class ActivityExecutionInterceptor {
 
       const output = await Storage.runWithContext( async _ => next( input ), { parentId: activityId, executionContext } );
 
-      log.info( LifecycleEventLogMessage[LifecycleEvent.END], { ...logContext, durationMs: Date.now() - startDate } );
+      log.info( `Ended ${activityType} ${kind}`, { event: LifecycleEvent.END, kind, ...logContext, durationMs: Date.now() - startDate } );
       addEventEnd( { details: output, ...traceArguments } );
       return output;
 
     } catch ( error ) {
-      log.error( LifecycleEventLogMessage[LifecycleEvent.ERROR], { ...logContext, durationMs: Date.now() - startDate, error: error.message } );
+      log.error( `Error ${activityType} ${kind}: ${error.message}`, {
+        event: LifecycleEvent.ERROR, kind, ...logContext, durationMs: Date.now() - startDate, error: error.message
+      } );
       addEventError( { details: error, ...traceArguments } );
       throw error;
 

package/src/worker/sinks.js

@@ -1,4 +1,4 @@
-import { LifecycleEvent, LifecycleEventLogMessage, WORKFLOW_CATALOG } from '#consts';
+import { LifecycleEvent, WORKFLOW_CATALOG } from '#consts';
 import { addEventStart, addEventEnd, addEventError } from '#tracing';
 import { createChildLogger } from '#logger';
 
@@ -34,11 +34,12 @@ const logWorkflowEvent = ( event, workflowInfo, error ) => {
   }
 
   if ( event === LifecycleEvent.START ) {
-    log.info( LifecycleEventLogMessage[event], { workflowName, workflowId } );
+    log.info( `Started ${workflowName} workflow`, { event, workflowName, workflowId } );
   } else if ( event === LifecycleEvent.END ) {
-    log.info( LifecycleEventLogMessage[event], { workflowName, workflowId, durationMs: Date.now() - startTime.getTime() } );
+    log.info( `Ended ${workflowName} workflow`, { event, workflowName, workflowId, durationMs: Date.now() - startTime.getTime() } );
   } else if ( event === LifecycleEvent.ERROR ) {
-    log.info( LifecycleEventLogMessage[event], {
+    log.error( `Error ${workflowName} workflow: ${error.message}`, {
+      event,
       workflowName,
       workflowId,
       durationMs: Date.now() - startTime.getTime(),