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

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

@@ -7,7 +7,7 @@ import { JsonStreamStringify } from 'json-stream-stringify';
 
 const log = createChildLogger( 'S3 Processor' );
 
-const createRedisKey = ( { workflowId, workflowName } ) => `traces/${workflowName}/${workflowId}`;
+const createRedisKey = runId => `traces/${runId}`;
 
 /**
  * Add new entry to list of entries
@@ -44,17 +44,14 @@ const bustEntries = async key => {
 
 /**
  * Return the S3 key for the trace file
- * @param {object} args
- * @param {number} args.startTime
- * @param {string} args.workflowId
- * @param {string} args.workflowName
+ * @param {object} traceInfo
  * @returns
  */
-const getS3Key = ( { startTime, workflowId, workflowName } ) => {
+const getS3Key = ( { startTime, workflowId, workflowType } ) => {
   const isoDate = new Date( startTime ).toISOString();
   const [ year, month, day ] = isoDate.split( /\D/, 3 );
   const timeStamp = isoDate.replace( /[:T.]/g, '-' );
-  return `${workflowName}/${year}/${month}/${day}/${timeStamp}_${workflowId}.json`;
+  return `${workflowType}/${year}/${month}/${day}/${timeStamp}_${workflowId}.json`;
 };
 
 /**
@@ -70,19 +67,19 @@ export const init = async () => {
  *
  * Appends each trace entry to Redis.
  *
- * When the root workflow ends or the entry is an error action, it builds the trace tree and uploads it to S3.
+ * When the root workflow finishes or errors, builds the trace tree and uploads it to S3.
  *
  * @param {object} args
  * @param {object} args.entry - The trace entry to append
- * @param {object} args.executionContext - Execution info: workflowId, workflowName, startTime
+ * @param {object} args.traceInfo - Trace information object
  */
-export const exec = async ( { entry, executionContext } ) => {
-  const { workflowName, workflowId, startTime } = executionContext;
-  const cacheKey = createRedisKey( { workflowId, workflowName } );
+export const exec = async ( { entry, traceInfo } ) => {
+  const { workflowId, runId } = traceInfo;
+  const cacheKey = createRedisKey( runId );
 
   await addEntry( entry, cacheKey );
 
-  const isRootWorkflowEnd = entry.id === workflowId && entry.action !== 'start';
+  const isRootWorkflowEnd = entry.id === runId && entry.action !== 'start';
   if ( !isRootWorkflowEnd ) {
     return;
   }
@@ -100,20 +97,13 @@ export const exec = async ( { entry, executionContext } ) => {
     return;
   }
 
-  await upload( {
-    key: getS3Key( { workflowId, workflowName, startTime } ),
-    content: new JsonStreamStringify( content )
-  } );
+  await upload( { key: getS3Key( traceInfo ), content: new JsonStreamStringify( content ) } );
   await bustEntries( cacheKey );
 };
 
 /**
  * Returns where the trace is saved
- * @param {object} executionContext
- * @param {string} executionContext.startTime - The start time of the workflow
- * @param {string} executionContext.workflowId - The id of the workflow execution
- * @param {string} executionContext.workflowName - The name of the workflow
+ * @param {object} traceInfo - Trace information object
  * @returns {string} The S3 url of the trace file
  */
-export const getDestination = ( { startTime, workflowId, workflowName } ) =>
-  `https://${getVars().remoteS3Bucket}.s3.amazonaws.com/${getS3Key( { workflowId, workflowName, startTime } )}`;
+export const getDestination = traceInfo => `https://${getVars().remoteS3Bucket}.s3.amazonaws.com/${getS3Key( traceInfo )}`;

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

@@ -53,6 +53,14 @@ const streamToString = async stream => {
 };
 
 describe( 'tracing/processors/s3', () => {
+  const startTime = Date.parse( '2020-01-02T03:04:05.678Z' );
+  const traceInfo = {
+    workflowId: 'id1',
+    runId: 'run-1',
+    workflowType: 'WF',
+    startTime
+  };
+
   beforeEach( () => {
     vi.useFakeTimers();
     vi.clearAllMocks();
@@ -72,24 +80,30 @@ describe( 'tracing/processors/s3', () => {
 
   it( 'exec(): accumulates via redis, uploads only on root workflow end', 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( [] );
 
-    const workflowStart = { id: 'id1', name: 'WF', kind: 'workflow', action: 'start', details: {}, timestamp: startTime };
-    const activityStart = { id: 'act-1', name: 'DoSomething', kind: 'step', parentId: 'id1', action: 'start', details: {}, timestamp: startTime + 1 };
-    const workflowEnd = { id: 'id1', action: 'end', details: { ok: true }, timestamp: startTime + 2 };
+    const workflowStart = { id: 'run-1', name: 'WF', kind: 'workflow', action: 'start', details: {}, timestamp: startTime };
+    const activityStart = {
+      id: 'act-1',
+      name: 'DoSomething',
+      kind: 'step',
+      parentId: 'run-1',
+      action: 'start',
+      details: {},
+      timestamp: startTime + 1
+    };
+    const workflowEnd = { id: 'run-1', action: 'end', details: { ok: true }, timestamp: startTime + 2 };
     zRangeMock.mockResolvedValue( [
       JSON.stringify( workflowStart ),
       JSON.stringify( activityStart ),
       JSON.stringify( workflowEnd )
     ] );
 
-    await exec( { ...ctx, entry: workflowStart } );
-    await exec( { ...ctx, entry: activityStart } );
-    // Root end: id matches workflowId and not start — triggers the 10s delay before upload
-    const endPromise = exec( { ...ctx, entry: workflowEnd } );
+    await exec( { traceInfo, entry: workflowStart } );
+    await exec( { traceInfo, entry: activityStart } );
+    // Root end: id matches runId and not start — triggers the 10s delay before upload
+    const endPromise = exec( { traceInfo, entry: workflowEnd } );
     await vi.advanceTimersByTimeAsync( 10_000 );
     await endPromise;
 
@@ -101,14 +115,13 @@ describe( 'tracing/processors/s3', () => {
     expect( key ).toMatch( /^WF\/2020\/01\/02\// );
     expect( JSON.parse( await streamToString( content ) ).count ).toBe( 3 );
     expect( delMock ).toHaveBeenCalledTimes( 1 );
-    expect( delMock ).toHaveBeenCalledWith( 'traces/WF/id1' );
+    expect( delMock ).toHaveBeenCalledWith( 'traces/run-1' );
   } );
 
   it( 'getDestination(): returns S3 URL using bucket and key from getVars', async () => {
     getVarsMock.mockReturnValue( { remoteS3Bucket: 'my-bucket', redisIncompleteWorkflowsTTL: 3600, traceUploadDelayMs: 10_000 } );
     const { getDestination } = await import( './index.js' );
-    const startTime = Date.parse( '2020-01-02T03:04:05.678Z' );
-    const url = getDestination( { workflowId: 'id1', workflowName: 'WF', startTime } );
+    const url = getDestination( traceInfo );
     expect( getVarsMock ).toHaveBeenCalled();
     expect( url ).toBe(
       'https://my-bucket.s3.amazonaws.com/WF/2020/01/02/2020-01-02-03-04-05-678Z_id1.json'
@@ -117,36 +130,32 @@ 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( [] );
     const workflowStart = {
-      kind: 'workflow', id: 'id1', name: 'WF', parentId: undefined, action: 'start', details: {}, timestamp: startTime
+      kind: 'workflow', id: 'run-1', name: 'WF', parentId: undefined, action: 'start', details: {}, timestamp: startTime
     };
     zRangeMock.mockResolvedValue( [ JSON.stringify( workflowStart ) ] );
 
-    await exec( { ...ctx, entry: workflowStart } );
+    await exec( { traceInfo, entry: workflowStart } );
 
     expect( redisMulti.expire ).toHaveBeenCalledTimes( 1 );
-    expect( redisMulti.expire ).toHaveBeenCalledWith( 'traces/WF/id1', 3600 );
+    expect( redisMulti.expire ).toHaveBeenCalledWith( 'traces/run-1', 3600 );
   } );
 
   it( 'exec(): does not treat a non-root end (e.g. step without parentId) as root workflow end — regression for wrong root detection', 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( [] );
-    const workflowStart = { id: 'id1', name: 'WF', kind: 'workflow', action: 'start', details: {}, timestamp: startTime };
+    const workflowStart = { id: 'run-1', name: 'WF', kind: 'workflow', action: 'start', details: {}, timestamp: startTime };
     const stepEndNoParent = { id: 'step-1', action: 'end', details: { done: true }, timestamp: startTime + 1 };
     zRangeMock.mockResolvedValue( [
       JSON.stringify( workflowStart ),
       JSON.stringify( stepEndNoParent )
     ] );
 
-    await exec( { ...ctx, entry: workflowStart } );
-    await exec( { ...ctx, entry: stepEndNoParent } );
+    await exec( { traceInfo, entry: workflowStart } );
+    await exec( { traceInfo, entry: stepEndNoParent } );
 
     expect( redisMulti.zAdd ).toHaveBeenCalledTimes( 2 );
     expect( buildTraceTreeMock ).not.toHaveBeenCalled();
@@ -156,17 +165,15 @@ describe( 'tracing/processors/s3', () => {
 
   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' );
-    const ctx = { executionContext: { workflowId: 'id1', workflowName: 'WF', startTime } };
 
     redisMulti.exec.mockResolvedValue( [] );
     const workflowEnd = {
-      kind: 'workflow', id: 'id1', name: 'WF', parentId: undefined, action: 'end', details: {}, timestamp: startTime
+      kind: 'workflow', id: 'run-1', name: 'WF', parentId: undefined, action: 'end', details: {}, timestamp: startTime
     };
     zRangeMock.mockResolvedValue( [ JSON.stringify( workflowEnd ) ] );
     buildTraceTreeMock.mockReturnValueOnce( null );
 
-    const endPromise = exec( { ...ctx, entry: workflowEnd } );
+    const endPromise = exec( { traceInfo, entry: workflowEnd } );
     await vi.advanceTimersByTimeAsync( 10_000 );
     await endPromise;
 

package/src/tracing/trace_attribute.js

@@ -4,7 +4,6 @@ import Decimal from 'decimal.js';
  * All attributes inherit from this
  */
 export class BaseAttribute {
-  date = Date.now();
   type;
 
   constructor( type ) {

package/src/tracing/trace_engine.js

@@ -32,16 +32,12 @@ const processors = [
 /**
  * Returns the destinations for a given execution context
  *
- * @param {object} executionContext
- * @param {string} executionContext.startTime
- * @param {string} executionContext.workflowId
- * @param {string} executionContext.workflowName
- * @param {boolean} executionContext.disableTrace
+ * @param {object} traceInfo - The trace information object
  * @returns {object} A trace destinations object: { [dest-name]: 'path' }
  */
-export const getDestinations = executionContext =>
+export const getDestinations = traceInfo =>
   processors.reduce( ( o, p ) =>
-    Object.assign( o, { [p.name.toLowerCase()]: p.enabled && !executionContext.disableTrace ? p.getDestination( executionContext ) : null } )
+    Object.assign( o, { [p.name.toLowerCase()]: p.enabled && !traceInfo.disableTrace ? p.getDestination( traceInfo ) : null } )
   , {} );
 
 /**
@@ -72,11 +68,11 @@ const serializeDetails = details => details instanceof Error ? serializeError( d
  * @param {object} fields - All the trace fields
  * @returns {void}
  */
-export const addEventAction = ( action, { kind, name, id, parentId, details, executionContext } ) => {
+export const addEventAction = ( action, { kind, name, id, parentId, details, traceInfo } ) => {
   // Ignores internal steps in the actual trace files, ignore trace if the flag is true
-  if ( kind !== ComponentType.INTERNAL_STEP && !executionContext.disableTrace ) {
+  if ( kind !== ComponentType.INTERNAL_STEP && !traceInfo.disableTrace ) {
     traceBus.emit( 'entry', {
-      executionContext,
+      traceInfo,
       entry: { kind, action, name, id, parentId, timestamp: Date.now(), details: serializeDetails( details ) }
     } );
   }
@@ -93,7 +89,7 @@ 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, addAttribute } = storeContent;
+    const { parentId, traceInfo, addAttribute } = storeContent;
     if ( action === EventAction.ADD_ATTR ) {
       const attribute = options.details;
       if ( !( attribute instanceof BaseAttribute ) ) {
@@ -102,6 +98,6 @@ export function addEventActionWithContext( action, options ) {
         addAttribute( options.details );
       }
     }
-    addEventAction( action, { ...options, parentId, executionContext } );
+    addEventAction( action, { ...options, parentId, traceInfo } );
   }
 };

package/src/tracing/trace_engine.spec.js

@@ -34,6 +34,14 @@ async function loadTraceEngine() {
   return import( './trace_engine.js' );
 }
 
+const traceInfo = {
+  workflowId: 'w1',
+  runId: 'r1',
+  workflowType: 'WF',
+  startTime: 1,
+  disableTrace: false
+};
+
 describe( 'tracing/trace_engine', () => {
   beforeEach( () => {
     vi.clearAllMocks();
@@ -52,9 +60,8 @@ describe( 'tracing/trace_engine', () => {
     expect( localInitMock ).toHaveBeenCalledTimes( 1 );
     expect( s3InitMock ).not.toHaveBeenCalled();
 
-    const executionContext = { disableTrace: false };
     addEventAction( 'start', {
-      kind: 'step', name: 'N', id: '1', parentId: 'p', details: { ok: true }, executionContext
+      kind: 'step', name: 'N', id: '1', parentId: 'p', details: { ok: true }, traceInfo
     } );
     expect( localExecMock ).toHaveBeenCalledTimes( 1 );
     const payload = localExecMock.mock.calls[0][0];
@@ -62,7 +69,7 @@ describe( 'tracing/trace_engine', () => {
     expect( payload.entry.kind ).toBe( 'step' );
     expect( payload.entry.action ).toBe( 'start' );
     expect( payload.entry.details ).toEqual( { ok: true } );
-    expect( payload.executionContext ).toBe( executionContext );
+    expect( payload.traceInfo ).toBe( traceInfo );
   } );
 
   it( 'addEventAction() emits an entry consumed by processors', async () => {
@@ -72,7 +79,7 @@ describe( 'tracing/trace_engine', () => {
 
     addEventAction( 'end', {
       kind: 'workflow', name: 'W', id: '2', parentId: 'p2', details: 'done',
-      executionContext: { disableTrace: false }
+      traceInfo
     } );
     expect( localExecMock ).toHaveBeenCalledTimes( 1 );
     const payload = localExecMock.mock.calls[0][0];
@@ -81,14 +88,14 @@ describe( 'tracing/trace_engine', () => {
     expect( payload.entry.details ).toBe( 'done' );
   } );
 
-  it( 'addEventAction() does not emit when executionContext.disableTrace is true', async () => {
+  it( 'addEventAction() does not emit when traceInfo.disableTrace is true', async () => {
     process.env.OUTPUT_TRACE_LOCAL_ON = '1';
     const { init, addEventAction } = await loadTraceEngine();
     await init();
 
     addEventAction( 'start', {
       kind: 'step', name: 'X', id: '1', parentId: 'p', details: {},
-      executionContext: { disableTrace: true }
+      traceInfo: { ...traceInfo, disableTrace: true }
     } );
     expect( localExecMock ).not.toHaveBeenCalled();
   } );
@@ -100,7 +107,7 @@ describe( 'tracing/trace_engine', () => {
 
     addEventAction( 'start', {
       kind: 'internal_step', name: 'Internal', id: '1', parentId: 'p', details: {},
-      executionContext: { disableTrace: false }
+      traceInfo
     } );
     expect( localExecMock ).not.toHaveBeenCalled();
   } );
@@ -109,7 +116,7 @@ describe( 'tracing/trace_engine', () => {
     process.env.OUTPUT_TRACE_LOCAL_ON = 'true';
     storageLoadMock.mockReturnValue( {
       parentId: 'ctx-p',
-      executionContext: { runId: 'r1', disableTrace: false }
+      traceInfo
     } );
     const { init, addEventActionWithContext } = await loadTraceEngine();
     await init();
@@ -117,7 +124,7 @@ describe( 'tracing/trace_engine', () => {
     addEventActionWithContext( 'tick', { kind: 'step', name: 'S', id: '3', details: 1 } );
     expect( localExecMock ).toHaveBeenCalledTimes( 1 );
     const payload = localExecMock.mock.calls[0][0];
-    expect( payload.executionContext ).toEqual( { runId: 'r1', disableTrace: false } );
+    expect( payload.traceInfo ).toBe( traceInfo );
     expect( payload.entry.parentId ).toBe( 'ctx-p' );
     expect( payload.entry.name ).toBe( 'S' );
     expect( payload.entry.action ).toBe( 'tick' );
@@ -126,10 +133,9 @@ describe( 'tracing/trace_engine', () => {
   it( 'addEventActionWithContext() records ADD_ATTR attributes through storage context', async () => {
     process.env.OUTPUT_TRACE_LOCAL_ON = 'true';
     const addAttributeMock = vi.fn();
-    const executionContext = { runId: 'r1', disableTrace: false };
     storageLoadMock.mockReturnValue( {
       parentId: 'ctx-p',
-      executionContext,
+      traceInfo,
       addAttribute: addAttributeMock
     } );
     const { init, addEventActionWithContext } = await loadTraceEngine();
@@ -144,7 +150,7 @@ describe( 'tracing/trace_engine', () => {
     expect( addAttributeMock ).toHaveBeenCalledWith( attribute );
     expect( localExecMock ).toHaveBeenCalledTimes( 1 );
     expect( localExecMock.mock.calls[0][0] ).toEqual( {
-      executionContext,
+      traceInfo,
       entry: {
         kind: 'http',
         action: EventAction.ADD_ATTR,
@@ -162,7 +168,7 @@ describe( 'tracing/trace_engine', () => {
     const addAttributeMock = vi.fn();
     storageLoadMock.mockReturnValue( {
       parentId: 'ctx-p',
-      executionContext: { runId: 'r1', disableTrace: false },
+      traceInfo,
       addAttribute: addAttributeMock
     } );
     const { init, addEventActionWithContext } = await loadTraceEngine();
@@ -179,11 +185,11 @@ describe( 'tracing/trace_engine', () => {
     expect( localExecMock ).not.toHaveBeenCalled();
   } );
 
-  it( 'addEventActionWithContext() does not emit when storage executionContext.disableTrace is true', async () => {
+  it( 'addEventActionWithContext() does not emit when storage traceInfo.disableTrace is true', async () => {
     process.env.OUTPUT_TRACE_LOCAL_ON = '1';
     storageLoadMock.mockReturnValue( {
       parentId: 'ctx-p',
-      executionContext: { runId: 'r1', disableTrace: true }
+      traceInfo: { ...traceInfo, disableTrace: true }
     } );
     const { init, addEventActionWithContext } = await loadTraceEngine();
     await init();
@@ -203,21 +209,19 @@ describe( 'tracing/trace_engine', () => {
   } );
 
   describe( 'getDestinations()', () => {
-    const executionContext = { workflowId: 'w1', workflowName: 'WF', startTime: 1, disableTrace: false };
-
     it( 'returns null for both when traces are off (env vars unset)', async () => {
       const { getDestinations } = await loadTraceEngine();
-      const result = getDestinations( executionContext );
+      const result = getDestinations( traceInfo );
       expect( result ).toEqual( { local: null, remote: null } );
       expect( localGetDestinationMock ).not.toHaveBeenCalled();
       expect( s3GetDestinationMock ).not.toHaveBeenCalled();
     } );
 
-    it( 'returns null for both when executionContext.disableTrace is true', async () => {
+    it( 'returns null for both when traceInfo.disableTrace is true', async () => {
       process.env.OUTPUT_TRACE_LOCAL_ON = '1';
       process.env.OUTPUT_TRACE_REMOTE_ON = '1';
       const { getDestinations } = await loadTraceEngine();
-      const result = getDestinations( { ...executionContext, disableTrace: true } );
+      const result = getDestinations( { ...traceInfo, disableTrace: true } );
       expect( result ).toEqual( { local: null, remote: null } );
       expect( localGetDestinationMock ).not.toHaveBeenCalled();
       expect( s3GetDestinationMock ).not.toHaveBeenCalled();
@@ -227,24 +231,24 @@ describe( 'tracing/trace_engine', () => {
       process.env.OUTPUT_TRACE_LOCAL_ON = '1';
       process.env.OUTPUT_TRACE_REMOTE_ON = 'true';
       const { getDestinations } = await loadTraceEngine();
-      const result = getDestinations( executionContext );
+      const result = getDestinations( traceInfo );
       expect( result ).toEqual( {
         local: '/local/path.json',
         remote: 'https://bucket.s3.amazonaws.com/key.json'
       } );
       expect( localGetDestinationMock ).toHaveBeenCalledTimes( 1 );
-      expect( localGetDestinationMock ).toHaveBeenCalledWith( executionContext );
+      expect( localGetDestinationMock ).toHaveBeenCalledWith( traceInfo );
       expect( s3GetDestinationMock ).toHaveBeenCalledTimes( 1 );
-      expect( s3GetDestinationMock ).toHaveBeenCalledWith( executionContext );
+      expect( s3GetDestinationMock ).toHaveBeenCalledWith( traceInfo );
     } );
 
     it( 'returns local only when local trace on and remote off', async () => {
       process.env.OUTPUT_TRACE_LOCAL_ON = '1';
       process.env.OUTPUT_TRACE_REMOTE_ON = '0';
       const { getDestinations } = await loadTraceEngine();
-      const result = getDestinations( executionContext );
+      const result = getDestinations( traceInfo );
       expect( result ).toEqual( { local: '/local/path.json', remote: null } );
-      expect( localGetDestinationMock ).toHaveBeenCalledWith( executionContext );
+      expect( localGetDestinationMock ).toHaveBeenCalledWith( traceInfo );
       expect( s3GetDestinationMock ).not.toHaveBeenCalled();
     } );
 
@@ -252,10 +256,10 @@ describe( 'tracing/trace_engine', () => {
       process.env.OUTPUT_TRACE_LOCAL_ON = '0';
       process.env.OUTPUT_TRACE_REMOTE_ON = 'true';
       const { getDestinations } = await loadTraceEngine();
-      const result = getDestinations( executionContext );
+      const result = getDestinations( traceInfo );
       expect( result ).toEqual( { local: null, remote: 'https://bucket.s3.amazonaws.com/key.json' } );
       expect( localGetDestinationMock ).not.toHaveBeenCalled();
-      expect( s3GetDestinationMock ).toHaveBeenCalledWith( executionContext );
+      expect( s3GetDestinationMock ).toHaveBeenCalledWith( traceInfo );
     } );
   } );
 } );

package/src/worker/configs.js

@@ -7,6 +7,7 @@ const coalesceEmptyString = v => v === '' ? undefined : v;
 
 const envVarSchema = z.object( {
   OUTPUT_CATALOG_ID: z.string().regex( /^[a-z0-9_.@-]+$/i ),
+  OUTPUT_WORKER_TELEMETRY_INTERVAL_MS: z.preprocess( coalesceEmptyString, z.coerce.number().int().nonnegative().default( 0 ) ),
   TEMPORAL_ADDRESS: z.string().default( 'localhost:7233' ),
   TEMPORAL_API_KEY: z.string().optional(),
   TEMPORAL_NAMESPACE: z.string().optional().default( 'default' ),
@@ -51,6 +52,7 @@ export const maxConcurrentWorkflowTaskPolls = envVars.TEMPORAL_MAX_CONCURRENT_WO
 export const namespace = envVars.TEMPORAL_NAMESPACE;
 export const taskQueue = envVars.OUTPUT_CATALOG_ID;
 export const catalogId = envVars.OUTPUT_CATALOG_ID;
+export const workerTelemetryIntervalMs = envVars.OUTPUT_WORKER_TELEMETRY_INTERVAL_MS;
 export const activityHeartbeatIntervalMs = envVars.OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS;
 export const activityHeartbeatEnabled = envVars.OUTPUT_ACTIVITY_HEARTBEAT_ENABLED;
 export const processFailureShutdownDelay = envVars.OUTPUT_PROCESS_FAILURE_SHUTDOWN_DELAY;

package/src/worker/configs.spec.js

@@ -10,6 +10,7 @@ const CONFIG_KEYS = [
   'TEMPORAL_MAX_CACHED_WORKFLOWS',
   'TEMPORAL_MAX_CONCURRENT_ACTIVITY_TASK_POLLS',
   'TEMPORAL_MAX_CONCURRENT_WORKFLOW_TASK_POLLS',
+  'OUTPUT_WORKER_TELEMETRY_INTERVAL_MS',
   'OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS',
   'OUTPUT_ACTIVITY_HEARTBEAT_ENABLED'
 ];
@@ -61,6 +62,7 @@ describe( 'worker/configs', () => {
     expect( configs.maxCachedWorkflows ).toBe( 1000 );
     expect( configs.maxConcurrentActivityTaskPolls ).toBe( 5 );
     expect( configs.maxConcurrentWorkflowTaskPolls ).toBe( 5 );
+    expect( configs.workerTelemetryIntervalMs ).toBe( 0 );
     expect( configs.activityHeartbeatIntervalMs ).toBe( 2 * 60 * 1000 );
     expect( configs.activityHeartbeatEnabled ).toBe( true );
     expect( configs.taskQueue ).toBe( 'test-catalog' );
@@ -74,11 +76,19 @@ describe( 'worker/configs', () => {
     expect( configs.maxConcurrentActivityTaskExecutions ).toBe( 40 );
   } );
 
+  it( 'treats empty string for worker telemetry interval as default', async () => {
+    setEnv( { OUTPUT_WORKER_TELEMETRY_INTERVAL_MS: '' } );
+    const configs = await loadConfigs();
+
+    expect( configs.workerTelemetryIntervalMs ).toBe( 0 );
+  } );
+
   it( 'parses custom numeric env vars', async () => {
     setEnv( {
       TEMPORAL_MAX_CONCURRENT_ACTIVITY_TASK_EXECUTIONS: '10',
       TEMPORAL_MAX_CONCURRENT_WORKFLOW_TASK_EXECUTIONS: '50',
       TEMPORAL_MAX_CACHED_WORKFLOWS: '500',
+      OUTPUT_WORKER_TELEMETRY_INTERVAL_MS: '30000',
       OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS: '60000'
     } );
     const configs = await loadConfigs();
@@ -86,9 +96,24 @@ describe( 'worker/configs', () => {
     expect( configs.maxConcurrentActivityTaskExecutions ).toBe( 10 );
     expect( configs.maxConcurrentWorkflowTaskExecutions ).toBe( 50 );
     expect( configs.maxCachedWorkflows ).toBe( 500 );
+    expect( configs.workerTelemetryIntervalMs ).toBe( 30000 );
     expect( configs.activityHeartbeatIntervalMs ).toBe( 60000 );
   } );
 
+  it( 'allows zero for worker telemetry interval', async () => {
+    setEnv( { OUTPUT_WORKER_TELEMETRY_INTERVAL_MS: '0' } );
+    const configs = await loadConfigs();
+
+    expect( configs.workerTelemetryIntervalMs ).toBe( 0 );
+  } );
+
+  it( 'throws when worker telemetry interval is negative', async () => {
+    setEnv( { OUTPUT_WORKER_TELEMETRY_INTERVAL_MS: '-1' } );
+    vi.resetModules();
+
+    await expect( import( './configs.js' ) ).rejects.toThrow();
+  } );
+
   it( 'throws when optional number is zero or negative', async () => {
     setEnv( { TEMPORAL_MAX_CONCURRENT_ACTIVITY_TASK_EXECUTIONS: '0' } );
     vi.resetModules();

package/src/worker/index.js

@@ -11,9 +11,10 @@ import { registerShutdown } from './shutdown.js';
 import { startCatalog } from './start_catalog.js';
 import { bootstrapFetchProxy } from './proxy.js';
 import { messageBus } from '#bus';
-import './log_hooks.js';
 import { BusEventType } from '#consts';
 import { hashSourceCode } from './loader_tools.js';
+import { setupTelemetry } from './setup_telemetry.js';
+import './log_hooks.js';
 
 const log = createChildLogger( 'Worker' );
 
@@ -84,6 +85,8 @@ const callerDir = process.argv[2];
 
   registerShutdown( { worker, log } );
 
+  setupTelemetry( { worker } );
+
   log.info( 'Running worker...' );
   await Promise.all( [ worker.run(), startCatalog( { connection, namespace, catalog, catalogHash } ) ] );
 

package/src/worker/index.spec.js

@@ -62,6 +62,9 @@ vi.mock( './proxy.js', () => ( { bootstrapFetchProxy: bootstrapFetchProxyMock }
 const registerShutdownMock = vi.fn();
 vi.mock( './shutdown.js', () => ( { registerShutdown: registerShutdownMock } ) );
 
+const setupTelemetryMock = vi.fn();
+vi.mock( './setup_telemetry.js', () => ( { setupTelemetry: setupTelemetryMock } ) );
+
 vi.mock( './log_hooks.js', () => ( {} ) );
 
 const runState = { resolve: null };
@@ -129,6 +132,7 @@ describe( 'worker/index', () => {
     } ) );
     expect( initInterceptorsMock ).toHaveBeenCalledWith( { activities: {}, workflows: [], connection: mockConnection } );
     expect( registerShutdownMock ).toHaveBeenCalledWith( { worker: mockWorker, log: mockLog } );
+    expect( setupTelemetryMock ).toHaveBeenCalledWith( { worker: mockWorker } );
     expect( startCatalogMock ).toHaveBeenCalledWith( {
       connection: mockConnection,
       namespace: configValues.namespace,