@outputai/core 0.14.0 → 0.14.1-next.2947341.0

package/src/worker/shutdown.spec.js

@@ -1,197 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { shutdownServices } from './shutdown.js';
-
-const { mockLog, serializeErrorMock } = vi.hoisted( () => ( {
-  mockLog: { info: vi.fn(), warn: vi.fn() },
-  serializeErrorMock: vi.fn( error => ( { name: error.name, message: error.message } ) )
-} ) );
-
-vi.mock( '#logger', () => ( { createChildLogger: () => mockLog } ) );
-vi.mock( '#helpers/error_serializer', () => ( { serializeError: serializeErrorMock } ) );
-
-/** Stands in for the services registry built during startup, with every service active. */
-const createServices = () => ( {
-  workerRunner: { running: true, stop: vi.fn().mockResolvedValue( undefined ) },
-  connectionMonitor: { running: true, stop: vi.fn().mockResolvedValue( undefined ) },
-  catalogPublisher: { running: true, interrupt: vi.fn().mockResolvedValue( undefined ) },
-  connection: { close: vi.fn().mockResolvedValue( undefined ) }
-} );
-
-/** The registry as it looks before startup assigns anything. */
-const createEmptyServices = () => ( {
-  workerRunner: null,
-  connectionMonitor: null,
-  catalogPublisher: null,
-  connection: null
-} );
-
-describe( 'shutdownServices', () => {
-  beforeEach( () => {
-    vi.clearAllMocks();
-  } );
-
-  it( 'stops every active service, worker first and connection last', async () => {
-    const services = createServices();
-
-    await shutdownServices( services );
-
-    expect( services.workerRunner.stop ).toHaveBeenCalledOnce();
-    expect( services.connectionMonitor.stop ).toHaveBeenCalledOnce();
-    expect( services.catalogPublisher.interrupt ).toHaveBeenCalledOnce();
-    expect( services.connection.close ).toHaveBeenCalledOnce();
-
-    expect( services.workerRunner.stop.mock.invocationCallOrder[0] )
-      .toBeLessThan( services.connectionMonitor.stop.mock.invocationCallOrder[0] );
-    expect( services.connectionMonitor.stop.mock.invocationCallOrder[0] )
-      .toBeLessThan( services.catalogPublisher.interrupt.mock.invocationCallOrder[0] );
-    expect( services.catalogPublisher.interrupt.mock.invocationCallOrder[0] )
-      .toBeLessThan( services.connection.close.mock.invocationCallOrder[0] );
-  } );
-
-  it( 'announces each step it takes', async () => {
-    await shutdownServices( createServices() );
-
-    expect( mockLog.info ).toHaveBeenCalledWith( 'Stopping Worker...' );
-    expect( mockLog.info ).toHaveBeenCalledWith( 'Stopping Connection Monitor...' );
-    expect( mockLog.info ).toHaveBeenCalledWith( 'Interrupting Catalog Publisher...' );
-    expect( mockLog.info ).toHaveBeenCalledWith( 'Closing Connection...' );
-    expect( mockLog.warn ).not.toHaveBeenCalled();
-  } );
-
-  it( 'waits for a service to settle before stopping the next one', async () => {
-    const deferred = {};
-    const services = createServices();
-    services.workerRunner.stop.mockReturnValue( new Promise( resolve => {
-      deferred.resolve = resolve;
-    } ) );
-
-    const stopped = shutdownServices( services );
-    await Promise.resolve();
-
-    expect( services.connectionMonitor.stop ).not.toHaveBeenCalled();
-
-    deferred.resolve();
-    await stopped;
-
-    expect( services.connectionMonitor.stop ).toHaveBeenCalledOnce();
-  } );
-
-  it( 'skips a worker runner that is no longer running', async () => {
-    const services = createServices();
-    services.workerRunner.running = false;
-
-    await shutdownServices( services );
-
-    expect( services.workerRunner.stop ).not.toHaveBeenCalled();
-    expect( mockLog.info ).not.toHaveBeenCalledWith( 'Stopping Worker...' );
-    expect( services.connection.close ).toHaveBeenCalledOnce();
-  } );
-
-  it( 'skips a connection monitor that already exited', async () => {
-    const services = createServices();
-    services.connectionMonitor.running = false;
-
-    await shutdownServices( services );
-
-    expect( services.connectionMonitor.stop ).not.toHaveBeenCalled();
-    expect( mockLog.info ).not.toHaveBeenCalledWith( 'Stopping Connection Monitor...' );
-  } );
-
-  it( 'skips a catalog publisher that already finished', async () => {
-    const services = createServices();
-    services.catalogPublisher.running = false;
-
-    await shutdownServices( services );
-
-    expect( services.catalogPublisher.interrupt ).not.toHaveBeenCalled();
-    expect( mockLog.info ).not.toHaveBeenCalledWith( 'Interrupting Catalog Publisher...' );
-  } );
-
-  it( 'reads the state at each turn, so a service stopped by an earlier step is skipped', async () => {
-    const services = createServices();
-    services.workerRunner.stop.mockImplementation( async () => {
-      services.connectionMonitor.running = false;
-    } );
-
-    await shutdownServices( services );
-
-    expect( services.connectionMonitor.stop ).not.toHaveBeenCalled();
-    expect( services.connection.close ).toHaveBeenCalledOnce();
-  } );
-
-  it( 'does nothing when startup never built a service', async () => {
-    await expect( shutdownServices( createEmptyServices() ) ).resolves.toEqual( [] );
-
-    expect( mockLog.info ).not.toHaveBeenCalled();
-    expect( mockLog.warn ).not.toHaveBeenCalled();
-  } );
-
-  it( 'closes the connection when startup failed before anything else existed', async () => {
-    const services = { ...createEmptyServices(), connection: { close: vi.fn().mockResolvedValue( undefined ) } };
-
-    await shutdownServices( services );
-
-    expect( services.connection.close ).toHaveBeenCalledOnce();
-    expect( mockLog.info ).toHaveBeenCalledWith( 'Closing Connection...' );
-  } );
-
-  it( 'reports nothing when every service stops cleanly', async () => {
-    await expect( shutdownServices( createServices() ) ).resolves.toEqual( [] );
-  } );
-
-  it( 'warns, reports the failure and keeps going when a service fails to stop', async () => {
-    const error = new Error( 'drain failed' );
-    const services = createServices();
-    services.workerRunner.stop.mockRejectedValue( error );
-
-    await expect( shutdownServices( services ) ).resolves.toEqual( [ { service: 'worker', error } ] );
-
-    expect( serializeErrorMock ).toHaveBeenCalledWith( error );
-    expect( mockLog.warn ).toHaveBeenCalledWith( 'Stopping Worker error', {
-      error: { name: 'Error', message: 'drain failed' }
-    } );
-    expect( services.connectionMonitor.stop ).toHaveBeenCalledOnce();
-    expect( services.catalogPublisher.interrupt ).toHaveBeenCalledOnce();
-    expect( services.connection.close ).toHaveBeenCalledOnce();
-  } );
-
-  it( 'warns and reports when closing the connection fails', async () => {
-    const error = new Error( 'close failed' );
-    const services = createServices();
-    services.connection.close.mockRejectedValue( error );
-
-    await expect( shutdownServices( services ) ).resolves.toEqual( [ { service: 'connection', error } ] );
-
-    expect( mockLog.warn ).toHaveBeenCalledWith( 'Closing Connection error', {
-      error: { name: 'Error', message: 'close failed' }
-    } );
-  } );
-
-  it( 'warns and reports a service that throws instead of rejecting', async () => {
-    const error = new Error( 'shutdown blew up' );
-    const services = createServices();
-    services.workerRunner.stop.mockImplementation( () => {
-      throw error;
-    } );
-
-    await expect( shutdownServices( services ) ).resolves.toEqual( [ { service: 'worker', error } ] );
-
-    expect( mockLog.warn ).toHaveBeenCalledWith( 'Stopping Worker error', {
-      error: { name: 'Error', message: 'shutdown blew up' }
-    } );
-    expect( services.connection.close ).toHaveBeenCalledOnce();
-  } );
-
-  it( 'reports every service that failed, in the order they were stopped', async () => {
-    const drainError = new Error( 'drain failed' );
-    const closeError = new Error( 'close failed' );
-    const services = createServices();
-    services.workerRunner.stop.mockRejectedValue( drainError );
-    services.connection.close.mockRejectedValue( closeError );
-
-    await expect( shutdownServices( services ) ).resolves.toEqual( [
-      { service: 'worker', error: drainError },
-      { service: 'connection', error: closeError }
-    ] );
-  } );
-} );

