gaogaotiantian/viztracer

Features

• Python Profilers - Measures execution time and identifies bottlenecks in Python code using interactive timelines and flamegraphs.
• Execution Flow Visualizations - Generates an interactive timeline of code execution to identify bottlenecks and analyze call sequences.
• Execution Tracing - Records the sequence of operations and function calls executed by a program to generate a visual timeline of execution.
• Runtime Variable Trackers - Logs the current value of a variable as a counter or timestamped event for state inspection.
• Runtime Value Capture - Logs function arguments, return values, and variable attributes dynamically without requiring modifications to the source code.
• Concurrent Execution Tracing - Captures flow across multiple threads, subprocesses, and tasks to analyze parallel behavior in a single report.
• Tracing Debuggers - Injects tracing and variable tracking into live Python processes without requiring application restarts.
• Asynchronous Tracing - Provides asynchronous tracing that visualizes tasks as individual threads to separate work from the event loop.
• Multi-Process Trace Orchestrators - Aggregates execution data from multiple threads, subprocesses, and asynchronous tasks into a single unified timeline.
• Multi-Process Debugging - Analyzes concurrent execution across threads, subprocesses, and asynchronous tasks within a single unified report.
• Live Process Profilers - Allows attaching to and detaching from active Python applications to profile them in real-time.
• Variable Assignment Tracers - Records the value of variables matching a regex pattern whenever they are assigned during execution.
• Interpreter Frame Instrumentation - Captures function entry and exit events by hooking into the Python interpreter's call stack and execution loop.
• Low-Overhead Runtime Event Streaming - Implements low-overhead runtime event streaming using source code comments to minimize performance impact during tracing.
• Multi-Process Trace Aggregation - Captures execution data from subprocesses and pools, aggregating the results into a single unified report.
• Multi-Threaded Trace Aggregation - Records execution across native threads and provides a mechanism to enable tracing for non-native implementations.
• Multi-Process Performance Analyzers - Aggregates execution data from multiple Python threads, subprocesses, and asynchronous tasks for performance analysis.
• Python Language Runtimes - Records function arguments, return values, and variable assignments during Python program execution.
• Process Attachment Tools - Injects tracing logic into running processes using system-level calls to capture runtime data without restarts.
• Trace Report Aggregators - Combines multiple separate trace files from different processes into a single unified visualization.
• User-Space Function Tracing - Instruments user-space functions to mark the timeline with instant events whenever specific functions are entered.
• Trace Visualizers - Renders execution logs into an interactive browser interface or flamegraph to analyze timing and bottlenecks.
• Attribute Pattern Monitoring - Tracks variable assignments and object changes by matching specific naming patterns during instrumentation.
• Asynchronous Task Visualization - Provides visual representations of asynchronous task execution and event loop transitions to analyze non-blocking concurrency.
• Process Attachment - Connects to an active process remotely to start tracing execution without requiring an application restart.
• Hardware - Records native GPU calls and hardware events to analyze performance for machine learning workloads.
• Trace Exception Recording - Captures all raised exceptions and integrates them as events within the context of the execution trace.
• Attribute Change Tracing - Records changes to specific object attributes matching a regex pattern as instant events on the timeline.
• Standard Output Interceptors - Intercepts standard print function calls and records the output as events on the execution timeline.
• Execution Duration Tracking - Marks specific blocks of code with start and end times to visualize execution duration.
• Local Variable Tracing - Records all variable assignments occurring within specified functions and includes them in entry details.
• Trace Volume Filtering - Limits the volume of captured data by filtering based on duration, stack depth, file paths, and language.
• Instrumentation Detachments - Removes tracing instrumentation from a live process to stop data collection and reclaim resources.
• Numerical Data Recorders - Records numeric variable assignments as counter events to visualize value trends over time.
• Sparse Trace Recording - Records only specifically decorated functions to provide a high-level timing overview without tracing every call.
• Garbage Collection Monitors - Tracks memory management events and pause times of the garbage collector to detect cycle reference collection.
• Logging Integrations - Adds a custom handler to the logging module to route messages directly into the trace report.
• Function IO Tracing - Records the string representations of function arguments and return values for every function call.
• Execution Trace Visualizers - Provides an interactive timeline and flamegraph interface for analyzing Python function calls and execution durations.
• Trace Report Rendering - Converts raw execution logs into a browser-compatible JSON format for interactive call hierarchy visualization.

Istoric stele