traceperf 0.1.0 → 0.1.2

package/dist/esm/trackers/execution.js

@@ -0,0 +1,214 @@
+import { CallStackManager, getFunctionName } from '../utils/stack';
+import { getHighResTime, getDuration } from '../utils/timing';
+import { AsciiArtGenerator } from '../formatters/ascii';
+/**
+ * Execution tracker for tracking function calls and generating flow charts
+ */
+export class ExecutionTracker {
+    /**
+     * Create a new ExecutionTracker instance
+     *
+     * @param options - Tracker options
+     */
+    constructor(options = {}) {
+        var _a;
+        this._executions = [];
+        this._currentExecution = null;
+        this._instrumentedFunctions = new Map();
+        this._isInstrumented = false;
+        this._callStack = new CallStackManager();
+        this._asciiGenerator = new AsciiArtGenerator({ boxWidth: options.boxWidth });
+        this._defaultThreshold = (_a = options.defaultThreshold) !== null && _a !== void 0 ? _a : 100; // ms
+    }
+    /**
+     * Track the execution of a function
+     *
+     * @param fn - The function to track
+     * @param options - Options for tracking
+     * @returns The return value of the tracked function
+     */
+    track(fn, options) {
+        var _a, _b, _c;
+        const fnName = (options === null || options === void 0 ? void 0 : options.label) || getFunctionName(fn);
+        const threshold = (_a = options === null || options === void 0 ? void 0 : options.threshold) !== null && _a !== void 0 ? _a : this._defaultThreshold;
+        const includeMemory = (_b = options === null || options === void 0 ? void 0 : options.includeMemory) !== null && _b !== void 0 ? _b : true;
+        const enableNestedTracking = (_c = options === null || options === void 0 ? void 0 : options.enableNestedTracking) !== null && _c !== void 0 ? _c : true;
+        // Get memory usage before execution
+        const startMemory = includeMemory ? process.memoryUsage().heapUsed : undefined;
+        // Start timing
+        const startTime = getHighResTime();
+        // Add to call stack
+        const level = this._callStack.push(fnName);
+        // Create execution record
+        const execution = {
+            name: fnName,
+            duration: 0,
+            isSlow: false,
+            level: level - 1, // 0-based level
+            startTime,
+            children: [],
+        };
+        // Set parent-child relationship
+        if (this._currentExecution) {
+            execution.parent = this._currentExecution;
+            this._currentExecution.children.push(execution);
+        }
+        else {
+            // This is a root execution
+            this._executions.push(execution);
+        }
+        // Save the previous current execution
+        const previousExecution = this._currentExecution;
+        // Set this as the current execution
+        this._currentExecution = execution;
+        // Flag to track if we're already instrumenting to avoid recursion
+        const wasInstrumented = this._isInstrumented;
+        try {
+            // If this is the top-level call and nested tracking is enabled, instrument the function
+            if (enableNestedTracking && !wasInstrumented) {
+                this._isInstrumented = true;
+                // Instrument the function to track nested calls
+                const instrumentedFn = this.instrumentFunction(fn);
+                return instrumentedFn();
+            }
+            else {
+                // Execute the function normally
+                return fn();
+            }
+        }
+        finally {
+            // End timing
+            const endTime = getHighResTime();
+            execution.endTime = endTime;
+            // Calculate duration
+            execution.duration = getDuration(startTime);
+            // Check if it's a bottleneck
+            execution.isSlow = execution.duration > threshold;
+            // Calculate memory usage
+            if (includeMemory && startMemory !== undefined) {
+                execution.memoryUsage = process.memoryUsage().heapUsed - startMemory;
+            }
+            // Restore the previous current execution
+            this._currentExecution = previousExecution;
+            // Remove from call stack
+            this._callStack.pop();
+            // Reset instrumentation flag if this was the top-level call
+            if (!wasInstrumented) {
+                this._isInstrumented = false;
+            }
+        }
+    }
+    /**
+     * Instrument a function to track nested function calls
+     *
+     * @param fn - The function to instrument
+     * @returns The instrumented function
+     */
+    instrumentFunction(fn) {
+        // If we've already instrumented this function, return the instrumented version
+        if (this._instrumentedFunctions.has(fn)) {
+            return this._instrumentedFunctions.get(fn);
+        }
+        // Create a new instrumented function
+        const instrumentedFn = () => {
+            try {
+                // We can't actually modify the function at runtime to track nested calls
+                // in a generic way. The best we can do is execute the function and rely
+                // on the call stack for visualization.
+                //
+                // For proper nested function tracking, users should wrap each function
+                // they want to track with tracePerf.track() or use a more advanced
+                // instrumentation approach like aspect-oriented programming or
+                // code transformation.
+                return fn();
+            }
+            catch (error) {
+                // Re-throw any errors
+                throw error;
+            }
+        };
+        // Cache the instrumented function
+        this._instrumentedFunctions.set(fn, instrumentedFn);
+        return instrumentedFn;
+    }
+    /**
+     * Get the current call stack
+     *
+     * @returns The current call stack
+     */
+    getCallStack() {
+        return this._callStack.getStack();
+    }
+    /**
+     * Generate a visual representation of the execution flow
+     *
+     * @returns ASCII flow chart of the execution
+     */
+    generateFlowChart() {
+        // Convert execution records to execution data for the ASCII generator
+        const executionData = this.prepareExecutionData(this._executions);
+        // Generate the flow chart
+        return this._asciiGenerator.generateFlowChart(executionData);
+    }
+    /**
+     * Prepare execution data for the ASCII generator
+     *
+     * @param executions - The execution records to prepare
+     * @returns A list of execution data
+     */
+    prepareExecutionData(executions) {
+        const result = [];
+        // Process each root execution
+        executions.forEach(execution => {
+            // Add the root execution
+            result.push({
+                name: execution.name,
+                duration: execution.duration,
+                isSlow: execution.isSlow,
+                memoryUsage: execution.memoryUsage,
+                level: execution.level,
+            });
+            // Add children recursively
+            this.addChildrenToResult(execution.children, result);
+        });
+        return result;
+    }
+    /**
+     * Add children to the result list
+     *
+     * @param children - The children to add
+     * @param result - The result list
+     */
+    addChildrenToResult(children, result) {
+        children.forEach(child => {
+            // Add the child
+            result.push({
+                name: child.name,
+                duration: child.duration,
+                isSlow: child.isSlow,
+                memoryUsage: child.memoryUsage,
+                level: child.level,
+            });
+            // Add grandchildren recursively
+            this.addChildrenToResult(child.children, result);
+        });
+    }
+    /**
+     * Clear all execution records
+     */
+    clear() {
+        this._executions = [];
+        this._currentExecution = null;
+        this._callStack.clear();
+        this._instrumentedFunctions.clear();
+    }
+    /**
+     * Get all execution records
+     *
+     * @returns All execution records
+     */
+    getExecutions() {
+        return [...this._executions];
+    }
+}
+//# sourceMappingURL=execution.js.map