package/src/worker/sinks.spec.js

@@ -1,220 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { BusEventType, ComponentType } from '#consts';
-
-const mainEventBusMock = vi.hoisted( () => ( {
-  emit: vi.fn()
-} ) );
-
-const addEventStartMock = vi.hoisted( () => vi.fn() );
-const addEventEndMock = vi.hoisted( () => vi.fn() );
-const addEventErrorMock = vi.hoisted( () => vi.fn() );
-
-const createWorkflowDetailsMock = vi.hoisted( () => vi.fn( workflowInfo => ( {
-  workflowId: workflowInfo.workflowId,
-  workflowType: workflowInfo.workflowType,
-  runId: workflowInfo.runId
-} ) ) );
-
-const rehydrateErrorMock = vi.hoisted( () => vi.fn( error => error ) );
-
-vi.mock( '#bus', () => ( { mainEventBus: mainEventBusMock } ) );
-vi.mock( '#tracing', () => ( {
-  addEventStart: addEventStartMock,
-  addEventEnd: addEventEndMock,
-  addEventError: addEventErrorMock
-} ) );
-vi.mock( '#helpers/temporal_context', () => ( {
-  createWorkflowDetails: createWorkflowDetailsMock
-} ) );
-vi.mock( '#helpers/errors', () => ( {
-  rehydrateError: rehydrateErrorMock
-} ) );
-
-describe( 'worker/sinks', () => {
-  const workflowInfo = {
-    workflowId: 'wf-1',
-    workflowType: 'myWorkflow',
-    runId: 'run-1',
-    memo: {
-      traceInfo: { traceId: 'trace-1' }
-    },
-    parent: {
-      runId: 'parent-run-1'
-    }
-  };
-  const workflowDetails = {
-    workflowId: 'wf-1',
-    workflowType: 'myWorkflow',
-    runId: 'run-1'
-  };
-
-  beforeEach( () => {
-    vi.clearAllMocks();
-  } );
-
-  it( 'disables replay calls for side-effecting sinks', async () => {
-    const { sinks } = await import( './sinks.js' );
-
-    expect( sinks.workflow.start.callDuringReplay ).toBe( false );
-    expect( sinks.workflow.end.callDuringReplay ).toBe( false );
-    expect( sinks.workflow.error.callDuringReplay ).toBe( false );
-    expect( sinks.trace.start.callDuringReplay ).toBe( false );
-    expect( sinks.trace.end.callDuringReplay ).toBe( false );
-    expect( sinks.trace.error.callDuringReplay ).toBe( false );
-  } );
-
-  it( 'workflow.log emits workflow log events with metadata and workflow details', async () => {
-    const { sinks } = await import( './sinks.js' );
-    const metadata = { requestId: 'req-1' };
-
-    sinks.workflow.log.fn( workflowInfo, {
-      level: 'info',
-      message: 'workflow detail',
-      metadata
-    } );
-
-    expect( createWorkflowDetailsMock ).toHaveBeenCalledWith( workflowInfo );
-    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_LOG, {
-      level: 'info',
-      message: 'workflow detail',
-      metadata,
-      workflowDetails
-    } );
-  } );
-
-  it( 'workflow.start emits workflow start events and trace start events', async () => {
-    const { sinks } = await import( './sinks.js' );
-    const input = { value: 'input' };
-
-    sinks.workflow.start.fn( workflowInfo, input );
-
-    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_START, { workflowDetails } );
-    expect( addEventStartMock ).toHaveBeenCalledWith( {
-      id: 'run-1',
-      kind: ComponentType.WORKFLOW,
-      name: 'myWorkflow',
-      details: input,
-      parentId: 'parent-run-1',
-      traceInfo: { traceId: 'trace-1' }
-    } );
-  } );
-
-  it( 'workflow.start skips tracing when trace info is absent', async () => {
-    const { sinks } = await import( './sinks.js' );
-
-    sinks.workflow.start.fn( { ...workflowInfo, memo: {} }, { value: 'input' } );
-
-    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_START, { workflowDetails } );
-    expect( addEventStartMock ).not.toHaveBeenCalled();
-  } );
-
-  it( 'workflow.end emits workflow end events and trace end events', async () => {
-    const { sinks } = await import( './sinks.js' );
-    const output = { value: 'output' };
-
-    sinks.workflow.end.fn( workflowInfo, output );
-
-    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_END, { workflowDetails } );
-    expect( addEventEndMock ).toHaveBeenCalledWith( {
-      id: 'run-1',
-      details: output,
-      traceInfo: { traceId: 'trace-1' }
-    } );
-  } );
-
-  it( 'workflow.end skips tracing when trace info is absent', async () => {
-    const { sinks } = await import( './sinks.js' );
-
-    sinks.workflow.end.fn( { ...workflowInfo, memo: {} }, { value: 'output' } );
-
-    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_END, { workflowDetails } );
-    expect( addEventEndMock ).not.toHaveBeenCalled();
-  } );
-
-  it( 'workflow.error emits workflow error events and trace error events', async () => {
-    const { sinks } = await import( './sinks.js' );
-    const error = { name: 'Error', message: 'workflow failed' };
-    const rehydrated = new Error( 'workflow failed' );
-    rehydrateErrorMock.mockReturnValueOnce( rehydrated );
-
-    sinks.workflow.error.fn( workflowInfo, error );
-
-    expect( rehydrateErrorMock ).toHaveBeenCalledWith( error );
-    expect( mainEventBusMock.emit ).toHaveBeenCalledWith(
-      BusEventType.WORKFLOW_ERROR,
-      { workflowDetails, error: rehydrated }
-    );
-    expect( addEventErrorMock ).toHaveBeenCalledWith( {
-      id: 'run-1',
-      details: error,
-      traceInfo: { traceId: 'trace-1' }
-    } );
-  } );
-
-  it( 'workflow.error skips tracing when trace info is absent', async () => {
-    const { sinks } = await import( './sinks.js' );
-    const error = { name: 'Error', message: 'workflow failed' };
-    const rehydrated = new Error( 'workflow failed' );
-    rehydrateErrorMock.mockReturnValueOnce( rehydrated );
-
-    sinks.workflow.error.fn( { ...workflowInfo, memo: {} }, error );
-
-    expect( rehydrateErrorMock ).toHaveBeenCalledWith( error );
-    expect( mainEventBusMock.emit ).toHaveBeenCalledWith(
-      BusEventType.WORKFLOW_ERROR,
-      { workflowDetails, error: rehydrated }
-    );
-    expect( addEventErrorMock ).not.toHaveBeenCalled();
-  } );
-
-  it( 'trace.start parents trace start events on the current workflow, not its parent workflow', async () => {
-    const { sinks } = await import( './sinks.js' );
-
-    sinks.trace.start.fn( workflowInfo, {
-      id: 'step-1',
-      kind: ComponentType.STEP,
-      name: 'myStep',
-      details: { input: true }
-    } );
-
-    expect( addEventStartMock ).toHaveBeenCalledWith( {
-      id: 'step-1',
-      kind: ComponentType.STEP,
-      name: 'myStep',
-      details: { input: true },
-      parentId: 'run-1',
-      traceInfo: { traceId: 'trace-1' }
-    } );
-  } );
-
-  it( 'trace.end records trace end events', async () => {
-    const { sinks } = await import( './sinks.js' );
-
-    sinks.trace.end.fn( workflowInfo, {
-      id: 'step-1',
-      details: { output: true }
-    } );
-
-    expect( addEventEndMock ).toHaveBeenCalledWith( {
-      id: 'step-1',
-      details: { output: true },
-      traceInfo: { traceId: 'trace-1' }
-    } );
-  } );
-
-  it( 'trace.error records trace error events', async () => {
-    const { sinks } = await import( './sinks.js' );
-    const error = new Error( 'step failed' );
-
-    sinks.trace.error.fn( workflowInfo, {
-      id: 'step-1',
-      details: error
-    } );
-
-    expect( addEventErrorMock ).toHaveBeenCalledWith( {
-      id: 'step-1',
-      details: error,
-      traceInfo: { traceId: 'trace-1' }
-    } );
-  } );
-} );

