@outputai/core 0.8.2-next.42a0ddf.0 → 0.8.2-next.57bc8d6.0

package/src/sdk/runtime/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * > [!WARNING]
+ * > **Internal use only.** Not part of the public API; may change without notice.
+ *
+ * These are helpers for other SDK modules integration.
+ * These need Temporal activity runtime to work, as they access state, emit events and use node:* modules.
+ *
+ * @packageDocumentation
+ */
+export * from './context.js';
+export * from './events.js';
+export * from './tracing.js';

package/src/sdk/runtime/index.js

@@ -0,0 +1,3 @@
+export * from './context.js';
+export * from './events.js';
+export * from './tracing.js';

package/src/sdk/runtime/tracing.d.ts

@@ -0,0 +1,46 @@
+import { Attribute } from '#trace_attribute';
+
+/**
+ * Tools to interact with Tracing
+ */
+export declare const Tracing: {
+  Attribute: typeof Attribute;
+
+  /**
+   * Creates a new event.
+   *
+   * @param args
+   * @param args.id - A unique id for the Event.
+   * @param args.kind - The kind of Event, like HTTP, DiskWrite, DBOp, etc.
+   * @param args.name - The human-friendly name of the Event: query, request, create.
+   * @param args.details - Arbitrary data to add to this event, it will be used as the "input" field.
+   */
+  addEventStart( args: { id: string; kind: string; name: string; details: unknown } ): void;
+
+  /**
+   * Concludes an event.
+   *
+   * @param args
+   * @param args.id - The id of the event to conclude.
+   * @param args.details - Arbitrary data to add to this event, it will be used as the "output" field.
+   */
+  addEventEnd( args: { id: string; details: unknown } ): void;
+
+  /**
+   * Concludes an event with an error.
+   *
+   * @param args
+   * @param args.id - The id of the event to conclude.
+   * @param args.details - Arbitrary data to add to this event, it will be used as the "error" field.
+   */
+  addEventError( args: { id: string; details: unknown } ): void;
+
+  /**
+   * Adds an attribute to an event.
+   *
+   * @param args
+   * @param args.eventId - The id of the event to attach the attribute to.
+   * @param args.attribute - The attribute to attach to the event.
+   */
+  addEventAttribute( args: { eventId: string; attribute: Attribute.Instance } ): void;
+};

package/src/sdk/runtime/tracing.js

@@ -0,0 +1,11 @@
+import { addEventActionWithContext as send, EventAction } from '#tracing';
+
+import { Attribute } from '#trace_attribute';
+
+export const Tracing = {
+  Attribute,
+  addEventStart: ( { id, kind, name, details } ) => send( EventAction.START, { kind, name, details, id } ),
+  addEventEnd: ( { id, details } ) => send( EventAction.END, { id, details } ),
+  addEventError: ( { id, details } ) => send( EventAction.ERROR, { id, details } ),
+  addEventAttribute: ( { eventId, attribute } ) => send( EventAction.ADD_ATTR, { id: eventId, details: attribute } )
+};

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