package/dist/esm/trackers/execution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution.js","sourceRoot":"","sources":["../../../src/trackers/execution.ts"],"names":[],"mappings":"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"}

package/dist/esm/trackers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './execution';
+export * from './performance';

package/dist/esm/trackers/index.js

@@ -0,0 +1,3 @@
+export * from './execution';
+export * from './performance';
+//# sourceMappingURL=index.js.map

package/dist/esm/trackers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/trackers/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC"}

package/dist/esm/trackers/performance.d.ts

@@ -0,0 +1,82 @@
+import { IPerformanceMonitor } from '../types';
+/**
+ * Performance monitor for tracking execution times and memory usage
+ */
+export declare class PerformanceMonitor implements IPerformanceMonitor {
+    private _timers;
+    private _defaultThreshold;
+    /**
+     * Create a new PerformanceMonitor instance
+     *
+     * @param options - Monitor options
+     */
+    constructor(options?: {
+        defaultThreshold?: number;
+    });
+    /**
+     * Start timing an operation
+     *
+     * @param label - Label for the operation
+     * @returns A unique identifier for the timing operation
+     */
+    startTimer(label: string): string;
+    /**
+     * End timing an operation
+     *
+     * @param id - The identifier returned by startTimer
+     * @returns The duration in milliseconds
+     * @throws Error if the timer doesn't exist
+     */
+    endTimer(id: string): number;
+    /**
+     * Check if an operation exceeds the performance threshold
+     *
+     * @param duration - The duration in milliseconds
+     * @param threshold - The threshold to check against
+     * @returns Whether the operation is considered slow
+     */
+    isBottleneck(duration: number, threshold?: number): boolean;
+    /**
+     * Get memory usage information
+     *
+     * @returns Memory usage in bytes
+     */
+    getMemoryUsage(): {
+        heapUsed: number;
+        heapTotal: number;
+        external: number;
+        rss: number;
+    };
+    /**
+     * Get memory difference between two points
+     *
+     * @param before - Memory usage before
+     * @param after - Memory usage after
+     * @returns Memory difference in bytes
+     */
+    getMemoryDiff(before: {
+        heapUsed: number;
+        heapTotal: number;
+        external: number;
+        rss: number;
+    }, after: {
+        heapUsed: number;
+        heapTotal: number;
+        external: number;
+        rss: number;
+    }): {
+        heapUsed: number;
+        heapTotal: number;
+        external: number;
+        rss: number;
+    };
+    /**
+     * Generate a suggestion for a bottleneck
+     *
+     * @param functionName - The name of the function
+     * @param duration - The duration in milliseconds
+     * @param memoryUsage - Memory usage in bytes
+     * @returns A suggestion for improving performance
+     */
+    generateSuggestion(functionName: string, duration: number, memoryUsage?: number): string;
+}