package/src/worker/telemetry.spec.js

@@ -1,80 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-const configMock = vi.hoisted( () => ( { workerTelemetryIntervalMs: 0 } ) );
-const logMock = vi.hoisted( () => ( { info: vi.fn(), warn: vi.fn() } ) );
-const createChildLoggerMock = vi.hoisted( () => vi.fn( () => logMock ) );
-
-vi.mock( './configs.js', () => ( {
-  get workerTelemetryIntervalMs() {
-    return configMock.workerTelemetryIntervalMs;
-  }
-} ) );
-
-vi.mock( '#logger', () => ( { createChildLogger: createChildLoggerMock } ) );
-
-const loadSetupTelemetry = async () => {
-  vi.resetModules();
-  return import( './telemetry.js' );
-};
-
-const mockSetInterval = unrefMock =>
-  vi.spyOn( globalThis, 'setInterval' ).mockReturnValue( { unref: unrefMock } );
-
-describe( 'worker/telemetry', () => {
-  const availableMemoryMock = vi.fn();
-  const constrainedMemoryMock = vi.fn();
-  const memoryUsageMock = vi.fn();
-  const unrefMock = vi.fn();
-
-  beforeEach( () => {
-    vi.clearAllMocks();
-    configMock.workerTelemetryIntervalMs = 0;
-
-    availableMemoryMock.mockReturnValue( 1_000 );
-    constrainedMemoryMock.mockReturnValue( 2_000 );
-    memoryUsageMock.mockReturnValue( { heapUsed: 300 } );
-
-    vi.spyOn( process, 'availableMemory' ).mockImplementation( availableMemoryMock );
-    vi.spyOn( process, 'constrainedMemory' ).mockImplementation( constrainedMemoryMock );
-    vi.spyOn( process, 'memoryUsage' ).mockImplementation( memoryUsageMock );
-  } );
-
-  afterEach( () => {
-    vi.restoreAllMocks();
-  } );
-
-  it( 'does not create an interval when telemetry interval is disabled', async () => {
-    const setIntervalMock = mockSetInterval( unrefMock );
-    const { setupTelemetry } = await loadSetupTelemetry();
-
-    setupTelemetry( { worker: { getStatus: vi.fn() } } );
-
-    expect( setIntervalMock ).not.toHaveBeenCalled();
-    expect( logMock.info ).not.toHaveBeenCalled();
-  } );
-
-  it( 'logs worker status and memory on the configured interval', async () => {
-    const setIntervalMock = mockSetInterval( unrefMock );
-    configMock.workerTelemetryIntervalMs = 5_000;
-    const worker = { getStatus: vi.fn().mockReturnValue( { runState: 'RUNNING' } ) };
-    const { setupTelemetry } = await loadSetupTelemetry();
-
-    setupTelemetry( { worker } );
-
-    expect( createChildLoggerMock ).toHaveBeenCalledWith( 'Telemetry' );
-    expect( setIntervalMock ).toHaveBeenCalledWith( expect.any( Function ), 5_000 );
-    expect( unrefMock ).toHaveBeenCalled();
-
-    const [ callback ] = setIntervalMock.mock.calls[0];
-    callback();
-
-    expect( logMock.info ).toHaveBeenCalledWith( 'Worker', {
-      status: { runState: 'RUNNING' },
-      memory: {
-        availableMemory: 1_000,
-        constrainedMemory: 2_000,
-        memoryUsage: { heapUsed: 300 }
-      }
-    } );
-  } );
-} );

