Class OptimizedExecutionTracker

constructor

• new OptimizedExecutionTracker(
      options?: ExecutionTrackerOptions,
  ): OptimizedExecutionTracker

  Create a new execution tracker

  Parameters

  • options: ExecutionTrackerOptions = {}

    Tracker configuration options

  Returns OptimizedExecutionTracker

blockingThreshold

defaultSampleRate

defaultThreshold

enabled

enableNestedTracking

reporter

showMemoryUsage

silent

stats

trackingMode

createTrackable

• createTrackable<T extends (...args: any[]) => any>(
      fn: T,
      options?: Record<string, any>,
  ): (...args: Parameters<T>) => ReturnType<T>

  Create a trackable version of a function

  Type Parameters

  • T extends (...args: any[]) => any

  Parameters

  • fn: T

    Function to track

  • options: Record<string, any> = {}

    Tracking options

  Returns (...args: Parameters<T>) => ReturnType<T>

  Tracked version of the function

endTimer

• endTimer(
      executionId: string,
      result?: any,
      error?: Error | null,
  ): ExecutionData | null

  End timing a function execution

  Parameters

  • executionId: string

    ID of the execution to end

  • Optionalresult: any

    Result of the function

  • error: Error | null = null

    Error if the function threw

  Returns ExecutionData | null

  Execution data

markSyncEnd

• markSyncEnd(executionId: string): void

  Mark the end of the synchronous part of an execution that returned a promise

  Parameters

  • executionId: string

  Returns void

reset

• reset(): void

  Reset the tracker state

  Returns void

startSpan

• startSpan(label: string, options?: Record<string, any>): Span

  Start a manually-ended execution (a "span"). Use run() to execute code as part of it, so tracked calls inside attach as children, and end() when the work is finished.

  Parameters

  • label: string
  • options: Record<string, any> = {}

  Returns Span

startTimer

• startTimer(
      label: string,
      parentExecutionId?: string | null,
      options?: TimerOptions,
      args?: ArrayLike<unknown> | undefined,
  ): string

  Start timing a function execution

  Parameters

  • label: string

    Function name or label

  • parentExecutionId: string | null = null

    ID of parent execution if nested

  • options: TimerOptions = {}

    Additional options

  • args: ArrayLike<unknown> | undefined = options.args

  Returns string

  Execution ID

track

• track<T>(fn: () => T, options?: Record<string, any>): T

  Track a function execution directly

  Type Parameters

  • T

  Parameters

  • fn: () => T

    Function to track

  • options: Record<string, any> = {}

    Tracking options

  Returns T

  Function result

trackModule

• trackModule<T extends Record<string, any>>(
      module: T,
      options?: Record<string, any>,
  ): T

  Track a module's methods

  Type Parameters

  • T extends Record<string, any>

  Parameters

  • module: T

    Module to track

  • options: Record<string, any> = {}

    Tracking options

  Returns T

  Tracked module

use

• use(plugin: TracePerfPlugin): () => void

  Register a plugin. Returns a function that removes it again.

  Parameters

  • plugin: TracePerfPlugin

  Returns () => void