package/dist/esm/trackers/performance.js

@@ -0,0 +1,106 @@
+import { getHighResTime, getDuration } from '../utils/timing';
+import { v4 as uuidv4 } from 'uuid';
+/**
+ * Performance monitor for tracking execution times and memory usage
+ */
+export class PerformanceMonitor {
+    /**
+     * Create a new PerformanceMonitor instance
+     *
+     * @param options - Monitor options
+     */
+    constructor(options = {}) {
+        var _a;
+        this._timers = new Map();
+        this._defaultThreshold = (_a = options.defaultThreshold) !== null && _a !== void 0 ? _a : 100; // ms
+    }
+    /**
+     * Start timing an operation
+     *
+     * @param label - Label for the operation
+     * @returns A unique identifier for the timing operation
+     */
+    startTimer(label) {
+        const id = `${label}-${uuidv4()}`;
+        this._timers.set(id, getHighResTime());
+        return id;
+    }
+    /**
+     * End timing an operation
+     *
+     * @param id - The identifier returned by startTimer
+     * @returns The duration in milliseconds
+     * @throws Error if the timer doesn't exist
+     */
+    endTimer(id) {
+        const startTime = this._timers.get(id);
+        if (!startTime) {
+            throw new Error(`Timer with id ${id} not found`);
+        }
+        const duration = getDuration(startTime);
+        this._timers.delete(id);
+        return duration;
+    }
+    /**
+     * Check if an operation exceeds the performance threshold
+     *
+     * @param duration - The duration in milliseconds
+     * @param threshold - The threshold to check against
+     * @returns Whether the operation is considered slow
+     */
+    isBottleneck(duration, threshold) {
+        const effectiveThreshold = threshold !== null && threshold !== void 0 ? threshold : this._defaultThreshold;
+        return duration > effectiveThreshold;
+    }
+    /**
+     * Get memory usage information
+     *
+     * @returns Memory usage in bytes
+     */
+    getMemoryUsage() {
+        const memoryUsage = process.memoryUsage();
+        return {
+            heapUsed: memoryUsage.heapUsed,
+            heapTotal: memoryUsage.heapTotal,
+            external: memoryUsage.external,
+            rss: memoryUsage.rss,
+        };
+    }
+    /**
+     * Get memory difference between two points
+     *
+     * @param before - Memory usage before
+     * @param after - Memory usage after
+     * @returns Memory difference in bytes
+     */
+    getMemoryDiff(before, after) {
+        return {
+            heapUsed: after.heapUsed - before.heapUsed,
+            heapTotal: after.heapTotal - before.heapTotal,
+            external: after.external - before.external,
+            rss: after.rss - before.rss,
+        };
+    }
+    /**
+     * Generate a suggestion for a bottleneck
+     *
+     * @param functionName - The name of the function
+     * @param duration - The duration in milliseconds
+     * @param memoryUsage - Memory usage in bytes
+     * @returns A suggestion for improving performance
+     */
+    generateSuggestion(functionName, duration, memoryUsage) {
+        // Simple heuristic-based suggestions
+        if (memoryUsage && memoryUsage > 10 * 1024 * 1024) {
+            return `🛠 Potential Fix: Check for memory leaks or large object allocations in ${functionName}`;
+        }
+        if (duration > 1000) {
+            return `🛠 Potential Fix: Consider optimizing or adding caching to ${functionName}`;
+        }
+        if (duration > 500) {
+            return `🛠 Potential Fix: Look for blocking operations in ${functionName}`;
+        }
+        return `🛠 Potential Fix: Review ${functionName} for performance optimizations`;
+    }
+}
+//# sourceMappingURL=performance.js.map

