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

package/src/interface/logger.spec.js

@@ -0,0 +1,172 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { ACTIVITY_LOGGER_SYMBOL } from '#consts';
+
+const workflowLogMock = vi.fn();
+const proxySinksMock = vi.fn( () => ( {
+  workflow: {
+    log: workflowLogMock
+  }
+} ) );
+const inWorkflowContextMock = vi.fn( () => false );
+
+vi.mock( '@temporalio/workflow', () => ( {
+  inWorkflowContext: inWorkflowContextMock,
+  proxySinks: proxySinksMock
+} ) );
+
+const logLevels = [
+  'error',
+  'warn',
+  'info',
+  'http',
+  'verbose',
+  'debug',
+  'silly'
+];
+
+const consoleMethodsByLevel = {
+  error: 'error',
+  warn: 'warn',
+  info: 'info',
+  http: 'log',
+  verbose: 'log',
+  debug: 'debug',
+  silly: 'log'
+};
+
+const loadLogger = async () => ( await import( './logger.js' ) ).Logger;
+
+describe( 'interface/logger', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    inWorkflowContextMock.mockReturnValue( false );
+    delete globalThis[ACTIVITY_LOGGER_SYMBOL];
+  } );
+
+  afterEach( () => {
+    delete globalThis[ACTIVITY_LOGGER_SYMBOL];
+    vi.restoreAllMocks();
+  } );
+
+  it( 'proxies sinks once when the module is loaded', async () => {
+    await loadLogger();
+
+    expect( proxySinksMock ).toHaveBeenCalledTimes( 1 );
+  } );
+
+  it( 'logs every level through workflow sinks inside workflow context', async () => {
+    const logger = await loadLogger();
+    inWorkflowContextMock.mockReturnValue( true );
+
+    logLevels.forEach( level => {
+      logger[level]( `${level} message`, { requestId: level } );
+    } );
+
+    logLevels.forEach( ( level, index ) => {
+      const payload = {
+        level,
+        message: `${level} message`,
+        metadata: { requestId: level }
+      };
+
+      expect( workflowLogMock ).toHaveBeenNthCalledWith( index + 1, payload );
+    } );
+  } );
+
+  it( 'sanitizes messages and metadata before logging', async () => {
+    const logger = await loadLogger();
+    inWorkflowContextMock.mockReturnValue( true );
+
+    logger.info( 123, {
+      requestId: 'req-1',
+      level: 'error',
+      message: 'metadata message'
+    } );
+
+    expect( workflowLogMock ).toHaveBeenCalledWith( {
+      level: 'info',
+      message: '123',
+      metadata: { requestId: 'req-1' }
+    } );
+  } );
+
+  it( 'logs every level through the activity global logger when it is set outside workflow context', async () => {
+    const logger = await loadLogger();
+    const activityLoggerMock = vi.fn();
+    globalThis[ACTIVITY_LOGGER_SYMBOL] = activityLoggerMock;
+
+    logLevels.forEach( level => {
+      logger[level]( `${level} message`, { requestId: level } );
+    } );
+
+    logLevels.forEach( ( level, index ) => {
+      expect( activityLoggerMock ).toHaveBeenNthCalledWith( index + 1, {
+        level,
+        message: `${level} message`,
+        metadata: { requestId: level }
+      } );
+    } );
+    expect( workflowLogMock ).not.toHaveBeenCalled();
+  } );
+
+  it( 'logs every level to its native console method when no workflow or activity logger is available', async () => {
+    const logger = await loadLogger();
+    const consoleMocks = Object.fromEntries(
+      [ 'debug', 'error', 'info', 'log', 'warn' ].map( method => [
+        method,
+        vi.spyOn( console, method ).mockImplementation( () => {} )
+      ] )
+    );
+
+    logLevels.forEach( level => {
+      logger[level]( `${level} message`, { requestId: level } );
+    } );
+
+    logLevels.forEach( level => {
+      expect( consoleMocks[consoleMethodsByLevel[level]] ).toHaveBeenCalledWith(
+        `${level} message`,
+        { requestId: level }
+      );
+    } );
+    expect( consoleMocks.error ).toHaveBeenCalledTimes( 1 );
+    expect( consoleMocks.warn ).toHaveBeenCalledTimes( 1 );
+    expect( consoleMocks.info ).toHaveBeenCalledTimes( 1 );
+    expect( consoleMocks.debug ).toHaveBeenCalledTimes( 1 );
+    expect( consoleMocks.log ).toHaveBeenCalledTimes( 3 );
+    expect( workflowLogMock ).not.toHaveBeenCalled();
+  } );
+
+  it( 'creates a logger with a default namespace for every level', async () => {
+    const logger = await loadLogger();
+    inWorkflowContextMock.mockReturnValue( true );
+
+    const namespacedLogger = logger.createLogger( 'Namespace' );
+    logLevels.forEach( level => {
+      namespacedLogger[level]( `${level} message`, { requestId: level } );
+    } );
+
+    logLevels.forEach( ( level, index ) => {
+      expect( workflowLogMock ).toHaveBeenNthCalledWith( index + 1, {
+        level,
+        message: `${level} message`,
+        metadata: {
+          namespace: 'Namespace',
+          requestId: level
+        }
+      } );
+    } );
+  } );
+
+  it( 'lets log metadata override the default namespace', async () => {
+    const logger = await loadLogger();
+    inWorkflowContextMock.mockReturnValue( true );
+
+    logger.createLogger( 'Default namespace' ).info( 'message', { namespace: 'Inline namespace' } );
+
+    expect( workflowLogMock ).toHaveBeenCalledWith( {
+      level: 'info',
+      message: 'message',
+      metadata: { namespace: 'Inline namespace' }
+    } );
+  } );
+} );

