Tencent/matrix

Features

• Mobile Performance Monitoring - Provides a comprehensive framework for tracking crashes, lags, and memory leaks in real time for mobile apps.
• Application Performance Monitoring - Implements a plugin-based monitoring system for tracking crashes, lags, and memory leaks in mobile applications.
• Bytecode and Instrumentation - Implements bytecode modification during compilation to inject performance tracking and call stack recording.
• Crash Monitoring - Provides a system for capturing and reporting detailed application crash logs in JSON format.
• Application Lag Detection - Tracks hanging or lagging execution patterns and provides detailed diagnostic logs with report IDs.
• Package Composition Analysis - Inspects oversized files and inefficient image formats within the application package to reduce the footprint.
• Native Stack Unwinders - Generates native call stacks using simplified unwind tables derived from DWARF and ARM debug data.
• ANR Detection - Identifies Application Not Responding events and generates stable trace files to pinpoint the cause.
• APK Asset Auditing - Identifies redundant resources and unused assets within APKs using custom checking rules.
• Binary Bloat Analysis - Inspects APKs for unused resources and redundant classes to optimize binary size.
• Mobile Binary Analysis - Provides static analysis to identify unused assets and oversized files to reduce the installation package size.
• Asset - Detects unused assets and verifies resource obfuscation to eliminate waste and reduce package size.
• Heap Corruption Detection - Identifies heap memory access overlaps, use-after-free, and double-free issues using memory sanitizers.
• Memory Allocation Tracers - Tracks memory allocation patterns and stack calls during high-memory events to locate leaks.
• Native Application Debugging - Identifies memory leaks, use-after-free errors, and double-frees in native libraries without recompilation.
• Native Hooking Frameworks - Intercepts system calls and native library functions to monitor IO performance and detect memory leaks.
• PLT Hooking - Patches the procedure linkage table to intercept system calls and monitor binaries without recompilation.
• Native Memory Debuggers - Identifies memory leaks and heap corruption in native libraries without requiring source code recompilation.
• Binary Size Optimizations - Finds binary optimization opportunities by checking for uncompressed files and missing image alpha channels.
• Mobile App Binary Size Optimization - Analyzes application packages to find unused assets and redundant resources to reduce installation size.
• Plugin-Based Architectures - Provides a modular plugin interface to collect telemetry and route performance data to custom backends.
• Telemetry Plugins - Uses a modular interface specifically to collect performance data from various sources.
• Application Hang Detection - Monitors the Runloop status to identify stuck applications and capture time-consuming thread stacks.
• Execution Time Profilers - Measures function execution times using bytecode modification to identify slow functions and interface blocks.
• Execution Tracing - Records the sequence of function calls and execution times for long-running methods during startup.
• Slow Function Identification - Captures execution time and call stacks for long-running methods during activity transitions or ANRs.
• Application Performance Profiling - Measures frame rates, startup times, and main thread blocking to eliminate interface stuttering.
• Memory Leak Detection - Tracks memory allocation and call stacks during out-of-memory events to find sources of exhaustion.
• Native - Identifies memory leaks in native libraries using hooking techniques without requiring code recompilation.
• Performance Profilers - Tracks frame rates, startup speed, and main-thread blocking to resolve interface stuttering.
• Runloop Hang Detection - Monitors the application runloop status to identify main thread blocks and capture time-consuming execution stacks.
• Structured Log Analysis - Produces structured data from crashes and lags, including energy-consuming stacks for bottleneck analysis.
• Query Auditing Tools - Scans database operations for inefficiencies such as full table scans and missing indices.
• Database Query Optimizations - Identifies inefficient database queries and provides optimization advice to improve performance.
• Query Optimizers - Detects full table scans and missing prepared statements in database queries to improve retrieval speed.
• SQL Query Optimizations - Inspects database operations to detect full table scans and inefficient SQL patterns.
• SQLite Query Linters - Scans database statements for full table scans and missing indexes to optimize retrieval speed.
• Startup Timers - Measures and tracks startup latency across different stages to identify boot performance bottlenecks.
• Battery Status Monitors - Monitors mobile device power usage through a flexible API to identify battery-draining behavior.
• Runtime Bytecode Instrumentation - Modifies application code during compilation to inject performance tracking and call stack recording.
• Activity Leak Analysis - Identifies leaking activities and provides cropped heap profiles to pinpoint the source of leaks.
• UI Blockage Detection - Identifies slow functions blocking the UI by recording execution costs and call stacks.
• Disk IO Observability - Detects inefficient system calls and unclosed file descriptors that cause application bottlenecks.
• Energy Consumption Analyzers - Captures stack traces related to high power consumption to identify energy-inefficient code paths.
• Observability Data Aggregators - Captures probe data and routes it to custom listeners for external reporting and analysis.
• IO Bottleneck Detection - Detects disk and network IO issues using system-level hooks to identify bottlenecks on real devices.
• Object Allocation Profilers - Records every object creation and its associated callstack to diagnose the cause of OOM errors.
• Frame Rate Monitors - Calculates frames per second and quantifies frame drops to identify UI lag and stuttering.
• Disk I/O Performance Analysis - Monitors file system operations to detect main-thread blocking and unclosed file handles.
• Power Consumption Monitoring - Deno Monitoring & Observability records energy-consuming call stacks in JSON format to identify specific code paths causing battery drain.
• Thread Leak Detection - Identifies leaks in Java and native threads and reduces virtual memory overhead by trimming stack sizes.

Star history