@@ -1,11 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 
-vi.mock( '#utils', () => ( {
-  throws: e => {
-    throw e;
-  }
-} ) );
-
 const logCalls = { warn: [], error: [] };
 vi.mock( '#logger', () => ( {
   createChildLogger: () => ( {

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

@@ -1,11 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
-vi.mock( '#utils', () => ( {
-  throws: e => {
-    throw e;
-  }
-} ) );
-
 const getVarsMock = vi.fn();
 vi.mock( './configs', () => ( { getVars: () => getVarsMock() } ) );
 

package/src/tracing/trace_engine.js

@@ -1,7 +1,7 @@
 import { Storage } from '#async_storage';
 import { EventEmitter } from 'node:events';
 import { serializeError } from './tools/utils.js';
-import { isStringboolTrue } from '#utils';
+import { isStringboolTrue } from '#helpers/string';
 import * as localProcessor from './processors/local/index.js';
 import * as s3Processor from './processors/s3/index.js';
 import { ComponentType } from '#consts';

package/src/worker/catalog_workflow/catalog_job.js

@@ -3,7 +3,7 @@ import { WorkflowExecutionAlreadyStartedError, WorkflowIdConflictPolicy } from '
 import { WORKFLOW_CATALOG } from '#consts';
 import { catalogId, taskQueue } from '../configs.js';
 import { createChildLogger } from '#logger';
-import { CancellablePromise } from '#utils';
+import { CancellablePromise } from '#helpers/promise';
 
 const log = createChildLogger( 'Catalog' );
 

package/src/worker/catalog_workflow/index.spec.js

@@ -7,9 +7,6 @@ vi.mock( '#consts', () => ( {
   METADATA_ACCESS_SYMBOL
 } ) );
 
-const setMetadata = ( target, values ) =>
-  Object.defineProperty( target, METADATA_ACCESS_SYMBOL, { value: values, writable: false, enumerable: false, configurable: false } );
-
 describe( 'createCatalog', () => {
   it( 'builds catalog with activities grouped by workflow path and returns Catalog with CatalogWorkflow entries', async () => {
     const { createCatalog } = await import( './index.js' );
@@ -32,40 +29,40 @@ describe( 'createCatalog', () => {
     ];
 
     const activity1 = () => {};
-    setMetadata( activity1, {
+    activity1[METADATA_ACCESS_SYMBOL] = {
       name: 'A1',
       path: '/flows/flow1#A1',
       description: 'desc-a1',
       inputSchema: z.object( { in: z.literal( 'a1' ) } ),
       outputSchema: z.object( { out: z.literal( 'a1' ) } )
-    } );
+    };
 
     const activity2 = () => {};
-    setMetadata( activity2, {
+    activity2[METADATA_ACCESS_SYMBOL] = {
       name: 'A2',
       path: '/flows/flow1#A2',
       description: 'desc-a2',
       inputSchema: z.object( { in: z.literal( 'a2' ) } ),
       outputSchema: z.object( { out: z.literal( 'a2' ) } )
-    } );
+    };
 
     const activity3 = () => {};
-    setMetadata( activity3, {
+    activity3[METADATA_ACCESS_SYMBOL] = {
       name: 'B1',
       path: '/flows/flow2#B1',
       description: 'desc-b1',
       inputSchema: z.object( { in: z.literal( 'b1' ) } ),
       outputSchema: z.object( { out: z.literal( 'b1' ) } )
-    } );
+    };
 
     const activity4 = () => {};
-    setMetadata( activity4, {
+    activity4[METADATA_ACCESS_SYMBOL] = {
       name: 'X',
       path: '/other#X',
       description: 'desc-x',
       inputSchema: z.object( { in: z.literal( 'x' ) } ),
       outputSchema: z.object( { out: z.literal( 'x' ) } )
-    } );
+    };
 
     const activities = {
       '/flows/flow1#A1': activity1,

package/src/worker/configs.js

@@ -1,5 +1,5 @@
 import * as z from 'zod';
-import { isStringboolTrue } from '#utils';
+import { isStringboolTrue } from '#helpers/string';
 
 class InvalidEnvVarsErrors extends Error { }
 

package/src/worker/connection_monitor.js

@@ -1,6 +1,6 @@
 import { createChildLogger } from '#logger';
 import { setTimeout as delay } from 'node:timers/promises';
-import { CancellablePromise } from '#utils';
+import { CancellablePromise } from '#helpers/promise';
 
 const log = createChildLogger( 'Connection' );
 

package/src/worker/global_functions.js

@@ -0,0 +1,14 @@
+import { messageBus } from '#bus';
+import { ACTIVITY_LOGGER_SYMBOL, BusEventType } from '#consts';
+import { activityInfo as activityInfoFn } from '@temporalio/activity';
+import { assignImmutableProperty } from '#helpers/object';
+
+/**
+ * Sets global functions on globalThis
+ */
+export const bindGlobalFunctions = () => {
+  /** Defines the activity logger function, accessible in activity context via logger interface */
+  assignImmutableProperty( globalThis, ACTIVITY_LOGGER_SYMBOL, ( { level, message, metadata } ) =>
+    messageBus.emit( BusEventType.ACTIVITY_LOG, { level, message, metadata, activityInfo: activityInfoFn() } )
+  );
+};

package/src/worker/global_functions.spec.js

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const {
+  ACTIVITY_LOGGER_SYMBOL,
+  BusEventType
+} = vi.hoisted( () => ( {
+  ACTIVITY_LOGGER_SYMBOL: Symbol( 'activity_logger' ),
+  BusEventType: {
+    ACTIVITY_LOG: 'activity:log'
+  }
+} ) );
+
+const messageBusMock = vi.hoisted( () => ( {
+  emit: vi.fn()
+} ) );
+const activityInfoMock = vi.hoisted( () => vi.fn( () => ( {
+  activityId: 'act-1',
+  activityType: 'myStep'
+} ) ) );
+
+vi.mock( '#consts', () => ( { ACTIVITY_LOGGER_SYMBOL, BusEventType } ) );
+vi.mock( '#bus', () => ( { messageBus: messageBusMock } ) );
+vi.mock( '@temporalio/activity', () => ( {
+  activityInfo: activityInfoMock
+} ) );
+
+describe( 'worker/global_functions', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    delete globalThis[ACTIVITY_LOGGER_SYMBOL];
+  } );
+
+  it( 'binds activity logger global function that emits activity log events with metadata', async () => {
+    const { bindGlobalFunctions } = await import( './global_functions.js' );
+    const metadata = { requestId: 'req-1' };
+
+    bindGlobalFunctions();
+    globalThis[ACTIVITY_LOGGER_SYMBOL]( {
+      level: 'debug',
+      message: 'activity detail',
+      metadata
+    } );
+
+    expect( activityInfoMock ).toHaveBeenCalledTimes( 1 );
+    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.ACTIVITY_LOG, {
+      level: 'debug',
+      message: 'activity detail',
+      metadata,
+      activityInfo: {
+        activityId: 'act-1',
+        activityType: 'myStep'
+      }
+    } );
+  } );
+} );

package/src/worker/index.js

@@ -17,7 +17,8 @@ import { messageBus } from '#bus';
 import { BusEventType } from '#consts';
 import { setupTelemetry } from './telemetry.js';
 import { TemporalConnectionMonitor } from './connection_monitor.js';
-import { runOnce } from '#utils';
+import { bindGlobalFunctions } from './global_functions.js';
+import { runOnce } from '#helpers/function';
 
 import './log_hooks.js';
 
@@ -76,6 +77,8 @@ const execute = async () => {
     log.info( 'Using gRPC proxy', { targetHost: grpcProxy } );
   }
 
+  bindGlobalFunctions();
+
   state.connection = await NativeConnection.connect( { address, tls: Boolean( apiKey ), apiKey, proxy } );
 
   log.info( 'Creating connection monitor...' );

package/src/worker/index.spec.js

@@ -2,6 +2,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 const {
   catalogJobInstance,
+  bindGlobalFunctionsMock,
   configValues,
   connectionMonitorInstance,
   createCatalogMock,
@@ -98,6 +99,7 @@ const {
 
   return {
     catalogJobInstance,
+    bindGlobalFunctionsMock: vi.fn(),
     configValues,
     connectionMonitorInstance,
     createCatalogMock: vi.fn().mockReturnValue( { workflows: [], activities: {} } ),
@@ -145,6 +147,7 @@ vi.mock( './interceptors/index.js', () => ( { initInterceptors: initInterceptors
 vi.mock( './proxy.js', () => ( { bootstrapFetchProxy: vi.fn() } ) );
 vi.mock( './telemetry.js', () => ( { setupTelemetry: setupTelemetryMock } ) );
 vi.mock( './interruption.js', () => ( { setupInterruptionHandler: setupInterruptionHandlerMock } ) );
+vi.mock( './global_functions.js', () => ( { bindGlobalFunctions: bindGlobalFunctionsMock } ) );
 vi.mock( './connection_monitor.js', () => ( {
   TemporalConnectionMonitor: vi.fn( function () {
     return connectionMonitorInstance;
@@ -222,6 +225,10 @@ describe( 'worker/index', () => {
       apiKey: undefined,
       proxy: undefined
     } );
+    expect( bindGlobalFunctionsMock ).toHaveBeenCalledTimes( 1 );
+    expect( bindGlobalFunctionsMock.mock.invocationCallOrder[0] ).toBeLessThan(
+      NativeConnection.connect.mock.invocationCallOrder[0]
+    );
     expect( TemporalConnectionMonitor ).toHaveBeenCalledWith( mockConnection );
     expect( CatalogJob ).toHaveBeenCalledWith( {
       connection: mockConnection,

package/src/worker/interceptors/activity.js

@@ -5,8 +5,8 @@ import { headersToObject } from './headers.js';
 import { ACTIVITY_WRAPPER_VERSION_FIELD, BusEventType, METADATA_ACCESS_SYMBOL } from '#consts';
 import { activityHeartbeatEnabled, activityHeartbeatIntervalMs } from '../configs.js';
 import { messageBus } from '#bus';
-import { aggregateAttributes } from '#internal_utils/aggregations';
-import { buildApplicationFailureWithDetails } from '#internal_utils/errors';
+import { aggregateAttributes } from '#helpers/aggregations';
+import { buildApplicationFailureWithDetails } from '#helpers/errors';
 
 /*
   This interceptor wraps every activity execution with cross-cutting concerns:
@@ -77,20 +77,17 @@ export class ActivityExecutionInterceptor {
 
       const output = await Storage.runWithContext( async _ => next( input ), storageContext );
 
-      messageBus.emit( BusEventType.ACTIVITY_END, { activityInfo, workflowDetails, outputActivityKind } );
+      const aggregations = state.attributes.length > 0 ? aggregateAttributes( state.attributes ) : null;
+
+      messageBus.emit( BusEventType.ACTIVITY_END, { activityInfo, aggregations, workflowDetails, outputActivityKind } );
       Tracing.addEventEnd( { id: activityId, details: output, traceInfo } );
 
-      return {
-        [ACTIVITY_WRAPPER_VERSION_FIELD]: 1,
-        output,
-        aggregations: state.attributes.length > 0 ? aggregateAttributes( state.attributes ) : null
-      };
+      return { [ACTIVITY_WRAPPER_VERSION_FIELD]: 1, output, aggregations };
 
     } catch ( error ) {
-      messageBus.emit( BusEventType.ACTIVITY_ERROR, { activityInfo, workflowDetails, outputActivityKind, error } );
-      Tracing.addEventError( { id: activityId, details: error, traceInfo } );
-
       const aggregations = state.attributes.length > 0 ? aggregateAttributes( state.attributes ) : null;
+      messageBus.emit( BusEventType.ACTIVITY_ERROR, { activityInfo, aggregations, workflowDetails, outputActivityKind, error } );
+      Tracing.addEventError( { id: activityId, details: error, traceInfo } );
 
       throw aggregations ? buildApplicationFailureWithDetails( error, { aggregations } ) : error;
     } finally {

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

@@ -100,6 +100,12 @@ const httpRequestAttribute = {
   requestId: 'req-1'
 };
 
+const httpRequestAggregations = {
+  cost: { total: 0 },
+  tokens: { total: 0 },
+  httpRequests: { total: 1 }
+};
+
 describe( 'ActivityExecutionInterceptor', () => {
   beforeEach( () => {
     vi.clearAllMocks();
@@ -136,7 +142,7 @@ describe( 'ActivityExecutionInterceptor', () => {
     );
     expect( messageBusEmitMock ).toHaveBeenCalledWith(
       BusEventType.ACTIVITY_END,
-      { activityInfo: activityInfoMock, workflowDetails: workflowDetailsMock, outputActivityKind: 'step' }
+      { activityInfo: activityInfoMock, aggregations: null, workflowDetails: workflowDetailsMock, outputActivityKind: 'step' }
     );
     expect( addEventStartMock ).toHaveBeenCalledWith( {
       id: 'act-1',
@@ -189,14 +195,16 @@ describe( 'ActivityExecutionInterceptor', () => {
 
     await expect( interceptor.execute( makeInput(), next ) ).resolves.toEqual( {
       output: { result: 'ok' },
-      aggregations: {
-        cost: { total: 0 },
-        tokens: { total: 0 },
-        httpRequests: { total: 1 }
-      },
+      aggregations: httpRequestAggregations,
       [ACTIVITY_WRAPPER_VERSION_FIELD]: 1
     } );
 
+    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_END, {
+      activityInfo: activityInfoMock,
+      aggregations: httpRequestAggregations,
+      workflowDetails: workflowDetailsMock,
+      outputActivityKind: 'step'
+    } );
   } );
 
   it( 'stores collected aggregations in ApplicationFailure details after failed execution', async () => {
@@ -215,15 +223,17 @@ describe( 'ActivityExecutionInterceptor', () => {
       message: 'step failed',
       type: 'Error',
       details: [ {
-        aggregations: {
-          cost: { total: 0 },
-          tokens: { total: 0 },
-          httpRequests: { total: 1 }
-        }
+        aggregations: httpRequestAggregations
       } ],
       cause: error
     } );
-    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, expect.objectContaining( { error } ) );
+    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, {
+      activityInfo: activityInfoMock,
+      aggregations: httpRequestAggregations,
+      workflowDetails: workflowDetailsMock,
+      outputActivityKind: 'step',
+      error
+    } );
     expect( addEventErrorMock ).toHaveBeenCalledOnce();
     expect( addEventEndMock ).not.toHaveBeenCalled();
   } );
@@ -243,13 +253,7 @@ describe( 'ActivityExecutionInterceptor', () => {
 
     expect( thrown.details ).toEqual( [
       { domain: { reason: 'bad-input' } },
-      {
-        aggregations: {
-          cost: { total: 0 },
-          tokens: { total: 0 },
-          httpRequests: { total: 1 }
-        }
-      }
+      { aggregations: httpRequestAggregations }
     ] );
   } );
 
@@ -300,13 +304,7 @@ describe( 'ActivityExecutionInterceptor', () => {
       nonRetryable: true,
       details: [
         { domain: { reason: 'bad-input' } },
-        {
-          aggregations: {
-            cost: { total: 0 },
-            tokens: { total: 0 },
-            httpRequests: { total: 1 }
-          }
-        }
+        { aggregations: httpRequestAggregations }
       ]
     } );
   } );
@@ -324,6 +322,7 @@ describe( 'ActivityExecutionInterceptor', () => {
     expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_START, expect.any( Object ) );
     expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, {
       activityInfo: activityInfoMock,
+      aggregations: null,
       workflowDetails: workflowDetailsMock,
       outputActivityKind: 'step',
       error

package/src/worker/interceptors/workflow.js

@@ -1,10 +1,10 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
 import { workflowInfo, proxySinks, ContinueAsNew, isCancellation } from '@temporalio/workflow';
 import { memoToHeaders } from './headers.js';
-import { deepMerge } from '#utils';
-import { buildApplicationFailureWithDetails } from '#internal_utils/errors';
+import { deepMerge } from '#helpers/object';
+import { buildApplicationFailureWithDetails } from '#helpers/errors';
 import { METADATA_ACCESS_SYMBOL, WorkflowSpecialOutput } from '#consts';
-import { createWorkflowDetails } from '#internal_utils/temporal_context';
+import { createWorkflowDetails } from '#helpers/temporal_context';
 
 // this is a dynamic generated file with activity configs overwrites
 import stepOptions from '../temp/__activity_options.js';

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

@@ -54,7 +54,7 @@ const memoToHeadersMock = vi.fn( memo => ( memo ? { ...memo, __asHeaders: true }
 vi.mock( './headers.js', () => ( { memoToHeaders: ( ...args ) => memoToHeadersMock( ...args ) } ) );
 
 const deepMergeMock = vi.fn( ( a, b ) => ( { ...( a || {} ), ...( b || {} ) } ) );
-vi.mock( '#utils', () => ( { deepMerge: ( ...args ) => deepMergeMock( ...args ) } ) );
+vi.mock( '#helpers/object', () => ( { deepMerge: ( ...args ) => deepMergeMock( ...args ) } ) );
 
 const stepOptionsDefault = {};
 vi.mock( '../temp/__activity_options.js', () => ( { default: stepOptionsDefault } ) );

package/src/worker/loader/matchers.js

@@ -1,5 +1,5 @@
 import { sep } from 'node:path';
-import { rxEscape } from '#utils';
+import { rxEscape } from '#helpers/string';
 
 /**
  * Creates a matcher function that based on "path", matches:

package/src/worker/log_hooks.js

@@ -47,6 +47,13 @@ messageBus.on( BusEventType.ACTIVITY_ERROR, ( { activityInfo, outputActivityKind
   } )
 );
 
+messageBus.on( BusEventType.ACTIVITY_LOG, ( { level, message, metadata, activityInfo } ) =>
+  activityLog[level]( message, {
+    ...metadata ?? {},
+    ...serializedActivityFields( activityInfo )
+  } )
+);
+
 /*
 ╔═════════════════╗
 ║ Workflow events ║
@@ -82,3 +89,10 @@ messageBus.on( BusEventType.WORKFLOW_ERROR, ( { workflowDetails, error } ) =>
     error: error.message
   } )
 );
+
+messageBus.on( BusEventType.WORKFLOW_LOG, ( { level, message, metadata, workflowDetails } ) =>
+  workflowLog[level]( message, {
+    ...metadata ?? {},
+    ...serializeWorkflowFields( workflowDetails )
+  } )
+);

package/src/worker/log_hooks.spec.js

@@ -6,8 +6,17 @@ import {
   WORKFLOW_CATALOG
 } from '#consts';
 
-const activityLogMock = vi.hoisted( () => ( { info: vi.fn(), error: vi.fn() } ) );
-const workflowLogMock = vi.hoisted( () => ( { info: vi.fn(), error: vi.fn() } ) );
+const createLoggerMock = vi.hoisted( () => () => ( {
+  error: vi.fn(),
+  warn: vi.fn(),
+  info: vi.fn(),
+  http: vi.fn(),
+  verbose: vi.fn(),
+  debug: vi.fn(),
+  silly: vi.fn()
+} ) );
+const activityLogMock = vi.hoisted( () => createLoggerMock() );
+const workflowLogMock = vi.hoisted( () => createLoggerMock() );
 const createChildLoggerMock = vi.hoisted( () =>
   vi.fn( name => ( name === 'Activity' ? activityLogMock : workflowLogMock ) )
 );
@@ -125,6 +134,44 @@ describe( 'log_hooks', () => {
 
       expect( activityLogMock.error ).not.toHaveBeenCalled();
     } );
+
+    it( 'ACTIVITY_LOG logs dynamic levels with metadata and serialized activity fields', () => {
+      onHandlers[BusEventType.ACTIVITY_LOG]( {
+        activityInfo,
+        level: 'debug',
+        message: 'activity detail',
+        metadata: {
+          custom: 'value',
+          workflowId: 'metadata-workflow-id'
+        }
+      } );
+
+      expect( activityLogMock.debug ).toHaveBeenCalledTimes( 1 );
+      expect( activityLogMock.debug ).toHaveBeenCalledWith( 'activity detail', {
+        custom: 'value',
+        activityId: 'act-1',
+        activityType: 'myWorkflow#myStep',
+        workflowId: 'wf-1',
+        workflowType: 'myWorkflow',
+        runId: 'run-1'
+      } );
+    } );
+
+    it( 'ACTIVITY_LOG accepts omitted metadata', () => {
+      onHandlers[BusEventType.ACTIVITY_LOG]( {
+        activityInfo,
+        level: 'info',
+        message: 'activity detail'
+      } );
+
+      expect( activityLogMock.info ).toHaveBeenCalledWith( 'activity detail', {
+        activityId: 'act-1',
+        activityType: 'myWorkflow#myStep',
+        workflowId: 'wf-1',
+        workflowType: 'myWorkflow',
+        runId: 'run-1'
+      } );
+    } );
   } );
 
   describe( 'workflow events', () => {
@@ -210,5 +257,39 @@ describe( 'log_hooks', () => {
 
       expect( workflowLogMock.error ).not.toHaveBeenCalled();
     } );
+
+    it( 'WORKFLOW_LOG logs dynamic levels with metadata and serialized workflow fields', () => {
+      onHandlers[BusEventType.WORKFLOW_LOG]( {
+        workflowDetails,
+        level: 'warn',
+        message: 'workflow detail',
+        metadata: {
+          custom: 'value',
+          runId: 'metadata-run-id'
+        }
+      } );
+
+      expect( workflowLogMock.warn ).toHaveBeenCalledTimes( 1 );
+      expect( workflowLogMock.warn ).toHaveBeenCalledWith( 'workflow detail', {
+        custom: 'value',
+        workflowId: 'wf-1',
+        workflowType: 'myWorkflow',
+        runId: 'run-1'
+      } );
+    } );
+
+    it( 'WORKFLOW_LOG accepts omitted metadata', () => {
+      onHandlers[BusEventType.WORKFLOW_LOG]( {
+        workflowDetails,
+        level: 'info',
+        message: 'workflow detail'
+      } );
+
+      expect( workflowLogMock.info ).toHaveBeenCalledWith( 'workflow detail', {
+        workflowId: 'wf-1',
+        workflowType: 'myWorkflow',
+        runId: 'run-1'
+      } );
+    } );
   } );
 } );

package/src/worker/sinks.js

@@ -1,7 +1,7 @@
 import { BusEventType, ComponentType } from '#consts';
 import * as Tracing from '#tracing';
 import { messageBus } from '#bus';
-import { createWorkflowDetails } from '#internal_utils/temporal_context';
+import { createWorkflowDetails } from '#helpers/temporal_context';
 
 // This sink allow for sandbox Temporal environment to send trace logs back to the main thread.
 export const sinks = {
@@ -10,6 +10,12 @@ export const sinks = {
    * Workflow lifecycle sinks
    */
   workflow: {
+    log: {
+      fn: ( workflowInfo, { level, message, metadata } ) => {
+        messageBus.emit( BusEventType.WORKFLOW_LOG, { level, message, metadata, workflowDetails: createWorkflowDetails( workflowInfo ) } );
+      },
+      callDuringReplay: false
+    },
     start: {
       fn: ( workflowInfo, input ) => {
         const { runId, workflowType, memo: { traceInfo }, parent } = workflowInfo;