Viztracer

VizTracer is a Python runtime instrumentation system and execution profiler used to trace and visualize code execution. It functions as a multi-process performance analyzer and trace visualizer, providing an interactive timeline and flamegraph interface to identify performance bottlenecks and analyze call sequences.

The project distinguishes itself by its ability to aggregate execution data from multiple threads, subprocesses, and asynchronous tasks into a single unified report. It also features live process instrumentation, allowing users to attach to and detach from running Python applications to capture runtime data without restarting the process.

The tool covers a broad range of observability capabilities, including the recording of function arguments, return values, and variable assignments. It monitors concurrent execution flow, tracks garbage collection activity, and logs hardware events for machine learning workloads. Additionally, it can intercept standard print calls and logging module output, routing them directly into the trace event stream.

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.

google/perfetto

5,558View on GitHub

Perfetto is a platform for system-level performance tracing and analysis on Linux and Android. It combines a high-throughput trace recorder, a SQL-based query engine, and a browser-based visualizer into a single toolchain. The platform covers CPU scheduling and call-stack profiling, native and Java heap memory allocation tracking, GPU and graphics events, and system-wide counters such as CPU frequency and power consumption. The architecture decouples trace recording from offline analysis, using a compact protobuf format for event encoding and columnar storage for efficient SQL queries. The we

iovisor/bcc

22,459View on GitHub

BCC is an eBPF development toolkit and tracing framework used for monitoring and analyzing the Linux kernel. It functions as a performance analysis tool and debugging utility to capture system events, measure kernel latency, and provide network observability. The project distinguishes itself by providing a build system that integrates with LLVM to compile C-like code into BPF bytecode at runtime. It utilizes BPF Type Format data for relocations to maintain cross-kernel compatibility and extracts kernel headers to ensure the generated programs match the specific kernel version. The toolkit co

cool-RR/PySnooper

16,604View on GitHub

PySnooper is a diagnostic library for Python that tracks variable values and execution flow to provide a detailed history of program state. By applying decorators to functions, generators, or classes, it logs line-by-line execution and state changes without requiring manual print statements. The tool distinguishes itself through its ability to monitor nested function calls and concurrent operations in multi-threaded applications. It captures execution context by accessing the current stack frame, allowing for the inspection of local variables and the evaluation of arbitrary expressions during

pydantic/logfire

4,034View on GitHub

Logfire is an OpenTelemetry observability platform and Python application monitoring tool. It provides a suite of tools for collecting, storing, and querying spans, logs, and metrics to monitor application performance and execution. The platform features a specialized monitor for Pydantic data validation, tracking data flow and validation outcomes in real time. It also includes a telemetry analysis tool that uses standard SQL to query observability data and connect to business intelligence tools. The system provides automatic instrumentation for Python libraries and frameworks, allowing for

gaogaotiantianviztracer

Features