View detailed information

Procedure

1. Log on to the EMAS Management Console. Select Application Monitoring and click to enter the Application Monitoring console.

2. In the navigation pane on the left, choose Application Monitoring - Crash Analysis. Then, select Crash, Stuttering, or Exception.

3. Set the required filters and click Query.

4. In the Crash List section, click a crash name to open the crash aggregation analysis page.

Page overview

The left side of the details page lists all error instances that share the same crash name. When you click an instance, the right side displays its Basic Information, Error Stack, Contextual Data, ConsoleLog, Custom Log, Process Information, and Symbol Table.

Page features

On this page, you can use the Resymbolicate and Search Instance features.

• Resymbolicate: Reruns the symbolication process.

• Search Instance: Searches for a specific crash instance by device Utdid.

Basic information

Basic information shows details about the device where each error instance occurred.

Error stack

The error stack provides the detailed stack trace reported when the crash occurred. This information is crucial for analyzing and resolving crash issues.

• If no symbol table is uploaded, the original stack is displayed. After a symbol table is uploaded and parsed, the restored stack is displayed.

• If the symbol table or parsing is incorrect, click Resymbolicate on the Symbol Table page.

• By default, the restored stack expands the thread stack where the crash occurred. If the current thread stack does not provide enough information to locate the problem, click Expand Call Stack to view other thread stacks.

• You can search the stack, download the full stack, and copy the full stack or individual thread stacks.

Stuttering flame graph, stack tree, and time slice

The error stack for stuttering supports three different visualizations: flame graph, stack tree, and time slice.

When troubleshooting stuttering issues, developers should use these three views along with three key time metrics: total stuttering duration, key stack duration, and maximum leaf node duration.

The current stack capture interval is 300 ms.

In the flame graph, the x-axis represents relative time, and the y-axis represents the call depth. The width of a function block reflects its execution duration. Colors distinguish between system and business stacks.

The following figure illustrates a stack tree.

Time slice analysis displays data in the order it was collected. Adjacent call stack fragments with identical content are automatically merged.

On-site data

This section displays the context of the crash instance, including basic information, memory information, and custom data.

Consolelog

This section shows the console log data from the device, captured before and after the crash occurred.

Custom log

Shows custom logs reported through SDK callbacks at the time of the crash.

If you have integrated Remote Log Access, you can click Retrieve Logs for This Device to quickly create a log retrieval task.

Process information

Shows process-related information at the time of the crash, including Maps info, Meminfo, process status, and FD info.

• Maps info shows the memory mapping of the user process at runtime. You can filter for specific memory segments by address and access permissions.

• Meminfo shows detailed memory usage statistics. You can use this information to find memory allocation abnormalities and optimize memory usage.

  • Memory statistics dimensions

    Located on the x-axis of the statistics table, these dimensions describe the physical properties and sharing status of memory pages.

    Parameter	Description
    Pss Total	Proportional Set Size. The total actual physical memory consumed by the application, including private memory and proportionally shared memory.
    Private Dirty	Private dirty memory. Physical memory that is exclusive to the application and has been modified. It cannot be directly reclaimed by the system and represents the core cost of the process.
    Private Clean	Private clean memory. Physical memory that is exclusive to the application but has not been modified. The system can reclaim it directly under pressure.
    SwapPss Dirty	Proportional swap space usage. The amount of memory swapped to ZRAM or compressed storage, proportionally allocated to the application.

  • Memory partitions

    Located on the y-axis of the statistics table, these partitions describe the logical source of memory usage.

    Parameter	Description
    Native Heap	Native heap memory. Memory requested by C/C++ code through malloc/new, including Bitmap pixel data on Android 8.0+.
    Dalvik Heap	Java heap memory. Memory space allocated by the virtual machine for Java/Kotlin objects.
    Dalvik Other	Other virtual machine overhead. Internal memory required for the virtual machine to run, including JIT code cache and GC management data.
    Stack	Thread stack. The total stack space required for all active threads in the application to run.
    Cursor	Database cursor. A buffer area used to store the result set during a SQLite database query.
    Ashmem	Anonymous shared memory. Space allocated by the Android-specific anonymous shared memory (Ashmem) mechanism, used for large data transfers between processes.
    Gfx dev	Graphics driver mapping. A memory region mapped to the process space by the graphics card driver, typically used for graphics data interaction with the GPU.
    Other dev	Other device mapping. Memory regions mapped to the process space by hardware drivers other than the graphics card driver.
    .so mmap	Native library mapping. The mapping in memory of C/C++ dynamic-link libraries (.so files) loaded by the application.
    .jar mmap	Java library mapping. The mapping in memory of Java archive files (.jar files) loaded by the application.
    .apk mmap	APK mapping. The mapping in memory of the application's installation package file (.apk) and its internal resources.
    .ttf mmap	Font mapping. The mapping in memory of font resource files (.ttf or .otf) loaded by the application.
    .dex mmap	Bytecode mapping. The mapping in memory of the Dalvik Executable (.dex) files executed by the Dalvik virtual machine.
    .art mmap	ART image mapping. The mapping in memory of the preloaded class information and object image (Boot Image) by the ART virtual machine.
    .oat mmap	Compiled code mapping. The mapping in memory of the machine code file (.oat) after Ahead-Of-Time (AOT) compilation.
    Other mmap	Other file mapping. Other files or memory regions mapped by the application using mmap, other than the types listed above.
    EGL mtrack	EGL memory tracking. Graphics buffer (Surface) and display memory usage reported by the graphics driver.
    GL mtrack	OpenGL memory tracking. Texture and vertex buffer memory usage reported by the graphics driver.
    Other mtrack	Other memory tracking. Other hardware memory usage reported by drivers that is not classified as EGL or GL.
    Unknown	Unknown mapping. Anonymous memory mappings that cannot be clearly identified and classified by the system.
    Total	Total memory usage. The sum of the physical usage for all the preceding partitions across each metric dimension.

• Process status shows a detailed list of the process status at the time of the crash.

• FD info shows the file descriptor (FD) usage status at the time of the crash.

  • Parameter	Description
    Current number of used FDs	Used to determine if the process is close to FD exhaustion.
    Maximum available FDs for the process	A reference baseline.
    Usage rate	Formula: Current number of used FDs / Maximum available FDs for the process.
    FD type	The category name.
    Quantity	The number of FDs in this category.
    Percentage	Quantity / Current number of used FDs × 100%.
    Details	The original link information for all FDs in this category.

Symbol table

Uploading symbol table files to the Crash Analytics console lets you de-obfuscate crash call stacks for easier problem analysis and resolution.

You can upload and download a symbol table.