package/src/interface/step.d.ts

@@ -36,7 +36,7 @@ export type StepFunction<
  * @param input - The Step input; it matches the schema defined by `inputSchema`.
  * @returns A value matching the schema defined by `outputSchema`.
  */
-export type StepFunctionWrapper<StepFunction> =
+export type StepFunctionWrapper<StepFunction extends ( ...args: any ) => any> = // eslint-disable-line @typescript-eslint/no-explicit-any
   Parameters<StepFunction> extends [infer Input] ?
     ( input: Input ) => ReturnType<StepFunction> :
     () => ReturnType<StepFunction>;

package/src/interface/step.js

@@ -1,6 +1,5 @@
 import { StepValidator } from './validations/index.js';
-import { setMetadata } from '#utils';
-import { ComponentType } from '#consts';
+import { createStep } from '#helpers/component';
 
 /**
  * Create a new step (activity flavor) and return a wrapper function around its fn handler
@@ -9,13 +8,17 @@ export function step( { name, description, inputSchema, outputSchema, fn, option
   StepValidator.validateDefinition( { name, description, inputSchema, outputSchema, fn, options } );
   const validator = new StepValidator( { name, inputSchema, outputSchema } );
 
-  const wrapper = async input => {
-    validator.validateInput( input );
-    const output = await fn( input );
-    validator.validateOutput( output );
-    return output;
-  };
-
-  setMetadata( wrapper, { name, description, inputSchema, outputSchema, type: ComponentType.STEP, options } );
-  return wrapper;
-};
+  return createStep( {
+    name,
+    description,
+    inputSchema,
+    outputSchema,
+    options,
+    handler: async input => {
+      validator.validateInput( input );
+      const output = await fn( input );
+      validator.validateOutput( output );
+      return output;
+    }
+  } );
+}

package/src/interface/step.spec.js

@@ -1,11 +1,11 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { ValidationError } from '#errors';
-import { ComponentType } from '#consts';
 
 const validateDefinitionMock = vi.hoisted( () => vi.fn() );
 const validateInputMock = vi.hoisted( () => vi.fn() );
 const validateOutputMock = vi.hoisted( () => vi.fn() );
 const validatorConstructorMock = vi.hoisted( () => vi.fn() );
+const createStepMock = vi.hoisted( () => vi.fn( ( { handler } ) => handler ) );
 
 vi.mock( './validations/index.js', () => {
   class StepValidator {
@@ -23,12 +23,16 @@ vi.mock( './validations/index.js', () => {
   return { StepValidator };
 } );
 
+vi.mock( '#helpers/component', () => ( {
+  createStep: createStepMock
+} ) );
+
 describe( 'step()', () => {
   beforeEach( () => {
     vi.clearAllMocks();
   } );
 
-  it( 'validates the definition, creates a runtime validator, and attaches metadata', async () => {
+  it( 'validates the definition, creates a runtime validator, and creates a step component', async () => {
     const { step } = await import( './step.js' );
     const inputSchema = { safeParse: vi.fn() };
     const outputSchema = { safeParse: vi.fn() };
@@ -58,15 +62,15 @@ describe( 'step()', () => {
       outputSchema
     } );
 
-    const [ metadataSymbol ] = Object.getOwnPropertySymbols( wrapper );
-    expect( wrapper[metadataSymbol] ).toEqual( {
+    expect( createStepMock ).toHaveBeenCalledWith( {
       name: 'test_step',
       description: 'Test step',
       inputSchema,
       outputSchema,
-      type: ComponentType.STEP,
-      options
+      options,
+      handler: expect.any( Function )
     } );
+    expect( wrapper ).toBe( createStepMock.mock.calls[0][0].handler );
   } );
 
   it( 'validates input and output around the step function', async () => {

package/src/interface/webhook.d.ts

@@ -1,10 +1,29 @@
-import type { SerializedFetchResponse } from '../utils/index.d.ts';
-
 /**
  * Allowed HTTP methods for request helpers.
  */
 export type HttpMethod = 'HEAD' | 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
 
