@output.ai/core 0.4.5 → 0.4.7

package/package.json

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

package/src/consts.js

@@ -10,3 +10,13 @@ export const ComponentType = {
   INTERNAL_STEP: 'internal_step',
   STEP: 'step'
 };
+export const LifecycleEvent = {
+  START: 'start',
+  END: 'end',
+  ERROR: 'error'
+};
+export const LifecycleEventLogMessage = {
+  [LifecycleEvent.START]: 'Start',
+  [LifecycleEvent.END]: 'End',
+  [LifecycleEvent.ERROR]: 'Error'
+};

package/src/index.js

@@ -17,7 +17,7 @@ export {
   EvaluationStringResult,
   EvaluationBooleanResult,
   EvaluationFeedback,
-  // webhook tools
+  // tools
   executeInParallel,
   sendHttpRequest,
   sendPostRequestAndAwaitWebhook,

package/src/internal_activities/index.spec.js

@@ -4,15 +4,18 @@ import { FatalError } from '#errors';
 import { serializeBodyAndInferContentType, serializeFetchResponse } from '#utils';
 import { sendHttpRequest } from './index.js';
 
-vi.mock( '#utils', () => {
-  return {
-    setMetadata: vi.fn(),
-    isStringboolTrue: vi.fn( () => false ),
-    serializeBodyAndInferContentType: vi.fn(),
-    serializeFetchResponse: vi.fn()
-  };
+vi.mock( '#logger', () => {
+  const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+  return { createChildLogger: vi.fn( () => log ) };
 } );
 
+vi.mock( '#utils', () => ( {
+  setMetadata: vi.fn(),
+  isStringboolTrue: vi.fn( () => false ),
+  serializeBodyAndInferContentType: vi.fn(),
+  serializeFetchResponse: vi.fn()
+} ) );
+
 const mockAgent = new MockAgent();
 mockAgent.disableNetConnect();
 

package/src/logger.js

@@ -1,4 +1,5 @@
 import winston from 'winston';
+import { shuffleArray } from '#utils';
 
 const isProduction = process.env.NODE_ENV === 'production';
 
@@ -10,6 +11,16 @@ const levels = {
   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 );
@@ -18,14 +29,20 @@ const formatMeta = obj => {
   }
   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 = namespace ? `{Core.${namespace}}` : '{Core}';
+    const ns = 'Core' + ( namespace ? `.${namespace}` : '' );
     const meta = formatMeta( rest );
-    return `[${level}] ${ns} ${message}${meta}`;
+    return `[${level}] ${colorizeByNamespace( ns, `${namespace}: ${message}` )}${meta}`;
   } )
 );
 

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

@@ -18,7 +18,7 @@ const addEntry = async ( entry, key ) => {
   const client = await getRedisClient();
   await client.multi()
     .zAdd( key, [ { score: entry.timestamp, value: JSON.stringify( entry ) } ], { NX: true } )
-    .expire( key, getVars().redisIncompleteWorkflowsTTL, 'GT' )
+    .expire( key, getVars().redisIncompleteWorkflowsTTL )
     .exec();
 };
 

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

@@ -88,6 +88,20 @@ 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( [] );
+    zRangeMock.mockResolvedValue( [ JSON.stringify( { phase: 'start', timestamp: startTime } ) ] );
+
+    await exec( { ...ctx, entry: { phase: 'start', timestamp: startTime, parentId: 'root' } } );
+
+    expect( redisMulti.expire ).toHaveBeenCalledTimes( 1 );
+    expect( redisMulti.expire ).toHaveBeenCalledWith( 'traces/WF/id1', 3600 );
+  } );
+
   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' );

package/src/utils/index.d.ts

@@ -96,6 +96,14 @@ export function serializeBodyAndInferContentType( body: unknown ): SerializedBod
  */
 export function isPlainObject( object: unknown ): boolean;
 
