@outputai/core 0.4.1-dev.92bc2fb.0 → 0.4.1-dev.ae4bd16.0

package/src/tracing/tools/build_trace_tree.spec.js

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { EventAction } from '../trace_consts.js';
+import { Attribute } from '#trace_attribute';
 import buildTraceTree from './build_trace_tree.js';
 
 describe( 'build_trace_tree', () => {
@@ -26,34 +27,66 @@ this can indicate it timed out or was interrupted.>>' );
     expect( buildTraceTree( entries ) ).toBeNull();
   } );
 
-  it( 'add_attr action merges details.name and details.value into node.attributes', () => {
+  it( 'add_attr action stores attribute details by type on node.attributes', () => {
+    const requestCount = {
+      type: Attribute.HTTPRequestCount.TYPE,
+      url: 'https://api.example.test',
+      requestId: 'req-1'
+    };
+    const requestCost = {
+      type: Attribute.HTTPRequestCost.TYPE,
+      url: 'https://api.example.test',
+      requestId: 'req-1',
+      total: 0.2
+    };
     const entries = [
       { kind: 'workflow', id: 'wf', parentId: undefined, action: EventAction.START, name: 'wf', details: {}, timestamp: 100 },
       { kind: 'step', id: 's', parentId: 'wf', action: EventAction.START, name: 'step', details: {}, timestamp: 200 },
-      { id: 's', action: EventAction.ADD_ATTR, details: { name: 'latency_ms', value: 42 }, timestamp: 250 },
-      { id: 's', action: EventAction.ADD_ATTR, details: { name: 'retries', value: 1 }, timestamp: 260 },
+      { id: 's', action: EventAction.ADD_ATTR, details: requestCount, timestamp: 250 },
+      { id: 's', action: EventAction.ADD_ATTR, details: requestCost, timestamp: 260 },
       { id: 'wf', action: EventAction.END, details: {}, timestamp: 300 }
     ];
     const result = buildTraceTree( entries );
     expect( result ).not.toBeNull();
-    expect( result.children[0].attributes ).toEqual( { latency_ms: 42, retries: 1 } );
+    expect( result.children[0].attributes ).toEqual( {
+      [Attribute.HTTPRequestCount.TYPE]: requestCount,
+      [Attribute.HTTPRequestCost.TYPE]: requestCost
+    } );
   } );
 
-  it( 'add_attr action overwrites prior value for the same attribute name', () => {
+  it( 'add_attr action overwrites prior value for the same attribute type', () => {
+    const firstCost = {
+      type: Attribute.HTTPRequestCost.TYPE,
+      url: 'https://api.example.test',
+      requestId: 'req-1',
+      total: 1
+    };
+    const secondCost = {
+      type: Attribute.HTTPRequestCost.TYPE,
+      url: 'https://api.example.test',
+      requestId: 'req-1',
+      total: 2
+    };
     const entries = [
       { kind: 'workflow', id: 'wf', parentId: undefined, action: EventAction.START, name: 'wf', details: {}, timestamp: 1 },
-      { id: 'wf', action: EventAction.ADD_ATTR, details: { name: 'x', value: 1 }, timestamp: 2 },
-      { id: 'wf', action: EventAction.ADD_ATTR, details: { name: 'x', value: 2 }, timestamp: 3 },
+      { id: 'wf', action: EventAction.ADD_ATTR, details: firstCost, timestamp: 2 },
+      { id: 'wf', action: EventAction.ADD_ATTR, details: secondCost, timestamp: 3 },
       { id: 'wf', action: EventAction.END, details: {}, timestamp: 4 }
     ];
     const result = buildTraceTree( entries );
-    expect( result.attributes ).toEqual( { x: 2 } );
+    expect( result.attributes ).toEqual( { [Attribute.HTTPRequestCost.TYPE]: secondCost } );
   } );
 
   it( 'add_attr does not attach nodes as children (only start does)', () => {
     const entries = [
       { kind: 'workflow', id: 'wf', parentId: undefined, action: EventAction.START, name: 'wf', details: {}, timestamp: 1 },
-      { id: 'orphan', parentId: 'wf', action: EventAction.ADD_ATTR, details: { name: 'k', value: 'v' }, timestamp: 2 },
+      {
+        id: 'orphan',
+        parentId: 'wf',
+        action: EventAction.ADD_ATTR,
+        details: { type: Attribute.HTTPRequestCount.TYPE, url: 'https://api.example.test', requestId: 'req-1' },
+        timestamp: 2
+      },
       { id: 'wf', action: EventAction.END, details: {}, timestamp: 3 }
     ];
     const result = buildTraceTree( entries );
@@ -75,6 +108,11 @@ this can indicate it timed out or was interrupted.>>' );
   } );
 
   it( 'builds a tree from workflow/step/IO entries with grouping and sorting', () => {
+    const stepAttribute = {
+      type: Attribute.HTTPRequestCount.TYPE,
+      url: 'https://api.example.test/step-1',
+      requestId: 'req-step-1'
+    };
     const entries = [
       // workflow start
       { kind: 'workflow', action: EventAction.START, name: 'wf', id: 'wf', parentId: undefined, details: { a: 1 }, timestamp: 1000 },
@@ -83,7 +121,7 @@ this can indicate it timed out or was interrupted.>>' );
       { id: 'eval', action: EventAction.END, details: { z: 1 }, timestamp: 1600 },
       // step1 start
       { kind: 'step', action: EventAction.START, name: 'step-1', id: 's1', parentId: 'wf', details: { x: 1 }, timestamp: 2000 },
-      { id: 's1', action: EventAction.ADD_ATTR, details: { name: 'step_tag', value: 'alpha' }, timestamp: 2050 },
+      { id: 's1', action: EventAction.ADD_ATTR, details: stepAttribute, timestamp: 2050 },
       // IO under step1
       { kind: 'IO', action: EventAction.START, name: 'test-1', id: 'io1', parentId: 's1', details: { y: 2 }, timestamp: 2300 },
       // step2 start
@@ -132,7 +170,7 @@ this can indicate it timed out or was interrupted.>>' );
           endedAt: 2800,
           input: { x: 1 },
           output: { done: true },
-          attributes: { step_tag: 'alpha' },
+          attributes: { [Attribute.HTTPRequestCount.TYPE]: stepAttribute },
           children: [
             {
               id: 'io1',

package/src/tracing/tools/utils.js

@@ -19,31 +19,3 @@ export const serializeError = error =>
     message: error.message,
     stack: error.stack
   };
-
-/**
- * Tries to stringify an object to an indented JSON string.
- * If its byte size is bigger than threshold returns a plain JSON string without formatting.
- *
- * @param {object|array} content
- * @param {*} [threshold] - The max allowed size to try to stringify with formatting (in bytes). Default is 50mb
- * @returns {string} String representation of the object
- */
-export const safeFormatJSON = ( content, threshold = 50 * 1024 * 1024 /* 50mb */ ) => {
-  const plainString = JSON.stringify( content );
-  const plainStringSize = Buffer.byteLength( plainString, 'utf8' );
-
-  if ( plainStringSize > threshold ) {
-    return plainString;
-  }
-  try {
-    return JSON.stringify( content, undefined, 2 );
-  } catch ( error ) {
-    // Only handles this specific error because other common parsing errors like:
-    // "TypeError: cyclic object value" and "RangeError: Maximum call stack size exceeded"
-    // would have been thrown on the first parsing.
-    if ( error instanceof RangeError && error.message === 'Invalid string length' ) {
-      return plainString;
-    }
-    throw error;
-  }
-};

package/src/tracing/tools/utils.spec.js

@@ -1,15 +1,5 @@
-import { describe, it, expect, vi } from 'vitest';
-import { safeFormatJSON, serializeError } from './utils.js';
-
-const isPrettyStringifyCall = args => args.length >= 3 && args[2] === 2;
-
-/** @param {number} targetBytes UTF-8 size of compact JSON.stringify( { a: "<xs>" } ) */
-const objectWithCompactByteLength = targetBytes => {
-  const sample = { a: '' };
-  const overhead = Buffer.byteLength( JSON.stringify( sample ), 'utf8' );
-  const repeat = Math.max( 0, targetBytes - overhead );
-  return { a: 'x'.repeat( repeat ) };
-};
+import { describe, it, expect } from 'vitest';
+import { serializeError } from './utils.js';
 
 describe( 'tracing/utils', () => {
   it( 'serializeError unwraps causes and keeps message/stack', () => {
@@ -21,126 +11,4 @@ describe( 'tracing/utils', () => {
     expect( out.message ).toBe( 'inner' );
     expect( typeof out.stack ).toBe( 'string' );
   } );
-
-  describe( 'safeFormatJSON', () => {
-    it( 'formats small objects with indentation when under threshold', () => {
-      const content = { a: 1, b: [ 2, 3 ] };
-      const out = safeFormatJSON( content, 10_000 );
-
-      expect( out ).toContain( '\n' );
-      expect( out ).toMatch( /^\{\n/ );
-      expect( JSON.parse( out ) ).toEqual( content );
-    } );
-
-    it( 'formats small arrays with indentation when under threshold', () => {
-      const content = [ 1, { nested: true } ];
-      const out = safeFormatJSON( content, 10_000 );
-
-      expect( out ).toContain( '\n' );
-      expect( out.trimStart() ).toMatch( /^\[/ );
-      expect( JSON.parse( out ) ).toEqual( content );
-    } );
-
-    it( 'returns compact JSON when compact UTF-8 size is strictly greater than threshold', () => {
-      const content = objectWithCompactByteLength( 40 );
-      const compact = JSON.stringify( content );
-      expect( Buffer.byteLength( compact, 'utf8' ) ).toBe( 40 );
-
-      const out = safeFormatJSON( content, 39 );
-      expect( out ).toBe( compact );
-      expect( out ).not.toContain( '\n  ' );
-      expect( JSON.parse( out ) ).toEqual( content );
-    } );
-
-    it( 'uses pretty JSON when compact UTF-8 size equals threshold', () => {
-      const content = objectWithCompactByteLength( 40 );
-      const compact = JSON.stringify( content );
-      expect( Buffer.byteLength( compact, 'utf8' ) ).toBe( 40 );
-
-      const out = safeFormatJSON( content, 40 );
-      expect( out ).not.toBe( compact );
-      expect( out ).toContain( '\n' );
-      expect( JSON.parse( out ) ).toEqual( content );
-    } );
-
-    it( 'uses UTF-8 byte length for threshold, not JavaScript string length', () => {
-      const content = { label: 'éclair' };
-      const compact = JSON.stringify( content );
-      expect( compact.length ).toBeLessThan( Buffer.byteLength( compact, 'utf8' ) );
-
-      const bytes = Buffer.byteLength( compact, 'utf8' );
-      const outCompact = safeFormatJSON( content, bytes - 1 );
-      expect( outCompact ).toBe( compact );
-
-      const outPretty = safeFormatJSON( content, bytes + 100 );
-      expect( outPretty ).toContain( '\n' );
-      expect( JSON.parse( outPretty ) ).toEqual( content );
-    } );
-
-    it( 'round-trips empty object and primitives for both branches', () => {
-      const tiny = {};
-      const pretty = safeFormatJSON( tiny, 100 );
-      expect( JSON.parse( pretty ) ).toEqual( tiny );
-
-      const forcedCompact = safeFormatJSON( tiny, 0 );
-      expect( JSON.parse( forcedCompact ) ).toEqual( tiny );
-    } );
-
-    it( 'returns compact JSON when pretty stringify throws Invalid string length', () => {
-      const content = { a: 1 };
-      const compact = JSON.stringify( content );
-      const origStringify = JSON.stringify.bind( JSON );
-
-      const spy = vi.spyOn( JSON, 'stringify' ).mockImplementation( ( ...args ) => {
-        if ( isPrettyStringifyCall( args ) ) {
-          throw new RangeError( 'Invalid string length' );
-        }
-        return origStringify( ...args );
-      } );
-
-      try {
-        const out = safeFormatJSON( content, 10_000 );
-        expect( out ).toBe( compact );
-        expect( JSON.parse( out ) ).toEqual( content );
-      } finally {
-        spy.mockRestore();
-      }
-    } );
-
-    it( 'rethrows RangeError when message is not Invalid string length', () => {
-      const content = { a: 1 };
-      const origStringify = JSON.stringify.bind( JSON );
-
-      const spy = vi.spyOn( JSON, 'stringify' ).mockImplementation( ( ...args ) => {
-        if ( isPrettyStringifyCall( args ) ) {
-          throw new RangeError( 'not the string length error' );
-        }
-        return origStringify( ...args );
-      } );
-
-      try {
-        expect( () => safeFormatJSON( content, 10_000 ) ).toThrow( RangeError );
-      } finally {
-        spy.mockRestore();
-      }
-    } );
-
-    it( 'rethrows non-RangeError from pretty stringify', () => {
-      const content = { a: 1 };
-      const origStringify = JSON.stringify.bind( JSON );
-
-      const spy = vi.spyOn( JSON, 'stringify' ).mockImplementation( ( ...args ) => {
-        if ( isPrettyStringifyCall( args ) ) {
-          throw new TypeError( 'cyclic structure' );
-        }
-        return origStringify( ...args );
-      } );
-
-      try {
-        expect( () => safeFormatJSON( content, 10_000 ) ).toThrow( TypeError );
-      } finally {
-        spy.mockRestore();
-      }
-    } );
-  } );
 } );

package/src/tracing/trace_attribute.d.ts

@@ -0,0 +1,38 @@
+export declare namespace Attribute {
+  export interface Usage {
+    type: string;
+    ppm: number;
+    amount: number;
+    total: number;
+  }
+
+  export class HTTPRequestCount {
+    static TYPE: 'http:request:count';
+    type: typeof HTTPRequestCount.TYPE;
+    url: string;
+    requestId: string;
+    constructor( url: string, requestId: string );
+  }
+
+  export class HTTPRequestCost {
+    static TYPE: 'http:request:cost';
+    type: typeof HTTPRequestCost.TYPE;
+    url: string;
+    requestId: string;
+    total: number;
+    constructor( url: string, requestId: string, total: number );
+  }
+
+  export class LLMUsage {
+    static TYPE: 'llm:usage';
+    type: typeof LLMUsage.TYPE;
+    modelId: string;
+    usage: Usage[];
+    constructor( modelId: string );
+    addUsage( usage: { type: string; ppm: number; amount: number } ): void;
+    readonly total: number;
+    readonly tokensUsed: number;
+  }
+
+  export type Instance = HTTPRequestCount | HTTPRequestCost | LLMUsage;
+}

package/src/tracing/trace_attribute.js

@@ -0,0 +1,80 @@
+import Decimal from 'decimal.js';
+
+/**
+ * All attributes inherit from this
+ */
+export class BaseAttribute {
+  activityId;
+  activityName;
+  date = Date.now();
+  type;
+
+  constructor( type ) {
+    this.type = type;
+  }
+
+  setActivity( id, name ) {
+    this.activityId = id;
+    this.activityName = name;
+  }
+}
+
+class HTTPRequestCount extends BaseAttribute {
+  static TYPE = 'http:request:count';
+  url;
+  requestId;
+
+  constructor( url, requestId ) {
+    super( HTTPRequestCount.TYPE );
+    this.url = url;
+    this.requestId = requestId;
+  }
+}
+
+class HTTPRequestCost extends BaseAttribute {
+  static TYPE = 'http:request:cost';
+  url;
+  requestId;
+  total = 0;
+
+  constructor( url, requestId, total ) {
+    super( HTTPRequestCost.TYPE );
+    this.url = url;
+    this.requestId = requestId;
+    this.total = total;
+  }
+}
+
+class LLMUsage extends BaseAttribute {
+  static TYPE = 'llm:usage';
+  modelId;
+  usage = [];
+  total = 0;
+  tokensUsed = 0;
+
+  constructor( modelId ) {
+    super( LLMUsage.TYPE );
+    this.modelId = modelId;
+  }
+
+  addUsage( { type, ppm, amount } ) {
+    const total = Decimal( amount ).div( 1_000_000 ).mul( ppm ).toNumber();
+    this.usage.push( {
+      type,
+      ppm,
+      amount,
+      total
+    } );
+    this.total = Decimal( this.total ).add( total ).toNumber();
+    this.tokensUsed = Decimal( this.tokensUsed ).add( amount ).toNumber();
+  }
+}
+
+/**
+ * Types of ADD_ATTR attributes
+ */
+export const Attribute = {
+  LLMUsage,
+  HTTPRequestCost,
+  HTTPRequestCount
+};

package/src/tracing/trace_engine.js

@@ -4,8 +4,10 @@ import { serializeError } from './tools/utils.js';
 import { isStringboolTrue } from '#utils';
 import * as localProcessor from './processors/local/index.js';
 import * as s3Processor from './processors/s3/index.js';
-import { ComponentType } from '#consts';
+import { ComponentType, Signal } from '#consts';
 import { createChildLogger } from '#logger';
+import { EventAction } from './trace_consts.js';
+import { BaseAttribute } from './trace_attribute.js';
 
 const log = createChildLogger( 'Tracing' );
 
@@ -91,7 +93,15 @@ export const addEventAction = ( action, { kind, name, id, parentId, details, exe
 export function addEventActionWithContext( action, options ) {
   const storeContent = Storage.load();
   if ( storeContent ) { // If there is no storageContext this was not called from a Temporal environment
-    const { parentId, executionContext } = storeContent;
+    const { parentId, parentName, executionContext, workflowHandle } = storeContent;
+    if ( action === EventAction.ADD_ATTR ) {
+      const attribute = options.details;
+      if ( !( attribute instanceof BaseAttribute ) ) {
+        throw new Error( `${EventAction.ADD_ATTR} called argument that is not a BaseAttribute instance` );
+      }
+      attribute.setActivity( parentId, parentName );
+      workflowHandle.signal( Signal.ADD_ATTRIBUTE, attribute );
+    }
     addEventAction( action, { ...options, parentId, executionContext } );
   }
 };

package/src/worker/index.js

@@ -69,7 +69,7 @@ const callerDir = process.argv[2];
     workflowsPath,
     activities,
     sinks,
-    interceptors: initInterceptors( { activities, workflows } ),
+    interceptors: initInterceptors( { activities, workflows, connection } ),
     maxConcurrentWorkflowTaskExecutions,
     maxConcurrentActivityTaskExecutions,
     maxCachedWorkflows,

package/src/worker/index.spec.js

@@ -123,7 +123,7 @@ describe( 'worker/index', () => {
       maxConcurrentActivityTaskPolls: configValues.maxConcurrentActivityTaskPolls,
       maxConcurrentWorkflowTaskPolls: configValues.maxConcurrentWorkflowTaskPolls
     } ) );
-    expect( initInterceptorsMock ).toHaveBeenCalledWith( { activities: {}, workflows: [] } );
+    expect( initInterceptorsMock ).toHaveBeenCalledWith( { activities: {}, workflows: [], connection: mockConnection } );
     expect( registerShutdownMock ).toHaveBeenCalledWith( { worker: mockWorker, log: mockLog } );
     expect( startCatalogMock ).toHaveBeenCalledWith( {
       connection: mockConnection,

package/src/worker/interceptors/activity.js

@@ -5,6 +5,7 @@ import { headersToObject } from '../sandboxed_utils.js';
 import { BusEventType, METADATA_ACCESS_SYMBOL } from '#consts';
 import { activityHeartbeatEnabled, activityHeartbeatIntervalMs } from '../configs.js';
 import { messageBus } from '#bus';
+import { Client } from '@temporalio/client';
 
 /*
   This interceptor wraps every activity execution with cross-cutting concerns:
@@ -23,7 +24,7 @@ import { messageBus } from '#bus';
   - Headers injected by the workflow interceptor (executionContext)
 */
 export class ActivityExecutionInterceptor {
-  constructor( { activities, workflows } ) {
+  constructor( { activities, workflows, connection } ) {
     this.activities = activities;
     this.workflowsMap = workflows.reduce( ( map, w ) => {
       map.set( w.name, w );
@@ -32,14 +33,19 @@ export class ActivityExecutionInterceptor {
       }
       return map;
     }, new Map() );
+    this.connection = connection;
   };
 
   async execute( input, next ) {
     const startDate = Date.now();
+    const client = new Client( { connection: this.connection } );
+
     const { workflowExecution: { workflowId }, activityId: id, activityType: name, workflowType: workflowName } = Context.current().info;
     const { executionContext } = headersToObject( input.headers );
     const { type: kind } = this.activities?.[name]?.[METADATA_ACCESS_SYMBOL];
 
+    const workflowHandle = client.workflow.getHandle( workflowId );
+
     messageBus.emit( BusEventType.ACTIVITY_START, { id, name, kind, workflowId, workflowName } );
     Tracing.addEventStart( { id, name, kind, parentId: workflowId, details: input.args[0], executionContext } );
 
@@ -56,7 +62,8 @@ export class ActivityExecutionInterceptor {
       intervals.heartbeat = activityHeartbeatEnabled && setInterval( () => Context.current().heartbeat(), activityHeartbeatIntervalMs );
 
       // Wraps the execution with accessible metadata for the activity
-      const output = await Storage.runWithContext( async _ => next( input ), { parentId: id, executionContext, workflowFilename } );
+      const ctx = { parentId: id, parentName: name, executionContext, workflowFilename, workflowHandle };
+      const output = await Storage.runWithContext( async _ => next( input ), ctx );
 
       messageBus.emit( BusEventType.ACTIVITY_END, { id, name, kind, workflowId, workflowName, duration: Date.now() - startDate } );
       Tracing.addEventEnd( { id, details: output, executionContext } );

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

@@ -2,6 +2,8 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { BusEventType } from '#consts';
 
 const METADATA_ACCESS_SYMBOL = vi.hoisted( () => Symbol( '__metadata' ) );
+const workflowHandleMock = vi.hoisted( () => ( { signal: vi.fn() } ) );
+const getHandleMock = vi.hoisted( () => vi.fn( () => workflowHandleMock ) );
 
 const heartbeatMock = vi.fn();
 const runWithContextMock = vi.hoisted( () => vi.fn().mockImplementation( async fn => fn() ) );
@@ -21,6 +23,14 @@ vi.mock( '@temporalio/activity', () => ( {
   }
 } ) );
 
+vi.mock( '@temporalio/client', () => ( {
+  Client: class Client {
+    workflow = {
+      getHandle: getHandleMock
+    };
+  }
+} ) );
+
 vi.mock( '#async_storage', () => ( {
   Storage: {
     runWithContext: runWithContextMock
@@ -108,12 +118,15 @@ describe( 'ActivityExecutionInterceptor', () => {
     expect( addEventErrorMock ).not.toHaveBeenCalled();
     expect( runWithContextMock ).toHaveBeenCalledWith(
       expect.any( Function ),
-      {
+      expect.objectContaining( {
         parentId: 'act-1',
+        parentName: 'myWorkflow#myStep',
         executionContext: { workflowId: 'wf-1' },
-        workflowFilename: '/workflows/myWorkflow.js'
-      }
+        workflowFilename: '/workflows/myWorkflow.js',
+        workflowHandle: workflowHandleMock
+      } )
     );
+    expect( getHandleMock ).toHaveBeenCalledWith( 'wf-1' );
   } );
 
   it( 'records trace error event on failed execution', async () => {

package/src/worker/interceptors.js

@@ -4,7 +4,7 @@ import { ActivityExecutionInterceptor } from './interceptors/activity.js';
 
 const __dirname = dirname( fileURLToPath( import.meta.url ) );
 
-export const initInterceptors = ( { activities, workflows } ) => ( {
+export const initInterceptors = ( { activities, workflows, connection } ) => ( {
   workflowModules: [ join( __dirname, './interceptors/workflow.js' ) ],
-  activityInbound: [ () => new ActivityExecutionInterceptor( { activities, workflows } ) ]
+  activityInbound: [ () => new ActivityExecutionInterceptor( { activities, workflows, connection } ) ]
 } );

package/src/worker/sinks.js

@@ -11,8 +11,8 @@ export const sinks = {
   workflow: {
     start: {
       fn: ( workflowInfo, input ) => {
-        const { workflowId: id, workflowType: name, memo: { parentId, executionContext } } = workflowInfo;
-        messageBus.emit( BusEventType.WORKFLOW_START, { id, name } );
+        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 } );
         }
@@ -22,8 +22,8 @@ export const sinks = {
 
     end: {
       fn: ( workflowInfo, output ) => {
-        const { workflowId: id, workflowType: name, startTime, memo: { executionContext } } = workflowInfo;
-        messageBus.emit( BusEventType.WORKFLOW_END, { id, name, duration: Date.now() - startTime.getTime() } );
+        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 } );
         }
@@ -33,8 +33,8 @@ export const sinks = {
 
     error: {
       fn: ( workflowInfo, error ) => {
-        const { workflowId: id, workflowType: name, startTime, memo: { executionContext } } = workflowInfo;
-        messageBus.emit( BusEventType.WORKFLOW_ERROR, { id, name, error, duration: Date.now() - startTime.getTime() } );
+        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 } );
         }