+/** Represents a {Response} serialized to plain object */
+export type SerializedFetchResponse = {
+  /** The response url */
+  url: string,
+
+  /** The response status code */
+  status: number,
+
+  /** The response status text */
+  statusText: string,
+
+  /** Flag indicating if the request succeeded */
+  ok: boolean,
+
+  /** Object with response headers */
+  headers: Record<string, string>,
+
+  /** Response body, either JSON, text, or an arrayBuffer converted to base64 */
+  body: object | string
+};
+
 /**
  * Send an POST HTTP request to a URL, optionally with a payload, then wait for a webhook response.
  *

package/src/interface/workflow.d.ts

@@ -133,7 +133,7 @@ export type WorkflowFunction<
 > = InputSchema extends AnyZodSchema ?
   ( input: z.infer<InputSchema>, context: WorkflowContext<InputSchema, OutputSchema> ) =>
   Promise<OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void> :
-  ( input?: undefined | null, context: WorkflowContext<InputSchema, OutputSchema> ) =>
+  ( input: undefined | null, context: WorkflowContext<InputSchema, OutputSchema> ) =>
   Promise<OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void>;
 
 /**
@@ -149,7 +149,7 @@ export type WorkflowFunction<
  * @param options - Additional options for the invocation.
  * @returns A value matching the schema defined by `outputSchema`.
  */
-export type WorkflowFunctionWrapper<WorkflowFunction> =
+export type WorkflowFunctionWrapper<WorkflowFunction extends ( ...args: any ) => any> = // eslint-disable-line @typescript-eslint/no-explicit-any
   [Parameters<WorkflowFunction>[0]] extends [undefined | null] ?
     ( input?: undefined | null, options?: WorkflowInvocationOptions ) =>
     ReturnType<WorkflowFunction> :

package/src/interface/workflow.js

@@ -1,10 +1,12 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
 import { proxyActivities, inWorkflowContext, executeChild, workflowInfo, uuid4, ParentClosePolicy } from '@temporalio/workflow';
 import { WorkflowValidator } from './validations/index.js';
-import { deepMerge, setMetadata, toUrlSafeBase64 } from '#utils';
-import { WorkflowContext } from '#internal_utils/workflow_context';
-import { TraceInfo } from '#internal_utils/trace_info';
+import { toUrlSafeBase64 } from '#helpers/string';
+import { WorkflowContext } from '#helpers/workflow_context';
+import { TraceInfo } from '#helpers/trace_info';
+import { deepMerge } from '#helpers/object';
 import { defaultOptions } from './workflow_activity_options.js';