+/**
+ * Returns a copy of an array with its content shuffled.
+ *
+ * @param arr - The array to shuffle
+ * @returns A shuffled array copy
+ */
+export function shuffleArray( arr: array ): array;
+
 /**
  * Creates a new object by merging object `b` onto object `a`, biased toward `b`:
  * - Fields in `b` overwrite fields in `a`.

package/src/utils/utils.js

@@ -162,6 +162,17 @@ export const serializeBodyAndInferContentType = payload => {
   return { body: String( payload ), contentType: 'text/plain; charset=UTF-8' };
 };
 
+/**
+ * Receives an array and returns a copy of it with the elements shuffled
+ *
+ * @param {array} arr
+ * @returns {array}
+ */
+export const shuffleArray = arr => arr
+  .map( v => ( { v, sort: Math.random() } ) )
+  .sort( ( a, b ) => a.sort - b.sort )
+  .map( ( { v } ) => v );
+
 /**
  * Creates a new object merging object "b" onto object "a" biased to "b":
  * - Object "b" will overwrite fields on object "a";

package/src/worker/interceptors/activity.js

@@ -2,9 +2,11 @@ import { Context } from '@temporalio/activity';
 import { Storage } from '#async_storage';
 import { addEventStart, addEventEnd, addEventError } from '#tracing';
 import { headersToObject } from '../sandboxed_utils.js';
-import { METADATA_ACCESS_SYMBOL } from '#consts';
+import { LifecycleEventLogMessage, LifecycleEvent, METADATA_ACCESS_SYMBOL } from '#consts';
 import { activityHeartbeatEnabled, activityHeartbeatIntervalMs } from '../configs.js';
+import { createChildLogger } from '#logger';
 
+const log = createChildLogger( 'Activity' );
 /*
   This interceptor wraps every activity execution with cross-cutting concerns:
 
@@ -27,11 +29,15 @@ export class ActivityExecutionInterceptor {
   };
 
   async execute( input, next ) {
-    const { workflowExecution: { workflowId }, activityId, activityType } = Context.current().info;
+    const { workflowExecution: { workflowId }, activityId, activityType, workflowType: workflowName } = Context.current().info;
     const { executionContext } = headersToObject( input.headers );
     const { type: kind } = this.activities?.[activityType]?.[METADATA_ACCESS_SYMBOL];
 
+    const startDate = Date.now();
+    const logContext = { workflowName, workflowId, stepId: activityId, stepName: activityType };
     const traceArguments = { kind, id: activityId, parentId: workflowId, name: activityType, executionContext };
+
+    log.info( LifecycleEventLogMessage[LifecycleEvent.START], logContext );
     addEventStart( { details: input.args[0], ...traceArguments } );
 
     const intervals = { heartbeat: null };
@@ -40,10 +46,13 @@ export class ActivityExecutionInterceptor {
       intervals.heartbeat = activityHeartbeatEnabled && setInterval( () => Context.current().heartbeat(), activityHeartbeatIntervalMs );
 
       const output = await Storage.runWithContext( async _ => next( input ), { parentId: activityId, executionContext } );
+
+      log.info( LifecycleEventLogMessage[LifecycleEvent.END], { ...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 } );
       addEventError( { details: error, ...traceArguments } );
       throw error;
 

package/src/worker/interceptors/activity.spec.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 
-const METADATA_ACCESS_SYMBOL = Symbol( '__metadata' );
+const METADATA_ACCESS_SYMBOL = vi.hoisted( () => Symbol( '__metadata' ) );
 
 const heartbeatMock = vi.fn();
 const contextInfoMock = {
@@ -37,11 +37,14 @@ vi.mock( '../sandboxed_utils.js', () => ( {
   headersToObject: () => ( { executionContext: { workflowId: 'wf-1' } } )
 } ) );
 
-vi.mock( '#consts', () => ( {
-  get METADATA_ACCESS_SYMBOL() {
-    return METADATA_ACCESS_SYMBOL;
-  }
-} ) );
+vi.mock( '#consts', async importOriginal => {
+  const actual = await importOriginal();
+  return {
+    ...actual, get METADATA_ACCESS_SYMBOL() {
+      return METADATA_ACCESS_SYMBOL;
+    }
+  };
+} );
 
 vi.mock( '../configs.js', () => ( {
   get activityHeartbeatEnabled() {

package/src/worker/sinks.js

@@ -1,11 +1,11 @@
-import { WORKFLOW_CATALOG } from '#consts';
+import { LifecycleEvent, LifecycleEventLogMessage, WORKFLOW_CATALOG } from '#consts';
 import { addEventStart, addEventEnd, addEventError } from '#tracing';
 import { createChildLogger } from '#logger';
 
-const log = createChildLogger( 'Worker' );
+const log = createChildLogger( 'Workflow' );
 
 /**
- * Start a workflow trace event
+ * Adds a workflow trace event
  *
  * @param {function} method - Trace function to call
  * @param {object} workflowInfo - Temporal workflowInfo object
@@ -20,44 +20,31 @@ const addWorkflowEvent = ( method, workflowInfo, details ) => {
 };
 
 /**
- * Log workflow start
+ * Logs the internal workflow event
  *
- * @param {object} workflowInfo - Temporal workflowInfo object
- */
-const logWorkflowStart = workflowInfo => {
-  const { workflowId, workflowType: workflowName } = workflowInfo;
-  if ( workflowName === WORKFLOW_CATALOG ) {
-    return;
-  }
-  log.info( 'Workflow started', { workflowName, workflowId } );
-};
-
-/**
- * Log workflow completion with duration
- *
- * @param {object} workflowInfo - Temporal workflowInfo object
+ * @param {LifecycleEvent} event
+ * @param {Object} workflowInfo
+ * @returns {void}
  */
