@outputai/core 0.6.0 → 0.6.1-next.34badf9.0

package/src/worker/log_hooks.js

@@ -1,6 +1,6 @@
 import { messageBus } from '#bus';
 import { createChildLogger } from '#logger';
-import { BusEventType, ComponentType, LifecycleEvent, WORKFLOW_CATALOG } from '#consts';
+import { ACTIVITY_GET_TRACE_DESTINATIONS, BusEventType, LifecycleEvent, WORKFLOW_CATALOG } from '#consts';
 
 const activityLog = createChildLogger( 'Activity' );
 const workflowLog = createChildLogger( 'Workflow' );
@@ -15,43 +15,34 @@ const workflowLog = createChildLogger( 'Workflow' );
 ╚═════════════════╝
 */
 
-/**
- * Returns true if activity event should be logged
- */
-const shouldLogActivityEvent = ( { kind } ) => kind !== ComponentType.INTERNAL_STEP;
+const serializedActivityFields = activityInfo => ( {
+  activityId: activityInfo.activityId,
+  activityType: activityInfo.activityType,
+  workflowId: activityInfo.workflowExecution.workflowId,
+  workflowType: activityInfo.workflowType,
+  runId: activityInfo.workflowExecution.runId
+} );
+
+const shouldLogActivity = activityInfo => activityInfo.activityType !== ACTIVITY_GET_TRACE_DESTINATIONS;
 
-messageBus.on( BusEventType.ACTIVITY_START, ( { id, name, kind, workflowId, workflowName } ) =>
-  shouldLogActivityEvent( { kind } ) && activityLog.info( `Started ${name} ${kind}`, {
+messageBus.on( BusEventType.ACTIVITY_START, ( { activityInfo, outputActivityKind } ) =>
+  shouldLogActivity( activityInfo ) && activityLog.info( `Started ${activityInfo.activityType} ${outputActivityKind}`, {
     event: LifecycleEvent.START,
-    activityId: id,
-    activityName: name,
-    activityKind: kind,
-    workflowId,
-    workflowName
+    ...serializedActivityFields( activityInfo )
   } )
 );
 
-messageBus.on( BusEventType.ACTIVITY_END, ( { id, name, kind, workflowId, workflowName, duration } ) =>
-  shouldLogActivityEvent( { kind } ) && activityLog.info( `Ended ${name} ${kind}`, {
+messageBus.on( BusEventType.ACTIVITY_END, ( { activityInfo, outputActivityKind } ) =>
+  shouldLogActivity( activityInfo ) && activityLog.info( `Ended ${activityInfo.activityType} ${outputActivityKind}`, {
     event: LifecycleEvent.END,
-    activityId: id,
-    activityName: name,
-    activityKind: kind,
-    workflowId,
-    workflowName,
-    durationMs: duration
+    ...serializedActivityFields( activityInfo )
   } )
 );
 
-messageBus.on( BusEventType.ACTIVITY_ERROR, ( { id, name, kind, workflowId, workflowName, duration, error } ) =>
-  shouldLogActivityEvent( { kind } ) && activityLog.error( `Error ${name} ${kind}: ${error.constructor.name}`, {
+messageBus.on( BusEventType.ACTIVITY_ERROR, ( { activityInfo, outputActivityKind, error } ) =>
+  shouldLogActivity( activityInfo ) && activityLog.error( `Error ${activityInfo.activityType} ${outputActivityKind}: ${error.constructor.name}`, {
     event: LifecycleEvent.ERROR,
-    activityId: id,
-    activityName: name,
-    activityKind: kind,
-    workflowId,
-    workflowName,
-    durationMs: duration,
+    ...serializedActivityFields( activityInfo ),
     error: error.message
   } )
 );
@@ -62,34 +53,32 @@ messageBus.on( BusEventType.ACTIVITY_ERROR, ( { id, name, kind, workflowId, work
 ╚═════════════════╝
 */
 
-/**
- * Returns true if activity event should be logged
- */
-const shouldLogWorkflowEvent = ( { name } ) => name !== WORKFLOW_CATALOG;
+const serializeWorkflowFields = workflowDetails => ( {
+  workflowId: workflowDetails.workflowId,
+  workflowType: workflowDetails.workflowType,
+  runId: workflowDetails.runId
+} );
+
+const shouldLogWorkflow = workflowDetails => workflowDetails.workflowType !== WORKFLOW_CATALOG;
 
-messageBus.on( BusEventType.WORKFLOW_START, ( { id, name } ) =>
-  shouldLogWorkflowEvent( { name } ) && workflowLog.info( `Started ${name} workflow`, {
+messageBus.on( BusEventType.WORKFLOW_START, ( { workflowDetails } ) =>
+  shouldLogWorkflow( workflowDetails ) && workflowLog.info( `Started ${workflowDetails.workflowType} workflow`, {
     event: LifecycleEvent.START,
-    workflowId: id,
-    workflowName: name
+    ...serializeWorkflowFields( workflowDetails )
   } )
 );
 
-messageBus.on( BusEventType.WORKFLOW_END, ( { id, name, duration } ) =>
-  shouldLogWorkflowEvent( { name } ) && workflowLog.info( `Ended ${name} workflow`, {
+messageBus.on( BusEventType.WORKFLOW_END, ( { workflowDetails } ) =>
+  shouldLogWorkflow( workflowDetails ) && workflowLog.info( `Ended ${workflowDetails.workflowType} workflow`, {
     event: LifecycleEvent.END,
-    workflowId: id,
-    workflowName: name,
-    durationMs: duration
+    ...serializeWorkflowFields( workflowDetails )
   } )
 );
 
-messageBus.on( BusEventType.WORKFLOW_ERROR, ( { id, name, duration, error } ) =>
-  shouldLogWorkflowEvent( { name } ) && workflowLog.error( `Error ${name} workflow: ${error.constructor.name}`, {
+messageBus.on( BusEventType.WORKFLOW_ERROR, ( { workflowDetails, error } ) =>
+  shouldLogWorkflow( workflowDetails ) && workflowLog.error( `Error ${workflowDetails.workflowType} workflow: ${error.constructor.name}`, {
     event: LifecycleEvent.ERROR,
-    workflowId: id,
-    workflowName: name,
-    durationMs: duration,
+    ...serializeWorkflowFields( workflowDetails ),
     error: error.message
   } )
 );

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/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
-      }
-    };
-  }
-};