bloomberg/memray
Memray
Memray is a memory profiler for Python that tracks heap allocations in both Python code and native C or C++ extensions. It captures memory events by hooking into the language runtime and traversing call stacks, providing a comprehensive view of how an application consumes memory. The tool is designed to minimize performance impact on the target application by using thread-local buffering and streaming data to an external process or file.
The project distinguishes itself through its ability to monitor complex, multi-threaded systems and child processes in real-time. It provides diagnostic utilities that allow developers to attach to running processes, filter memory data by specific threads, and visualize allocation patterns through interactive flame graphs. These graphs support temporal inspection, enabling users to analyze memory usage across specific time intervals during execution.
Beyond live monitoring, the tool includes mechanisms for automated memory validation and regression testing. It can detect memory leaks by identifying objects that remain in memory at the end of a session and allows developers to enforce resource consumption thresholds within continuous integration pipelines. The profiler also generates detailed statistics and hierarchical call graphs, which help pinpoint inefficient allocation patterns such as frequent, short-lived object creation.
Features
- Memory Profiling - Analyzes and optimizes heap allocation patterns in Python applications to identify memory leaks.
- Memory Profilers - Tracks and visualizes heap allocations in Python and native extensions to identify memory leaks.
- Memory Profilers - Observing live memory allocation statistics in a terminal interface to understand the immediate impact of specific code operations on system resources.
- Flame Graph Visualizers - Generates interactive flame graphs from captured profiling data to provide a visual representation of memory consumption.
- Memory Regression - Integrates memory tracking into automated test runs to detect memory regressions or leaks.
- Memory Leak Detection - Identifies objects remaining in memory at the end of a session to detect potential memory leaks.
- Native Stack Unwinders - Traverses the call stack of both managed and native code frames to map memory events to specific source code locations.
- Memory Allocation Tracers - Hooks into low-level memory allocation functions to capture and record heap allocation events.
- Temporal Memory Profilers - Creates temporal flame graphs to visualize memory usage and allocation patterns across specific time intervals.
- Live Process Profilers - Connects to an active application to monitor and record memory allocation patterns in real-time.
- Memory Usage Analyzers - Fails automated tests that exceed defined memory thresholds and provides detailed breakdown of responsible functions.
- Flame Graph Generators - Transforms raw memory allocation data into interactive flame graphs for analyzing peak memory usage.
- Performance Regression Analyzers - Integrates memory usage checks into test suites to automatically detect and prevent performance regressions.
- System Monitoring And Profiling - High-performance memory profiler for tracking allocations in Python.
- Concurrent Memory Profilers - Tracks memory usage across both Python and native threads to provide a complete view of memory activity.
- Memory Usage Analysis - Summarizes total allocations and memory distribution to help identify memory-intensive operations.
- Performance Analysis Tools - Monitors resource consumption and identifies high-impact functions within complex software environments.
- Real-Time Monitoring Dashboards - Displays live memory usage statistics while code executes to help observe the immediate impact of operations.
- Child Process Memory Tracers - Automatically captures memory allocation data for child processes created via forks.
- Concurrent Execution Monitors - Tracks and isolates memory allocation patterns across multiple threads and child processes.
- Native Memory Lifecycle Management - Captures memory allocation data from native extensions alongside Python code.
- Thread-Aware Memory Analyzers - Filters memory allocation data by individual threads to isolate and investigate specific memory usage patterns.
- Allocation Frequency Analyzers - Identifies short-lived or high-frequency object allocations to help pinpoint inefficient memory usage patterns.
- Native C Interoperability - Traces memory usage across both Python code and native C or C++ extensions.
- Symbol Resolution Engines - Translates raw memory addresses into human-readable function names and line numbers using debug information.
- Remote Profiling Interfaces - Connects a monitoring interface to a running application process to observe memory behavior remotely.
- Stack Trace Hierarchy Visualizers - Displays interactive tree representations of memory allocations at peak usage to identify high-memory source locations.
- Profiling Visualization Filters - Hides low-level implementation details or internal tool frames from visualization reports to reduce noise and focus on application-level code during performance analysis.