package/src/worker/temporal_logger.spec.js

@@ -1,90 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-const {
-  defaultLoggerMock,
-  logMock,
-  makeTelemetryFilterStringMock,
-  runtimeInstallMock
-} = vi.hoisted( () => ( {
-  defaultLoggerMock: vi.fn( function ( level, callback ) {
-    this.level = level;
-    this.callback = callback;
-  } ),
-  logMock: { log: vi.fn() },
-  makeTelemetryFilterStringMock: vi.fn().mockReturnValue( 'temporal-filter' ),
-  runtimeInstallMock: vi.fn()
-} ) );
-
-vi.mock( '@temporalio/worker', () => ( {
-  DefaultLogger: defaultLoggerMock,
-  makeTelemetryFilterString: makeTelemetryFilterStringMock,
-  Runtime: { install: runtimeInstallMock }
-} ) );
-vi.mock( '#logger', () => ( { createChildLogger: () => logMock } ) );
-
-import { setupTemporalLogger } from './temporal_logger.js';
-
-describe( 'setupTemporalLogger', () => {
-  beforeEach( () => {
-    vi.clearAllMocks();
-    vi.stubEnv( 'OUTPUT_TEMPORAL_LOG_LEVEL', undefined );
-  } );
-
-  afterEach( () => {
-    vi.unstubAllEnvs();
-  } );
-
-  it( 'forwards Temporal SDK and Core logs through the application logger', () => {
-    setupTemporalLogger();
-
-    expect( makeTelemetryFilterStringMock ).toHaveBeenCalledWith( { core: 'INFO', other: 'INFO' } );
-    expect( defaultLoggerMock ).toHaveBeenCalledWith( 'INFO', expect.any( Function ) );
-    expect( runtimeInstallMock ).toHaveBeenCalledWith( {
-      logger: expect.any( defaultLoggerMock ),
-      telemetryOptions: {
-        logging: {
-          forward: {},
-          filter: 'temporal-filter'
-        }
-      }
-    } );
-
-    const [ entryCallback ] = defaultLoggerMock.mock.calls[0].slice( 1 );
-    entryCallback( { level: 'WARN', message: 'Worker warning', meta: { taskQueue: 'default' } } );
-
-    expect( logMock.log ).toHaveBeenCalledWith( 'warn', 'Worker warning', { taskQueue: 'default' } );
-  } );
-
-  it.each( [
-    [ 'TRACE', 'debug' ],
-    [ 'DEBUG', 'debug' ],
-    [ 'INFO', 'info' ],
-    [ 'WARN', 'warn' ],
-    [ 'ERROR', 'error' ]
-  ] )( 'maps Temporal %s logs to the %s application level', ( temporalLevel, internalLevel ) => {
-    setupTemporalLogger();
-    const [ entryCallback ] = defaultLoggerMock.mock.calls[0].slice( 1 );
-
-    entryCallback( { level: temporalLevel, message: `${temporalLevel} event`, meta: { source: 'test' } } );
-
-    expect( logMock.log ).toHaveBeenCalledWith( internalLevel, `${temporalLevel} event`, { source: 'test' } );
-  } );
-
-  it( 'applies a case-insensitive configured log level to SDK and Core logs', () => {
-    vi.stubEnv( 'OUTPUT_TEMPORAL_LOG_LEVEL', 'debug' );
-
-    setupTemporalLogger();
-
-    expect( defaultLoggerMock ).toHaveBeenCalledWith( 'DEBUG', expect.any( Function ) );
-    expect( makeTelemetryFilterStringMock ).toHaveBeenCalledWith( { core: 'DEBUG', other: 'DEBUG' } );
-  } );
-
-  it.each( [ 'Activity failed', 'Workflow failed' ] )( 'omits redundant "%s" events', message => {
-    setupTemporalLogger();
-    const [ entryCallback ] = defaultLoggerMock.mock.calls[0].slice( 1 );
-
-    entryCallback( { level: 'WARN', message, meta: { error: new Error( 'failed' ) } } );
-
-    expect( logMock.log ).not.toHaveBeenCalled();
-  } );
-} );