package/dist/esm/trackers/performance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance.js","sourceRoot":"","sources":["../../../src/trackers/performance.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9D,OAAO,EAAE,EAAE,IAAI,MAAM,EAAE,MAAM,MAAM,CAAC;AAEpC;;GAEG;AACH,MAAM,OAAO,kBAAkB;IAI7B;;;;OAIG;IACH,YAAY,UAAyC,EAAE;;QAR/C,YAAO,GAAkC,IAAI,GAAG,EAAE,CAAC;QASzD,IAAI,CAAC,iBAAiB,GAAG,MAAA,OAAO,CAAC,gBAAgB,mCAAI,GAAG,CAAC,CAAC,KAAK;IACjE,CAAC;IAED;;;;;OAKG;IACI,UAAU,CAAC,KAAa;QAC7B,MAAM,EAAE,GAAG,GAAG,KAAK,IAAI,MAAM,EAAE,EAAE,CAAC;QAClC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,EAAE,cAAc,EAAE,CAAC,CAAC;QACvC,OAAO,EAAE,CAAC;IACZ,CAAC;IAED;;;;;;OAMG;IACI,QAAQ,CAAC,EAAU;QACxB,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACvC,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CAAC,iBAAiB,EAAE,YAAY,CAAC,CAAC;QACnD,CAAC;QAED,MAAM,QAAQ,GAAG,WAAW,CAAC,SAAS,CAAC,CAAC;QACxC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAExB,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;;;;OAMG;IACI,YAAY,CAAC,QAAgB,EAAE,SAAkB;QACtD,MAAM,kBAAkB,GAAG,SAAS,aAAT,SAAS,cAAT,SAAS,GAAI,IAAI,CAAC,iBAAiB,CAAC;QAC/D,OAAO,QAAQ,GAAG,kBAAkB,CAAC;IACvC,CAAC;IAED;;;;OAIG;IACI,cAAc;QACnB,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;QAC1C,OAAO;YACL,QAAQ,EAAE,WAAW,CAAC,QAAQ;YAC9B,SAAS,EAAE,WAAW,CAAC,SAAS;YAChC,QAAQ,EAAE,WAAW,CAAC,QAAQ;YAC9B,GAAG,EAAE,WAAW,CAAC,GAAG;SACrB,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACI,aAAa,CAClB,MAA8E,EAC9E,KAA6E;QAE7E,OAAO;YACL,QAAQ,EAAE,KAAK,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ;YAC1C,SAAS,EAAE,KAAK,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS;YAC7C,QAAQ,EAAE,KAAK,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ;YAC1C,GAAG,EAAE,KAAK,CAAC,GAAG,GAAG,MAAM,CAAC,GAAG;SAC5B,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACI,kBAAkB,CACvB,YAAoB,EACpB,QAAgB,EAChB,WAAoB;QAEpB,qCAAqC;QACrC,IAAI,WAAW,IAAI,WAAW,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,EAAE,CAAC;YAClD,OAAO,2EAA2E,YAAY,EAAE,CAAC;QACnG,CAAC;QAED,IAAI,QAAQ,GAAG,IAAI,EAAE,CAAC;YACpB,OAAO,8DAA8D,YAAY,EAAE,CAAC;QACtF,CAAC;QAED,IAAI,QAAQ,GAAG,GAAG,EAAE,CAAC;YACnB,OAAO,qDAAqD,YAAY,EAAE,CAAC;QAC7E,CAAC;QAED,OAAO,4BAA4B,YAAY,gCAAgC,CAAC;IAClF,CAAC;CACF"}