+import { createWorkflow } from '#helpers/component';
 import {
   ACTIVITY_WRAPPER_VERSION_FIELD,
   ACTIVITY_GET_TRACE_DESTINATIONS,
@@ -34,84 +36,89 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
   const { disableTrace, activityOptions } = deepMerge( defaultOptions, options );
   const validator = new WorkflowValidator( { name, inputSchema, outputSchema } );
 
-  const wrapper = async ( input, extra = {} ) => {
-    validator.validateInvocationOptions( extra );
-
-    // this returns a plain function, for example, in unit tests
-    if ( !inWorkflowContext() ) {
-      validator.validateInput( input );
-      const output = await fn( input, deepMerge( WorkflowContext.build(), extra?.context ) );
-      validator.validateOutput( output );
-      return output;
-    }
+  return createWorkflow( {
+    name,
+    description,
+    inputSchema,
+    outputSchema,
+    options,
+    aliases,
+    handler: async ( input, extra = {} ) => {
+      validator.validateInvocationOptions( extra );
+
+      // this returns a plain function, for example, in unit tests
+      if ( !inWorkflowContext() ) {
+        validator.validateInput( input );
+        const output = await fn( input, deepMerge( WorkflowContext.build(), extra?.context ) );
+        validator.validateOutput( output );
+        return output;
+      }
 
-    const { workflowId, workflowType, memo, root } = workflowInfo();
-
-    // if the stack already includes this workflowId, means the workflow() function was called
-    // from within a running workflow, meaning it is suppose to start a child workflow
-    const isChild = Array.isArray( memo.stack ) ? memo.stack.includes( workflowId ) :
-      checkChildFallback( { workflowType, aliases, name } );
-
-    if ( isChild ) {
-      const result = await executeChild( name, {
-        args: undefined === input ? [] : [ input ],
-        workflowId: `${workflowId}-${toUrlSafeBase64( uuid4() )}`,
-        parentClosePolicy: ParentClosePolicy[extra?.detached ? 'ABANDON' : 'TERMINATE'],
-        memo: {
-          ...memo, // Preserve memo and mix activityOptions, if provided
-          ...( extra?.activityOptions && {
-            activityOptions: deepMerge( memo?.activityOptions ?? {}, extra?.activityOptions )
-          } )
-        }
-      } );
-      return result.output;
-    }
+      const { workflowId, workflowType, memo, root } = workflowInfo();
+
+      // if the stack already includes this workflowId, means the workflow() function was called
+      // from within a running workflow, meaning it is suppose to start a child workflow
+      const isChild = Array.isArray( memo.stack ) ? memo.stack.includes( workflowId ) :
+        checkChildFallback( { workflowType, aliases, name } );
+
+      if ( isChild ) {
+        const result = await executeChild( name, {
+          args: undefined === input ? [] : [ input ],
+          workflowId: `${workflowId}-${toUrlSafeBase64( uuid4() )}`,
+          parentClosePolicy: ParentClosePolicy[extra?.detached ? 'ABANDON' : 'TERMINATE'],
+          memo: {
+            ...memo, // Preserve memo and mix activityOptions, if provided
+            ...( extra?.activityOptions && {
+              activityOptions: deepMerge( memo?.activityOptions ?? {}, extra?.activityOptions )
+            } )
+          }
+        } );
+        return result.output;
+      }
 
-    const isRoot = !root;
+      const isRoot = !root;
 
-    memo.stack = [ ...memo.stack ?? [], workflowId ];
-    // Parent options have prevalence on nested calls, child will be overwritten
-    memo.activityOptions = deepMerge( activityOptions, memo.activityOptions );
-    // Trace info is only added in the root workflow
-    if ( isRoot ) {
-      memo.traceInfo = TraceInfo.build( { disableTrace } );
-    }
+      memo.stack = [ ...memo.stack ?? [], workflowId ];
+      // Parent options have prevalence on nested calls, child will be overwritten
+      memo.activityOptions = deepMerge( activityOptions, memo.activityOptions );
+      // Trace info is only added in the root workflow
+      if ( isRoot ) {
+        memo.traceInfo = TraceInfo.build( { disableTrace } );
+      }
 
-    const steps = proxyActivities( memo.activityOptions );
-    const traceDest = isRoot && parseActivityOutput( await steps[ACTIVITY_GET_TRACE_DESTINATIONS]( memo.traceInfo ) );
-
-    try {
-      validator.validateInput( input );
-
-      // Creates an activity caller based on a prefix
-      const createCaller = prefix => async ( t, ...args ) => parseActivityOutput( await steps[`${prefix}#${t}`]( ...args ) );
-
-      // This are functions used by the AST to replace direct activity (step/evaluator) calls
-      const dispatchers = {
-        invokeStep: createCaller( name ),
-        invokeSharedStep: createCaller( SHARED_STEP_PREFIX ),
-        invokeEvaluator: createCaller( name ),
-        invokeSharedEvaluator: createCaller( SHARED_STEP_PREFIX )
-      };
-
-      // The workflow function execution with "this" set with the dispatchers
-      const output = await fn.call( dispatchers, input, WorkflowContext.build() );
-      validator.validateOutput( output );
-
-      return {
-        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output,
-        ...( traceDest && { trace: { destinations: traceDest } } )
-      };
-    } catch ( error ) {
-      if ( isRoot && traceDest ) {
-        // Append the trace destinations so it is carried to interceptor
-        error[METADATA_ACCESS_SYMBOL] = { trace: { destinations: traceDest } };
+      const steps = proxyActivities( memo.activityOptions );
+      const traceDest = isRoot && parseActivityOutput( await steps[ACTIVITY_GET_TRACE_DESTINATIONS]( memo.traceInfo ) );
+
+      try {
+        validator.validateInput( input );
+
+        // Creates an activity caller based on a prefix
+        const createCaller = prefix => async ( t, ...args ) => parseActivityOutput( await steps[`${prefix}#${t}`]( ...args ) );
+
+        // This are functions used by the AST to replace direct activity (step/evaluator) calls
+        const dispatchers = {
+          invokeStep: createCaller( name ),
+          invokeSharedStep: createCaller( SHARED_STEP_PREFIX ),
+          invokeEvaluator: createCaller( name ),
+          invokeSharedEvaluator: createCaller( SHARED_STEP_PREFIX )
+        };
+
+        // The workflow function execution with "this" set with the dispatchers
+        const output = await fn.call( dispatchers, input, WorkflowContext.build() );
+        validator.validateOutput( output );
+
+        return {
+          [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
+          output,
+          ...( traceDest && { trace: { destinations: traceDest } } )
+        };
+      } catch ( error ) {
+        if ( isRoot && traceDest ) {
+          // Append the trace destinations so it is carried to interceptor
+          error[METADATA_ACCESS_SYMBOL] = { trace: { destinations: traceDest } };
+        }
+        throw error;
       }
-      throw error;
     }
-  };
-
-  setMetadata( wrapper, { name, description, inputSchema, outputSchema, aliases } );
-  return wrapper;
-};
+  } );
+}

package/src/interface/workflow.spec.js

@@ -19,6 +19,7 @@ const validateInputMock = vi.hoisted( () => vi.fn() );
 const validateOutputMock = vi.hoisted( () => vi.fn() );
 const validateInvocationOptionsMock = vi.hoisted( () => vi.fn() );
 const validatorConstructorMock = vi.hoisted( () => vi.fn() );
+const createWorkflowMock = vi.hoisted( () => vi.fn( ( { handler } ) => handler ) );
 
 vi.mock( './validations/index.js', () => {
   class WorkflowValidator {
@@ -37,6 +38,10 @@ vi.mock( './validations/index.js', () => {
   return { WorkflowValidator };
 } );
 
+vi.mock( '#helpers/component', () => ( {
+  createWorkflow: createWorkflowMock
+} ) );
+
 vi.mock( '@temporalio/workflow', async importOriginal => {
   const actual = await importOriginal();
   return {
@@ -151,7 +156,7 @@ describe( 'workflow()', () => {
     expect( () => workflow( workflowDefinition( { name: 'invalid_name' } ) ) ).toThrow( error );
   } );
 
-  it( 'attaches workflow metadata to the wrapper', async () => {
+  it( 'creates a workflow component with definition metadata', async () => {
     const { workflow } = await import( './workflow.js' );
     const inputSchema = z.object( { value: z.string() } );
     const outputSchema = z.object( { ok: z.boolean() } );
@@ -165,14 +170,16 @@ describe( 'workflow()', () => {
       fn: async () => ( { ok: true } )
     } ) );
 
-    const [ metadataSymbol ] = Object.getOwnPropertySymbols( wf );
-    expect( wf[metadataSymbol] ).toEqual( {
+    expect( createWorkflowMock ).toHaveBeenCalledWith( {
       name: 'metadata_wf',
       description: 'Metadata workflow',
       inputSchema,
       outputSchema,
-      aliases: [ 'metadata_alias' ]
+      options: {},
+      aliases: [ 'metadata_alias' ],
+      handler: expect.any( Function )
     } );
+    expect( wf ).toBe( createWorkflowMock.mock.calls[0][0].handler );
   } );
 
   describe( 'outside Temporal workflow context', () => {

package/src/internal_activities/index.js

@@ -1,9 +1,10 @@
 import { FatalError } from '#errors';
 import { fetch } from 'undici';
-import { setMetadata, serializeFetchResponse, serializeBodyAndInferContentType } from '#utils';
-import { ComponentType } from '#consts';
+import { serializeFetchResponse, serializeBodyAndInferContentType } from '#helpers/fetch';
 import { createChildLogger } from '#logger';
 import { getDestinations } from '#tracing';
+import { createInternalStep } from '#helpers/component';
+import { ACTIVITY_GET_TRACE_DESTINATIONS, ACTIVITY_SEND_HTTP_REQUEST } from '#consts';
 
 const log = createChildLogger( 'HttpClient' );
 
@@ -19,41 +20,42 @@ const log = createChildLogger( 'HttpClient' );
  * @returns {object} The serialized HTTP response
  * @throws {FatalError}
  */
-export const sendHttpRequest = async ( { url, method, payload = undefined, headers = undefined, timeout = 30_000 } ) => {
-  const args = {
-    method,
-    headers: new Headers( headers ?? {} ),
-    signal: AbortSignal.timeout( timeout )
-  };
+export const sendHttpRequest = createInternalStep( {
+  name: ACTIVITY_SEND_HTTP_REQUEST,
+  handler: async ( { url, method, payload = undefined, headers = undefined, timeout = 30_000 } ) => {
+    const args = {
+      method,
+      headers: new Headers( headers ?? {} ),
+      signal: AbortSignal.timeout( timeout )
+    };
 
-  const methodsWithBody = [ 'DELETE', 'PATCH', 'POST', 'PUT', 'OPTIONS' ];
-  const hasBodyPayload = ![ undefined, null ].includes( payload );
-  if ( methodsWithBody.includes( method ) && hasBodyPayload ) {
-    const { body, contentType } = serializeBodyAndInferContentType( payload );
-    if ( contentType && !args.headers.has( 'content-type' ) ) {
-      args.headers.set( 'Content-Type', contentType );
-    }
-    Object.assign( args, { body } );
-  };
-
-  const response = await ( async () => {
-    try {
-      return await fetch( url, args );
-    } catch ( e ) {
-      throw new FatalError( `${method} ${url} ${e.cause ?? e.message}` );
-    }
-  } )();
+    const methodsWithBody = [ 'DELETE', 'PATCH', 'POST', 'PUT', 'OPTIONS' ];
+    const hasBodyPayload = ![ undefined, null ].includes( payload );
+    if ( methodsWithBody.includes( method ) && hasBodyPayload ) {
+      const { body, contentType } = serializeBodyAndInferContentType( payload );
+      if ( contentType && !args.headers.has( 'content-type' ) ) {
+        args.headers.set( 'Content-Type', contentType );
+      }
+      Object.assign( args, { body } );
+    };
 
-  log.info( 'HTTP request completed', { url, method, status: response.status, statusText: response.statusText } );
+    const response = await ( async () => {
+      try {
+        return await fetch( url, args );
+      } catch ( e ) {
+        throw new FatalError( `${method} ${url} ${e.cause ?? e.message}` );
+      }
+    } )();
 
-  if ( !response.ok ) {
-    throw new FatalError( `${method} ${url} ${response.status}` );
-  }
+    log.info( 'HTTP request completed', { url, method, status: response.status, statusText: response.statusText } );
 
-  return serializeFetchResponse( response );
-};
+    if ( !response.ok ) {
+      throw new FatalError( `${method} ${url} ${response.status}` );
+    }
 
-setMetadata( sendHttpRequest, { type: ComponentType.INTERNAL_STEP } );
+    return serializeFetchResponse( response );
+  }
+} );
 
 /**
  * Invokes a trace method that resolves all trace output paths based on the traceInfo
@@ -61,6 +63,7 @@ setMetadata( sendHttpRequest, { type: ComponentType.INTERNAL_STEP } );
  * @param {object} traceInfo
  * @returns {object} Information about enabled destinations
  */
-export const getTraceDestinations = traceInfo => getDestinations( traceInfo );
-
-setMetadata( getTraceDestinations, { type: ComponentType.INTERNAL_STEP } );
+export const getTraceDestinations = createInternalStep( {
+  name: ACTIVITY_GET_TRACE_DESTINATIONS,
+  handler: traceInfo => getDestinations( traceInfo )
+} );