-const logWorkflowEnd = workflowInfo => {
+const logWorkflowEvent = ( event, workflowInfo, error ) => {
   const { workflowId, workflowType: workflowName, startTime } = workflowInfo;
+  // exclude internal catalog
   if ( workflowName === WORKFLOW_CATALOG ) {
     return;
   }
-  const durationMs = Date.now() - startTime.getTime();
-  log.info( 'Workflow completed', { workflowName, workflowId, durationMs } );
-};
 
-/**
- * Log workflow failure with duration
- *
- * @param {object} workflowInfo - Temporal workflowInfo object
- */
-const logWorkflowError = workflowInfo => {
-  const { workflowId, workflowType: workflowName, startTime } = workflowInfo;
-  if ( workflowName === WORKFLOW_CATALOG ) {
-    return;
+  if ( event === LifecycleEvent.START ) {
+    log.info( LifecycleEventLogMessage[event], { workflowName, workflowId } );
+  } else if ( event === LifecycleEvent.END ) {
+    log.info( LifecycleEventLogMessage[event], { workflowName, workflowId, durationMs: Date.now() - startTime.getTime() } );
+  } else if ( event === LifecycleEvent.ERROR ) {
+    log.info( LifecycleEventLogMessage[event], {
+      workflowName,
+      workflowId,
+      durationMs: Date.now() - startTime.getTime(),
+      error: error.message
+    } );
   }
-  const durationMs = Date.now() - startTime.getTime();
-  log.error( 'Workflow failed', { workflowName, workflowId, durationMs } );
 };
 
 /**
@@ -77,25 +64,25 @@ const addEvent = ( method, workflowInfo, options ) => {
 export const sinks = {
   trace: {
     addWorkflowEventStart: {
-      fn: ( workflowInfo, ...rest ) => {
-        logWorkflowStart( workflowInfo );
-        addWorkflowEvent( addEventStart, workflowInfo, ...rest );
+      fn: ( workflowInfo, details ) => {
+        logWorkflowEvent( LifecycleEvent.START, workflowInfo );
+        addWorkflowEvent( addEventStart, workflowInfo, details );
       },
       callDuringReplay: false
     },
 
     addWorkflowEventEnd: {
-      fn: ( workflowInfo, ...rest ) => {
-        logWorkflowEnd( workflowInfo );
-        addWorkflowEvent( addEventEnd, workflowInfo, ...rest );
+      fn: ( workflowInfo, details ) => {
+        logWorkflowEvent( LifecycleEvent.END, workflowInfo );
+        addWorkflowEvent( addEventEnd, workflowInfo, details );
       },
       callDuringReplay: false
     },
 
     addWorkflowEventError: {
-      fn: ( workflowInfo, ...rest ) => {
-        logWorkflowError( workflowInfo );
-        addWorkflowEvent( addEventError, workflowInfo, ...rest );
+      fn: ( workflowInfo, details ) => {
+        logWorkflowEvent( LifecycleEvent.ERROR, workflowInfo, details );
+        addWorkflowEvent( addEventError, workflowInfo, details );
       },
       callDuringReplay: false
     },

package/src/logger.d.ts

@@ -1,4 +0,0 @@
-import type { Logger } from 'winston';
-
-export declare const logger: Logger;
-export declare function createChildLogger( namespace: string ): Logger;