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

package/src/worker/log_hooks.spec.js

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import {
+  ACTIVITY_GET_TRACE_DESTINATIONS,
   BusEventType,
-  ComponentType,
   LifecycleEvent,
   WORKFLOW_CATALOG
 } from '#consts';
@@ -30,12 +30,15 @@ describe( 'log_hooks', () => {
   } );
 
   describe( 'activity events', () => {
+    const activityInfo = {
+      activityId: 'act-1',
+      activityType: 'myWorkflow#myStep',
+      workflowExecution: { workflowId: 'wf-1', runId: 'run-1' },
+      workflowType: 'myWorkflow'
+    };
     const basePayload = {
-      id: 'act-1',
-      name: 'myWorkflow#myStep',
-      kind: 'step',
-      workflowId: 'wf-1',
-      workflowName: 'myWorkflow'
+      activityInfo,
+      outputActivityKind: 'step'
     };
 
     it( 'ACTIVITY_START logs full message and second arg', () => {
@@ -47,18 +50,18 @@ describe( 'log_hooks', () => {
         {
           event: LifecycleEvent.START,
           activityId: 'act-1',
-          activityName: 'myWorkflow#myStep',
-          activityKind: 'step',
+          activityType: 'myWorkflow#myStep',
           workflowId: 'wf-1',
-          workflowName: 'myWorkflow'
+          workflowType: 'myWorkflow',
+          runId: 'run-1'
         }
       );
     } );
 
-    it( 'ACTIVITY_START does not log when kind is INTERNAL_STEP', () => {
+    it( 'ACTIVITY_START does not log trace destination activity', () => {
       onHandlers[BusEventType.ACTIVITY_START]( {
         ...basePayload,
-        kind: ComponentType.INTERNAL_STEP
+        activityInfo: { ...activityInfo, activityType: ACTIVITY_GET_TRACE_DESTINATIONS }
       } );
 
       expect( activityLogMock.info ).not.toHaveBeenCalled();
@@ -73,20 +76,18 @@ describe( 'log_hooks', () => {
         {
           event: LifecycleEvent.END,
           activityId: 'act-1',
-          activityName: 'myWorkflow#myStep',
-          activityKind: 'step',
+          activityType: 'myWorkflow#myStep',
           workflowId: 'wf-1',
-          workflowName: 'myWorkflow',
-          durationMs: 42
+          workflowType: 'myWorkflow',
+          runId: 'run-1'
         }
       );
     } );
 
-    it( 'ACTIVITY_END does not log when kind is INTERNAL_STEP', () => {
+    it( 'ACTIVITY_END does not log trace destination activity', () => {
       onHandlers[BusEventType.ACTIVITY_END]( {
         ...basePayload,
-        kind: ComponentType.INTERNAL_STEP,
-        duration: 10
+        activityInfo: { ...activityInfo, activityType: ACTIVITY_GET_TRACE_DESTINATIONS }
       } );
 
       expect( activityLogMock.info ).not.toHaveBeenCalled();
@@ -106,21 +107,19 @@ describe( 'log_hooks', () => {
         {
           event: LifecycleEvent.ERROR,
           activityId: 'act-1',
-          activityName: 'myWorkflow#myStep',
-          activityKind: 'step',
+          activityType: 'myWorkflow#myStep',
           workflowId: 'wf-1',
-          workflowName: 'myWorkflow',
-          durationMs: 100,
+          workflowType: 'myWorkflow',
+          runId: 'run-1',
           error: 'step failed'
         }
       );
     } );
 
-    it( 'ACTIVITY_ERROR does not log when kind is INTERNAL_STEP', () => {
+    it( 'ACTIVITY_ERROR does not log trace destination activity', () => {
       onHandlers[BusEventType.ACTIVITY_ERROR]( {
         ...basePayload,
-        kind: ComponentType.INTERNAL_STEP,
-        duration: 5,
+        activityInfo: { ...activityInfo, activityType: ACTIVITY_GET_TRACE_DESTINATIONS },
         error: new Error( 'x' )
       } );
 
@@ -129,7 +128,12 @@ describe( 'log_hooks', () => {
   } );
 
   describe( 'workflow events', () => {
-    const basePayload = { id: 'wf-1', name: 'myWorkflow' };
+    const workflowDetails = {
+      workflowId: 'wf-1',
+      workflowType: 'myWorkflow',
+      runId: 'run-1'
+    };
+    const basePayload = { workflowDetails };
 
     it( 'WORKFLOW_START logs full message and second arg', () => {
       onHandlers[BusEventType.WORKFLOW_START]( basePayload );
@@ -140,25 +144,22 @@ describe( 'log_hooks', () => {
         {
           event: LifecycleEvent.START,
           workflowId: 'wf-1',
-          workflowName: 'myWorkflow'
+          workflowType: 'myWorkflow',
+          runId: 'run-1'
         }
       );
     } );
 
-    it( 'WORKFLOW_START does not log when name is WORKFLOW_CATALOG', () => {
+    it( 'WORKFLOW_START does not log when workflowType is WORKFLOW_CATALOG', () => {
       onHandlers[BusEventType.WORKFLOW_START]( {
-        id: 'cat-1',
-        name: WORKFLOW_CATALOG
+        workflowDetails: { ...workflowDetails, workflowType: WORKFLOW_CATALOG }
       } );
 
       expect( workflowLogMock.info ).not.toHaveBeenCalled();
     } );
 
     it( 'WORKFLOW_END logs full message and second arg', () => {
-      onHandlers[BusEventType.WORKFLOW_END]( {
-        ...basePayload,
-        duration: 200
-      } );
+      onHandlers[BusEventType.WORKFLOW_END]( basePayload );
 
       expect( workflowLogMock.info ).toHaveBeenCalledTimes( 1 );
       expect( workflowLogMock.info ).toHaveBeenCalledWith(
@@ -166,17 +167,15 @@ describe( 'log_hooks', () => {
         {
           event: LifecycleEvent.END,
           workflowId: 'wf-1',
-          workflowName: 'myWorkflow',
-          durationMs: 200
+          workflowType: 'myWorkflow',
+          runId: 'run-1'
         }
       );
     } );
 
-    it( 'WORKFLOW_END does not log when name is WORKFLOW_CATALOG', () => {
+    it( 'WORKFLOW_END does not log when workflowType is WORKFLOW_CATALOG', () => {
       onHandlers[BusEventType.WORKFLOW_END]( {
-        id: 'cat-1',
-        name: WORKFLOW_CATALOG,
-        duration: 50
+        workflowDetails: { ...workflowDetails, workflowType: WORKFLOW_CATALOG }
       } );
 
       expect( workflowLogMock.info ).not.toHaveBeenCalled();
@@ -196,18 +195,16 @@ describe( 'log_hooks', () => {
         {
           event: LifecycleEvent.ERROR,
           workflowId: 'wf-1',
-          workflowName: 'myWorkflow',
-          durationMs: 150,
+          workflowType: 'myWorkflow',
+          runId: 'run-1',
           error: 'workflow boom'
         }
       );
     } );
 
-    it( 'WORKFLOW_ERROR does not log when name is WORKFLOW_CATALOG', () => {
+    it( 'WORKFLOW_ERROR does not log when workflowType is WORKFLOW_CATALOG', () => {
       onHandlers[BusEventType.WORKFLOW_ERROR]( {
-        id: 'cat-1',
-        name: WORKFLOW_CATALOG,
-        duration: 1,
+        workflowDetails: { ...workflowDetails, workflowType: WORKFLOW_CATALOG },
         error: new Error( 'x' )
       } );
 

package/src/worker/setup_telemetry.js

@@ -0,0 +1,19 @@
+import { createChildLogger } from '#logger';
+import { workerTelemetryIntervalMs } from './configs.js';
+
+const log = createChildLogger( 'Telemetry' );
+
+export const setupTelemetry = ( { worker } ) => {
+  if ( workerTelemetryIntervalMs > 0 ) {
+    setInterval( () => {
+      log.info( 'Worker', {
+        status: worker.getStatus(),
+        memory: {
+          availableMemory: process.availableMemory(),
+          constrainedMemory: process.constrainedMemory(),
+          memoryUsage: process.memoryUsage()
+        }
+      } );
+    }, workerTelemetryIntervalMs ).unref();
+  }
+};

package/src/worker/setup_telemetry.spec.js

@@ -0,0 +1,80 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const configMock = vi.hoisted( () => ( { workerTelemetryIntervalMs: 0 } ) );
+const logMock = vi.hoisted( () => ( { info: vi.fn() } ) );
+const createChildLoggerMock = vi.hoisted( () => vi.fn( () => logMock ) );
+
+vi.mock( './configs.js', () => ( {
+  get workerTelemetryIntervalMs() {
+    return configMock.workerTelemetryIntervalMs;
+  }
+} ) );
+
+vi.mock( '#logger', () => ( { createChildLogger: createChildLoggerMock } ) );
+
+const loadSetupTelemetry = async () => {
+  vi.resetModules();
+  return import( './setup_telemetry.js' );
+};
+
+const mockSetInterval = unrefMock =>
+  vi.spyOn( globalThis, 'setInterval' ).mockReturnValue( { unref: unrefMock } );
+
+describe( 'worker/setup_telemetry', () => {
+  const availableMemoryMock = vi.fn();
+  const constrainedMemoryMock = vi.fn();
+  const memoryUsageMock = vi.fn();
+  const unrefMock = vi.fn();
+
+  beforeEach( () => {
+    vi.clearAllMocks();
+    configMock.workerTelemetryIntervalMs = 0;
+
+    availableMemoryMock.mockReturnValue( 1_000 );
+    constrainedMemoryMock.mockReturnValue( 2_000 );
+    memoryUsageMock.mockReturnValue( { heapUsed: 300 } );
+
+    vi.spyOn( process, 'availableMemory' ).mockImplementation( availableMemoryMock );
+    vi.spyOn( process, 'constrainedMemory' ).mockImplementation( constrainedMemoryMock );
+    vi.spyOn( process, 'memoryUsage' ).mockImplementation( memoryUsageMock );
+  } );
+
+  afterEach( () => {
+    vi.restoreAllMocks();
+  } );
+
+  it( 'does not create an interval when telemetry interval is disabled', async () => {
+    const setIntervalMock = mockSetInterval( unrefMock );
+    const { setupTelemetry } = await loadSetupTelemetry();
+
+    setupTelemetry( { worker: { getStatus: vi.fn() } } );
+
+    expect( setIntervalMock ).not.toHaveBeenCalled();
+    expect( logMock.info ).not.toHaveBeenCalled();
+  } );
+
+  it( 'logs worker status and memory on the configured interval', async () => {
+    const setIntervalMock = mockSetInterval( unrefMock );
+    configMock.workerTelemetryIntervalMs = 5_000;
+    const worker = { getStatus: vi.fn().mockReturnValue( { runState: 'RUNNING' } ) };
+    const { setupTelemetry } = await loadSetupTelemetry();
+
+    setupTelemetry( { worker } );
+
+    expect( createChildLoggerMock ).toHaveBeenCalledWith( 'Telemetry' );
+    expect( setIntervalMock ).toHaveBeenCalledWith( expect.any( Function ), 5_000 );
+    expect( unrefMock ).toHaveBeenCalled();
+
+    const [ callback ] = setIntervalMock.mock.calls[0];
+    callback();
+
+    expect( logMock.info ).toHaveBeenCalledWith( 'Worker', {
+      status: { runState: 'RUNNING' },
+      memory: {
+        availableMemory: 1_000,
+        constrainedMemory: 2_000,
+        memoryUsage: { heapUsed: 300 }
+      }
+    } );
+  } );
+} );

package/src/worker/sinks.js

@@ -1,6 +1,7 @@
 import { BusEventType, ComponentType } from '#consts';
 import * as Tracing from '#tracing';
 import { messageBus } from '#bus';
+import { createWorkflowDetails } from '#internal_utils/temporal_context';
 
 // This sink allow for sandbox Temporal environment to send trace logs back to the main thread.
 export const sinks = {
@@ -11,10 +12,17 @@ export const sinks = {
   workflow: {
     start: {
       fn: ( workflowInfo, input ) => {
-        const { workflowId: id, runId, workflowType: name, memo: { parentId, executionContext } } = workflowInfo;
-        messageBus.emit( BusEventType.WORKFLOW_START, { id, runId, name } );
-        if ( executionContext ) { // filters out internal workflows
-          Tracing.addEventStart( { id, kind: ComponentType.WORKFLOW, name, details: input, parentId, executionContext } );
+        const { runId, workflowType, memo: { traceInfo }, parent } = workflowInfo;
+        messageBus.emit( BusEventType.WORKFLOW_START, { workflowDetails: createWorkflowDetails( workflowInfo ) } );
+        if ( traceInfo ) { // internal workflows (catalog) do not have this info
+          Tracing.addEventStart( {
+            id: runId,
+            kind: ComponentType.WORKFLOW,
+            name: workflowType,
+            details: input,
+            parentId: parent?.runId,
+            traceInfo
+          } );
         }
       },
       callDuringReplay: false
@@ -22,10 +30,10 @@ export const sinks = {
 
     end: {
       fn: ( workflowInfo, output ) => {
-        const { workflowId: id, runId, workflowType: name, startTime, memo: { executionContext } } = workflowInfo;
-        messageBus.emit( BusEventType.WORKFLOW_END, { id, runId, name, duration: Date.now() - startTime.getTime() } );
-        if ( executionContext ) { // filters out internal workflows
-          Tracing.addEventEnd( { id, details: output, executionContext } );
+        const { runId, memo: { traceInfo } } = workflowInfo;
+        messageBus.emit( BusEventType.WORKFLOW_END, { workflowDetails: createWorkflowDetails( workflowInfo ) } );
+        if ( traceInfo ) { // internal workflows (catalog) do not have this info
+          Tracing.addEventEnd( { id: runId, details: output, traceInfo } );
         }
       },
       callDuringReplay: false
@@ -33,10 +41,10 @@ export const sinks = {
 
     error: {
       fn: ( workflowInfo, error ) => {
-        const { workflowId: id, runId, workflowType: name, startTime, memo: { executionContext } } = workflowInfo;
-        messageBus.emit( BusEventType.WORKFLOW_ERROR, { id, runId, name, error, duration: Date.now() - startTime.getTime() } );
-        if ( executionContext ) { // filters out internal workflows
-          Tracing.addEventError( { id, details: error, executionContext } );
+        const { runId, memo: { traceInfo } } = workflowInfo;
+        messageBus.emit( BusEventType.WORKFLOW_ERROR, { workflowDetails: createWorkflowDetails( workflowInfo ), error } );
+        if ( traceInfo ) { // internal workflows (catalog) do not have this info
+          Tracing.addEventError( { id: runId, details: error, traceInfo } );
         }
       },
       callDuringReplay: false
@@ -48,26 +56,18 @@ export const sinks = {
    */
   trace: {
     start: {
-      fn: ( workflowInfo, { id, name, kind, details } ) => {
-        const { memo: { executionContext, parentId } } = workflowInfo;
-        Tracing.addEventStart( { id, kind, name, details, parentId, executionContext } );
-      },
+      fn: ( workflowInfo, { id, name, kind, details } ) =>
+        Tracing.addEventStart( { id, kind, name, details, parentId: workflowInfo.parent?.runId, traceInfo: workflowInfo.memo.traceInfo } ),
       callDuringReplay: false
     },
 
     end: {
-      fn: ( workflowInfo, { id, details } ) => {
-        const { memo: { executionContext } } = workflowInfo;
-        Tracing.addEventEnd( { id, details, executionContext } );
-      },
+      fn: ( workflowInfo, { id, details } ) => Tracing.addEventEnd( { id, details, traceInfo: workflowInfo.memo.traceInfo } ),
       callDuringReplay: false
     },
 
     error: {
-      fn: ( workflowInfo, { id, details } ) => {
-        const { memo: { executionContext } } = workflowInfo;
-        Tracing.addEventError( { id, details, executionContext } );
-      },
+      fn: ( workflowInfo, { id, details } ) => Tracing.addEventError( { id, details, traceInfo: workflowInfo.memo.traceInfo } ),
       callDuringReplay: false
     }
   }

package/src/interface/workflow_context.js

@@ -1,33 +0,0 @@
-/**
- * Context instance builder
- */
-export class Context {
-
-  /**
-   * Builds a new context instance
-   * @param {object} options - Arguments to build a new context instance
-   * @param {string} workflowId
-   * @param {string} runId
-   * @param {function} continueAsNew
-   * @param {function} isContinueAsNewSuggested
-   * @returns {object} context
-   */
-  static build( { workflowId, runId, continueAsNew, isContinueAsNewSuggested } ) {
-    return {
-      /**
-       * Control namespace: This object adds functions to interact with Temporal flow mechanisms
-       */
-      control: {
-        continueAsNew,
-        isContinueAsNewSuggested
-      },
-      /**
-       * Info namespace: abstracts workflowInfo()
-       */
-      info: {
-        workflowId,
-        runId
-      }
-    };
-  }
-};

package/src/logger.js

@@ -1,73 +0,0 @@
-import winston from 'winston';
-import { shuffleArray } from '#utils';
-
-const isProduction = process.env.NODE_ENV === 'production';
-
-const levels = {
-  error: 0,
-  warn: 1,
-  info: 2,
-  http: 3,
-  debug: 4
-};
-
-const colors = shuffleArray( [
-  '033', // blue
-  '030', // green
-  '208', // orange
-  '045', // turquoise
-  '129', // purple
-  '184' // yellow
-] );
-const assignedColors = new Map();
-
-// Format metadata as friendly JSON: "{ name: "foo", count: 5 }"
-const formatMeta = obj => {
-  const entries = Object.entries( obj );
-  if ( !entries.length ) {
-    return '';
-  }
-  return ' { ' + entries.map( ( [ k, v ] ) => `${k}: ${JSON.stringify( v )}` ).join( ', ' ) + ' }';
-};
-// Distribute the namespace in a map and assign it the next available color
-const getColor = v =>
-  assignedColors.has( v ) ? assignedColors.get( v ) : assignedColors.set( v, colors[assignedColors.size % colors.length] ).get( v );
-
-// Colorize a text using the namespace string
-const colorizeByNamespace = ( namespace, text ) => `\x1b[38;5;${getColor( namespace )}m${text}\x1b[0m`;
-
-// Development format: colorized with namespace prefix
-const devFormat = winston.format.combine(
-  winston.format.colorize(),
-  winston.format.printf( ( { level, message, namespace, service: _, environment: __, ...rest } ) => {
-    const ns = 'Core' + ( namespace ? `.${namespace}` : '' );
-    const meta = formatMeta( rest );
-    return `[${level}] ${colorizeByNamespace( ns, `${namespace}: ${message}` )}${meta}`;
-  } )
-);
-
-// Production format: structured JSON
-const prodFormat = winston.format.combine(
-  winston.format.timestamp( { format: 'YYYY-MM-DDTHH:mm:ss.SSSZ' } ),
-  winston.format.errors( { stack: true } ),
-  winston.format.json()
-);
-
-export const logger = winston.createLogger( {
-  levels,
-  level: isProduction ? 'info' : 'debug',
-  format: isProduction ? prodFormat : devFormat,
-  defaultMeta: {
-    service: 'output-worker',
-    environment: process.env.NODE_ENV || 'development'
-  },
-  transports: [ new winston.transports.Console() ]
-} );
-
-/**
- * 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 } );