package/dist/esm/types/config.d.ts

@@ -0,0 +1,110 @@
+/**
+ * LogLevel - Defines the severity levels for logging
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * LogMode - Defines the operational modes for the logger
+ */
+export type LogMode = 'dev' | 'staging' | 'prod' | string;
+/**
+ * Transport - Interface for log output destinations
+ */
+export interface ITransport {
+    /**
+     * Write a log entry to the destination
+     *
+     * @param entry - The formatted log entry to write
+     */
+    write(entry: string): void;
+}
+/**
+ * Formatter - Interface for log formatters
+ */
+export interface IFormatter {
+    /**
+     * Format a log entry
+     *
+     * @param level - The log level
+     * @param message - The log message
+     * @param args - Additional arguments
+     * @param meta - Metadata for the log entry
+     * @returns The formatted log entry
+     */
+    format(level: LogLevel, message: string | object, args: any[], meta: LogMeta): string;
+}
+/**
+ * LogMeta - Metadata for log entries
+ */
+export interface LogMeta {
+    timestamp: Date;
+    level: LogLevel;
+    indentLevel: number;
+    [key: string]: any;
+}
+/**
+ * TrackOptions - Options for function execution tracking
+ */
+export interface ITrackOptions {
+    /**
+     * Custom label for the tracked function
+     */
+    label?: string;
+    /**
+     * Performance threshold in milliseconds
+     * Functions exceeding this threshold will be flagged as bottlenecks
+     */
+    threshold?: number;
+    /**
+     * Whether to include memory usage tracking
+     */
+    includeMemory?: boolean;
+    /**
+     * Whether to suppress logging for this tracking
+     */
+    silent?: boolean;
+}
+/**
+ * LoggerConfig - Configuration options for the logger
+ */
+export interface ILoggerConfig {
+    /**
+     * Operational mode
+     * @default 'dev'
+     */
+    mode?: LogMode;
+    /**
+     * Minimum log level to display
+     * @default 'debug'
+     */
+    level?: LogLevel;
+    /**
+     * Whether to colorize output
+     * @default true
+     */
+    colorize?: boolean;
+    /**
+     * Whether to include timestamps in logs
+     * @default true
+     */
+    timestamp?: boolean;
+    /**
+     * Default performance threshold in milliseconds
+     * @default 100
+     */
+    performanceThreshold?: number;
+    /**
+     * Number of spaces for each indentation level
+     * @default 2
+     */
+    indentSize?: number;
+    /**
+     * Log output destinations
+     * @default [ConsoleTransport]
+     */
+    transports?: ITransport[];
+    /**
+     * Log formatters
+     * @default [CliFormatter]
+     */
+    formatters?: IFormatter[];
+}

package/dist/esm/types/config.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=config.js.map

package/dist/esm/types/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../src/types/config.ts"],"names":[],"mappings":""}

package/dist/esm/types/index.d.ts

@@ -0,0 +1,34 @@
+export * from './config';
+export * from './logger';
+/**
+ * Options for tracking function execution
+ */
+export interface ITrackOptions {
+    /**
+     * Custom label for the function
+     */
+    label?: string;
+    /**
+     * Performance threshold in milliseconds
+     */
+    threshold?: number;
+    /**
+     * Whether to include memory usage in the tracking
+     */
+    includeMemory?: boolean;
+    /**
+     * Whether to track nested function calls
+     *
+     * Note: This option doesn't automatically track all nested function calls.
+     * It only enables the infrastructure for tracking nested calls, but you still
+     * need to manually track each nested function using one of the approaches
+     * described in the documentation.
+     *
+     * @default true
+     */
+    enableNestedTracking?: boolean;
+    /**
+     * Whether to suppress logging
+     */
+    silent?: boolean;
+}

package/dist/esm/types/index.js

@@ -0,0 +1,3 @@
+export * from './config';
+export * from './logger';
+//# sourceMappingURL=index.js.map

package/dist/esm/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}