@outputai/core 0.10.1-next.f6a7c1a.0 → 0.11.0

package/src/worker/log_hooks.spec.js

@@ -27,9 +27,14 @@ const mainEventBusMock = vi.hoisted( () => ( {
     onHandlers[eventType] = handler;
   } )
 } ) );
+const serializeErrorMock = vi.hoisted( () => vi.fn( error => ( {
+  name: error.name,
+  message: error.message
+} ) ) );
 
 vi.mock( '#logger', () => ( { createChildLogger: createChildLoggerMock } ) );
 vi.mock( '#bus', () => ( { mainEventBus: mainEventBusMock } ) );
+vi.mock( '#helpers/error_serializer', () => ( { serializeError: serializeErrorMock } ) );
 
 import './log_hooks.js';
 
@@ -104,6 +109,7 @@ describe( 'log_hooks', () => {
 
     it( 'ACTIVITY_ERROR logs full message and second arg', () => {
       const err = new Error( 'step failed' );
+      err.name = 'ProviderError';
       onHandlers[BusEventType.ACTIVITY_ERROR]( {
         ...basePayload,
         duration: 100,
@@ -112,7 +118,7 @@ describe( 'log_hooks', () => {
 
       expect( activityLogMock.error ).toHaveBeenCalledTimes( 1 );
       expect( activityLogMock.error ).toHaveBeenCalledWith(
-        'Error myWorkflow#myStep step: Error',
+        'Error myWorkflow#myStep step: ProviderError',
         {
           event: LifecycleEvent.ERROR,
           activityId: 'act-1',
@@ -120,9 +126,10 @@ describe( 'log_hooks', () => {
           workflowId: 'wf-1',
           workflowType: 'myWorkflow',
           runId: 'run-1',
-          error: 'step failed'
+          error: { name: 'ProviderError', message: 'step failed' }
         }
       );
+      expect( serializeErrorMock ).toHaveBeenCalledWith( err, { dropKeys: [ 'stack' ] } );
     } );
 
     it( 'ACTIVITY_ERROR does not log trace destination activity', () => {
@@ -229,7 +236,7 @@ describe( 'log_hooks', () => {
     } );
 
     it( 'WORKFLOW_ERROR logs full message and second arg', () => {
-      const err = new TypeError( 'workflow boom' );
+      const err = { name: 'TypeError', message: 'workflow boom' };
       onHandlers[BusEventType.WORKFLOW_ERROR]( {
         ...basePayload,
         duration: 150,
@@ -244,9 +251,10 @@ describe( 'log_hooks', () => {
           workflowId: 'wf-1',
           workflowType: 'myWorkflow',
           runId: 'run-1',
-          error: 'workflow boom'
+          error: { name: 'TypeError', message: 'workflow boom' }
         }
       );
+      expect( serializeErrorMock ).toHaveBeenCalledWith( err, { dropKeys: [ 'stack' ] } );
     } );
 
     it( 'WORKFLOW_ERROR does not log when workflowType is WORKFLOW_CATALOG', () => {

package/src/worker/sinks.js

@@ -2,6 +2,7 @@ import { BusEventType, ComponentType } from '#consts';
 import * as Tracing from '#tracing';
 import { mainEventBus } from '#bus';
 import { createWorkflowDetails } from '#helpers/temporal_context';
+import { rehydrateError } from '#helpers/errors';
 
 // This sink allow for sandbox Temporal environment to send trace logs back to the main thread.
 export const sinks = {
@@ -48,7 +49,8 @@ export const sinks = {
     error: {
       fn: ( workflowInfo, error ) => {
         const { runId, memo: { traceInfo } } = workflowInfo;
-        mainEventBus.emit( BusEventType.WORKFLOW_ERROR, { workflowDetails: createWorkflowDetails( workflowInfo ), error } );
+        // re-hydrate workflow error
+        mainEventBus.emit( BusEventType.WORKFLOW_ERROR, { workflowDetails: createWorkflowDetails( workflowInfo ), error: rehydrateError( error ) } );
         if ( traceInfo ) {
           Tracing.addEventError( { id: runId, details: error, traceInfo } );
         }

package/src/worker/sinks.spec.js

@@ -15,6 +15,8 @@ const createWorkflowDetailsMock = vi.hoisted( () => vi.fn( workflowInfo => ( {
   runId: workflowInfo.runId
 } ) ) );
 
+const rehydrateErrorMock = vi.hoisted( () => vi.fn( error => error ) );
+
 vi.mock( '#bus', () => ( { mainEventBus: mainEventBusMock } ) );
 vi.mock( '#tracing', () => ( {
   addEventStart: addEventStartMock,
@@ -24,6 +26,9 @@ vi.mock( '#tracing', () => ( {
 vi.mock( '#helpers/temporal_context', () => ( {
   createWorkflowDetails: createWorkflowDetailsMock
 } ) );
+vi.mock( '#helpers/errors', () => ( {
+  rehydrateError: rehydrateErrorMock
+} ) );
 
 describe( 'worker/sinks', () => {
   const workflowInfo = {
@@ -128,11 +133,17 @@ describe( 'worker/sinks', () => {
 
   it( 'workflow.error emits workflow error events and trace error events', async () => {
     const { sinks } = await import( './sinks.js' );
-    const error = new Error( 'workflow failed' );
+    const error = { name: 'Error', message: 'workflow failed' };
+    const rehydrated = new Error( 'workflow failed' );
+    rehydrateErrorMock.mockReturnValueOnce( rehydrated );
 
     sinks.workflow.error.fn( workflowInfo, error );
 
-    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_ERROR, { workflowDetails, error } );
+    expect( rehydrateErrorMock ).toHaveBeenCalledWith( error );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith(
+      BusEventType.WORKFLOW_ERROR,
+      { workflowDetails, error: rehydrated }
+    );
     expect( addEventErrorMock ).toHaveBeenCalledWith( {
       id: 'run-1',
       details: error,
@@ -142,11 +153,17 @@ describe( 'worker/sinks', () => {
 
   it( 'workflow.error skips tracing when trace info is absent', async () => {
     const { sinks } = await import( './sinks.js' );
-    const error = new Error( 'workflow failed' );
+    const error = { name: 'Error', message: 'workflow failed' };
+    const rehydrated = new Error( 'workflow failed' );
+    rehydrateErrorMock.mockReturnValueOnce( rehydrated );
 
     sinks.workflow.error.fn( { ...workflowInfo, memo: {} }, error );
 
-    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_ERROR, { workflowDetails, error } );
+    expect( rehydrateErrorMock ).toHaveBeenCalledWith( error );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith(
+      BusEventType.WORKFLOW_ERROR,
+      { workflowDetails, error: rehydrated }
+    );
     expect( addEventErrorMock ).not.toHaveBeenCalled();
   } );
 

package/src/worker/telemetry.js

@@ -1,3 +1,4 @@
+import { serializeError } from '#helpers/error_serializer';
 import { createChildLogger } from '#logger';
 import { workerTelemetryIntervalMs } from './configs.js';
 
@@ -18,7 +19,7 @@ export const setupTelemetry = ( { worker } ) => {
         }
       } );
     } catch ( error ) {
-      log.warn( 'Failure', { error: error.message } );
+      log.warn( 'Failure', { error: serializeError( error, { dropKeys: [ 'stack' ] } ) } );
     }
   }, workerTelemetryIntervalMs ).unref();
 };

package/src/worker/temporal_logger.js

@@ -0,0 +1,33 @@
+import { DefaultLogger, makeTelemetryFilterString, Runtime } from '@temporalio/worker';
+import { createChildLogger } from '#logger';
+
+const log = createChildLogger( 'Temporal' );
+const OMITTED_MESSAGES = [ 'Activity failed', 'Workflow failed' ];
+
+const temporalLevelToInternalLevelMap = {
+  TRACE: 'debug',
+  DEBUG: 'debug',
+  INFO: 'info',
+  WARN: 'warn',
+  ERROR: 'error'
+};
+
+export const setupTemporalLogger = () => {
+  const level = process.env.OUTPUT_TEMPORAL_LOG_LEVEL?.toUpperCase() ?? 'INFO';
+
+  Runtime.install( {
+    logger: new DefaultLogger( level, entry => {
+      // Already reported by Output activity logs and traces.
+      if ( OMITTED_MESSAGES.includes( entry.message ) ) {
+        return;
+      }
+      log.log( temporalLevelToInternalLevelMap[entry.level], entry.message, entry.meta );
+    } ),
+    telemetryOptions: {
+      logging: {
+        forward: {},
+        filter: makeTelemetryFilterString( { core: level, other: level } )
+      }
+    }
+  } );
+};

package/src/worker/temporal_logger.spec.js

@@ -0,0 +1,90 @@
+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();
+  } );
+} );

package/src/helpers/aggregations.js

@@ -1,44 +0,0 @@
-import { Attribute } from '#trace_attribute';
-import Decimal from 'decimal.js';
-
-/**
- * @typedef {object} Aggregation
- *
- * @property {object} cost
- * @property {object} cost.total - Total cost
- * @property {object} tokens
- * @property {object} tokens.total - Total tokens used
- * @property {object} tokens.input  - Total input tokens used
- * @property {object} tokens.input_cached - Total cached input tokens used
- * @property {object} tokens.output - Total output tokens used
- * @property {object} tokens.reasoning - Total reasoning tokens used
- * @property {object} httpRequests
- * @property {object} httpRequests.total - Total number of http requests made
- */
-/**
- * Aggregates a collection of Attributes into a object with totals
- *
- * @param {Attribute} attributes
- * @returns {Aggregation} aggregation object
- */
-export const aggregateAttributes = attributes => ( {
-  cost: {
-    total: attributes
-      .filter( a => [ Attribute.HTTPRequestCost.TYPE, Attribute.LLMUsage.TYPE ].includes( a.type ) )
-      .reduce( ( sum, a ) => sum.add( a.total ), Decimal( 0 ) ).toNumber()
-  },
-  tokens: {
-    total: attributes
-      .filter( a => Attribute.LLMUsage.TYPE === a.type )
-      .reduce( ( sum, a ) => sum.add( a.tokensUsed ), Decimal( 0 ) ).toNumber(),
-    ...Object.entries( attributes
-      .filter( a => Attribute.LLMUsage.TYPE === a.type )
-      .flatMap( a => a.usage )
-      .reduce( ( obj, a ) => Object.assign( obj, { [a.type]: ( obj[a.type] ?? Decimal( 0 ) ).add( a.amount ) } ), {} ) )
-      .reduce( ( obj, [ k, v ] ) => Object.assign( obj, { [k]: v.toNumber() } ), {} ) // convert all values to number
-
-  },
-  httpRequests: {
-    total: attributes.filter( a => Attribute.HTTPRequestCount.TYPE === a.type ).length
-  }
-} );

package/src/helpers/aggregations.spec.js

@@ -1,92 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { Attribute } from '#trace_attribute';
-import { aggregateAttributes } from './aggregations.js';
-
-describe( 'aggregateAttributes', () => {
-  it( 'returns zeroed aggregations when there are no attributes', () => {
-    expect( aggregateAttributes( [] ) ).toEqual( {
-      cost: { total: 0 },
-      tokens: { total: 0 },
-      httpRequests: { total: 0 }
-    } );
-  } );
-
-  it( 'aggregates costs, token usage, and HTTP request count by attribute type', () => {
-    const attributes = [
-      {
-        type: Attribute.HTTPRequestCount.TYPE,
-        url: 'https://api.example.test/a',
-        requestId: 'req-1'
-      },
-      {
-        type: Attribute.HTTPRequestCount.TYPE,
-        url: 'https://api.example.test/b',
-        requestId: 'req-2'
-      },
-      {
-        type: Attribute.HTTPRequestCost.TYPE,
-        url: 'https://api.example.test/a',
-        requestId: 'req-1',
-        total: 0.2
-      },
-      {
-        type: Attribute.LLMUsage.TYPE,
-        modelId: 'gpt-4o',
-        total: 0.3,
-        tokensUsed: 120,
-        usage: [
-          { type: 'input', ppm: 1, amount: 100, total: 0.1 },
-          { type: 'output', ppm: 2, amount: 20, total: 0.2 }
-        ]
-      },
-      {
-        type: Attribute.LLMUsage.TYPE,
-        modelId: 'gpt-4o-mini',
-        total: 0.05,
-        tokensUsed: 30,
-        usage: [
-          { type: 'input', ppm: 1, amount: 25, total: 0.025 },
-          { type: 'reasoning', ppm: 5, amount: 5, total: 0.025 }
-        ]
-      },
-      {
-        type: 'unrelated',
-        total: 100,
-        tokensUsed: 100
-      }
-    ];
-
-    expect( aggregateAttributes( attributes ) ).toEqual( {
-      cost: { total: 0.55 },
-      tokens: {
-        total: 150,
-        input: 125,
-        output: 20,
-        reasoning: 5
-      },
-      httpRequests: { total: 2 }
-    } );
-  } );
-
-  it( 'uses LLMUsage.tokensUsed for total tokens instead of summing usage amounts', () => {
-    const attributes = [
-      {
-        type: Attribute.LLMUsage.TYPE,
-        modelId: 'provider-model',
-        total: 0.1,
-        tokensUsed: 42,
-        usage: [
-          { type: 'input', ppm: 1, amount: 10, total: 0.01 },
-          { type: 'output', ppm: 1, amount: 5, total: 0.005 }
-        ]
-      }
-    ];
-
-    expect( aggregateAttributes( attributes ).tokens ).toEqual( {
-      total: 42,
-      input: 10,
-      output: 5
-    } );
-  } );
-} );
-

package/src/tracing/tools/utils.js

@@ -1,42 +0,0 @@
-import { inspect } from 'node:util';
-
-/**
- * @typedef {object} SerializedError
- * @property {string} name - The error constructor name
- * @property {string} message - The error message
- * @property {string} stack - The error stack trace
- */
-
-/**
- * Recursively Serialize an error object. Navigate using "cause" property.
- *
- * Goes up 10 levels deep.
- *
- * @param {Error} error
- * @returns {SerializedError}
- */
-export const serializeError = ( () => {
-
-  const serializeValue = v => {
-    try {
-      return JSON.parse( JSON.stringify( v ) );
-    } catch {
-      return inspect( v, { depth: 5, breakLength: Infinity, colors: false } );
-    }
-  };
-
-  return ( error, depth = 0 ) => {
-    if ( depth > 10 ) {
-      return { name: 'Error', message: 'Cause chain too deep' };
-    }
-    if ( error instanceof Error ) {
-      return {
-        name: error.constructor.name,
-        message: error.message,
-        stack: error.stack,
-        ...( error.cause !== undefined ? { cause: serializeError( error.cause, depth + 1 ) } : {} )
-      };
-    }
-    return serializeValue( error );
-  };
-} )();

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

@@ -1,83 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { serializeError } from './utils.js';
-
-describe( 'serializeError', () => {
-  it( 'serializes basic Error fields', () => {
-    const error = new Error( 'boom' );
-
-    const result = serializeError( error );
-
-    expect( result ).toMatchObject( {
-      name: 'Error',
-      message: 'boom'
-    } );
-    expect( typeof result.stack ).toBe( 'string' );
-    expect( result ).not.toHaveProperty( 'cause' );
-  } );
-
-  it( 'preserves custom error constructor names', () => {
-    class CustomError extends Error {}
-    const error = new CustomError( 'custom boom' );
-
-    expect( serializeError( error ) ).toMatchObject( {
-      name: 'CustomError',
-      message: 'custom boom'
-    } );
-  } );
-
-  it( 'recursively serializes Error causes', () => {
-    const root = new TypeError( 'root failure' );
-    const wrapped = new Error( 'wrapped failure', { cause: root } );
-
-    expect( serializeError( wrapped ) ).toMatchObject( {
-      name: 'Error',
-      message: 'wrapped failure',
-      cause: {
-        name: 'TypeError',
-        message: 'root failure'
-      }
-    } );
-  } );
-
-  it( 'preserves JSON-serializable non-Error causes', () => {
-    const cause = {
-      code: 'bad_input',
-      path: [ 'items', 0, 'title' ],
-      message: 'Expected title'
-    };
-    const error = new Error( 'validation failed', { cause } );
-
-    expect( serializeError( error ) ).toMatchObject( {
-      name: 'Error',
-      message: 'validation failed',
-      cause
-    } );
-  } );
-
-  it( 'falls back to inspect for non-JSON-serializable causes', () => {
-    const cause = { name: 'circular' };
-    cause.self = cause;
-    const error = new Error( 'failed', { cause } );
-
-    const result = serializeError( error );
-
-    expect( result.cause ).toContain( 'circular' );
-    expect( result.cause ).toContain( 'Circular' );
-  } );
-
-  it( 'falls back to inspect for primitive values JSON cannot serialize', () => {
-    expect( serializeError( 1n ) ).toBe( '1n' );
-  } );
-
-  it( 'stops serializing cause chains after the depth limit', () => {
-    const makeErrorChain = depth => depth === 0 ?
-      new Error( 'leaf' ) :
-      new Error( `level ${depth}`, { cause: makeErrorChain( depth - 1 ) } );
-    const getCauseAtDepth = ( error, depth ) => depth === 0 ?
-      error :
-      getCauseAtDepth( error.cause, depth - 1 );
-
-    expect( getCauseAtDepth( serializeError( makeErrorChain( 11 ) ), 11 ) )
-      .toEqual( { name: 'Error', message: 'Cause chain too deep' } );
-  } );
-} );

package/src/worker/proxy.js

@@ -1,20 +0,0 @@
-import { EnvHttpProxyAgent, setGlobalDispatcher } from 'undici';
-import { createChildLogger } from '#logger';
-
-const log = createChildLogger( 'Proxy' );
-
-/**
- * Routes all `fetch()` calls (including those inside Temporal activities)
- * through an HTTP/HTTPS proxy when standard proxy env vars are set.
- * No-op when none are set.
- */
-export const bootstrapFetchProxy = () => {
-  const httpProxyUrl = process.env.http_proxy ?? process.env.HTTP_PROXY;
-  const httpsProxyUrl = process.env.https_proxy ?? process.env.HTTPS_PROXY;
-
-  if ( httpProxyUrl?.length > 0 || httpsProxyUrl?.length > 0 ) {
-    log.info( 'Proxy env vars detected, setting up global fetch dispatcher EnvHttpProxyAgent', { httpProxyUrl, httpsProxyUrl } );
-    /* Ignore HTTP/2. Check: https://github.com/growthxai/output/issues/299 */
-    setGlobalDispatcher( new EnvHttpProxyAgent( { allowH2: false } ) );
-  }
-};

package/src/worker/proxy.spec.js

@@ -1,51 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-const mockSetGlobalDispatcher = vi.fn();
-const MockEnvHttpProxyAgent = vi.fn();
-const mockLogger = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-
-vi.mock( 'undici', () => ( {
-  EnvHttpProxyAgent: MockEnvHttpProxyAgent,
-  setGlobalDispatcher: mockSetGlobalDispatcher
-} ) );
-
-vi.mock( '#logger', () => ( {
-  createChildLogger: () => mockLogger
-} ) );
-
-describe( 'worker/proxy', () => {
-  const proxyEnv = [ 'http_proxy', 'HTTP_PROXY', 'https_proxy', 'HTTPS_PROXY' ];
-
-  beforeEach( () => {
-    vi.clearAllMocks();
-    for ( const key of proxyEnv ) {
-      delete process.env[key];
-    }
-  } );
-
-  afterEach( () => {
-    vi.resetModules();
-  } );
-
-  it( 'does nothing when no proxy env vars are set', async () => {
-    const { bootstrapFetchProxy } = await import( './proxy.js' );
-    bootstrapFetchProxy();
-
-    expect( MockEnvHttpProxyAgent ).not.toHaveBeenCalled();
-    expect( mockSetGlobalDispatcher ).not.toHaveBeenCalled();
-    expect( mockLogger.info ).not.toHaveBeenCalled();
-  } );
-
-  it( 'sets global dispatcher when proxy URL is available', async () => {
-    process.env.HTTP_PROXY = 'http://proxy:8080/';
-    const { bootstrapFetchProxy } = await import( './proxy.js' );
-    bootstrapFetchProxy();
-
-    expect( MockEnvHttpProxyAgent ).toHaveBeenCalledWith( { allowH2: false } );
-    expect( mockSetGlobalDispatcher ).toHaveBeenCalledTimes( 1 );
-    expect( mockLogger.info ).toHaveBeenCalledWith(
-      'Proxy env vars detected, setting up global fetch dispatcher EnvHttpProxyAgent',
-      { httpProxyUrl: 'http://proxy:8080/', httpsProxyUrl: undefined }
-    );
-  } );
-} );