Struct MemScope 

pub struct MemScope {
    pub event_store: Arc<EventStore>,
    pub capture: Arc<CaptureEngine>,
    pub metadata: Arc<MetadataEngine>,
    pub snapshot: Arc<SnapshotEngine>,
    pub query: Arc<QueryEngine>,
    pub analysis: Arc<Mutex<AnalysisEngine>>,
    pub timeline: Arc<TimelineEngine>,
    pub render: Arc<RenderEngine>,
}

MemScope - Unified facade for all engines

MemScope provides a simple, unified interface for memory tracking, analysis, and visualization. It integrates all 9 engines into a single, easy-to-use API.

Key properties:

• Simple: One-stop interface for all functionality
• Powerful: Access to all engines when needed
• Type-safe: Strong typing throughout
• Thread-safe: All operations are thread-safe

Fields

event_store: Arc<EventStore>

Event Store - Centralized event storage

capture: Arc<CaptureEngine>

Capture Engine - Event capture backend

metadata: Arc<MetadataEngine>

Metadata Engine - Centralized metadata management

snapshot: Arc<SnapshotEngine>

Snapshot Engine - Snapshot construction and aggregation

query: Arc<QueryEngine>

Query Engine - Unified query interface

analysis: Arc<Mutex<AnalysisEngine>>

Analysis Engine - Memory analysis logic (wrapped in Mutex for interior mutability)

timeline: Arc<TimelineEngine>

Timeline Engine - Time-based memory analysis

render: Arc<RenderEngine>

Render Engine - Output rendering

Implementations

impl MemScope

pub fn new() -> Self

Create a new MemScope instance

This creates all engines with default settings and connects them together in the correct configuration.

pub fn with_backend(backend_type: CaptureBackendType) -> Self

Create a new MemScope instance with a specific capture backend

Arguments

• backend_type - The type of capture backend to use

pub fn register_analyzer(&self, analyzer: Box<dyn Analyzer>)

Register an analyzer with the analysis engine

Arguments

• analyzer - The analyzer to register

pub fn summary(&self) -> QueryResult

Get a summary of current memory usage

pub fn top_allocations(&self, limit: usize) -> QueryResult

Get top allocations by size

Arguments

• limit - Maximum number of allocations to return

pub fn render_json(&self, verbose: bool) -> Result<RenderResult, String>

Render current snapshot to JSON

Arguments

• verbose - Whether to include verbose output

pub fn clear(&self)

Clear all events and reset state

pub fn event_count(&self) -> usize

Get the total number of events

pub fn register_detector<D>(&self, detector: D)

where D: Detector + Send + Sync + 'static,

Register a detector with the analysis engine

This method automatically wraps the detector in an adapter and registers it as an analyzer.

Arguments

• detector - The detector to register

pub fn run_detectors(&self) -> Vec<AnalysisResult>

Run all registered detectors and return the results

Returns

A vector of analysis results from all detectors

pub fn run_leak_detector(&self) -> DetectionResult

Run the leak detector on the current snapshot

Returns

Detection results from the leak detector

pub fn run_uaf_detector(&self) -> DetectionResult

Run the UAF (Use-After-Free) detector on the current snapshot

Returns

Detection results from the UAF detector

pub fn run_overflow_detector(&self) -> DetectionResult

Run the overflow detector on the current snapshot

Returns

Detection results from the overflow detector

pub fn run_safety_detector(&self) -> DetectionResult

Run the safety detector on the current snapshot

Returns

Detection results from the safety detector

pub fn run_lifecycle_detector(&self) -> DetectionResult

Run the lifecycle detector on the current snapshot

Returns

Detection results from the lifecycle detector

pub fn export_html_with_template<P: AsRef<Path>>( &self, path: P, template: DashboardTemplate, ) -> Result<(), String>

Export the current memory snapshot as an HTML dashboard with a specific template

Arguments

• path - Directory path where the HTML file will be saved
• template - The dashboard template to use

Returns

Result indicating success or failure

pub fn export_html<P: AsRef<Path>>(&self, path: P) -> Result<(), String>

Export the current memory snapshot as an HTML dashboard

This method automatically detects program characteristics and selects the most appropriate template:

• Multithread: If the program uses multiple threads
• Binary: Default template for single-threaded programs

Arguments

• path - Directory path where the HTML file will be saved

Returns

Result indicating success or failure

pub fn export_json<P: AsRef<Path>>(&self, path: P) -> Result<(), String>

Export all JSON files

This method exports 9 JSON files containing comprehensive memory analysis:

• memory_analysis.json: Complete memory allocation analysis
• lifetime.json: Ownership and lifetime tracking
• ownership_graph.json: Ownership graph analysis with cycle detection
• system_resources.json: System resource monitoring
• thread_analysis.json: Thread-specific memory stats
• unsafe_ffi.json: Unsafe FFI boundary tracking
• memory_passports.json: Memory lifecycle passports
• leak_detection.json: Potential memory leaks
• async_analysis.json: Async task analysis

Arguments

• path - Directory path where JSON files will be saved

Returns

Result indicating success or failure

Trait Implementations

impl Default for MemScope

fn default() -> Self

Returns the “default value” for a type.