How to get longer stack dump (tombstone) from android?

Introduction

Stack dumps, also known as tombstones, provide invaluable insights into app crashes.
However, the default stack dump size in Android can often be limited, hindering
effective debugging. This article delves into techniques for obtaining more
comprehensive stack dumps from your Android device.

Default Stack Dump Size Limitations

The default stack dump size in Android is typically limited, which can
make it difficult to identify the root cause of a crash. This is because:

• Limited memory: The device may have limited storage space to accommodate a
  large stack dump.
• Performance concerns: Large stack dumps can impact device performance,
  especially on older devices with less powerful hardware.
• Security considerations: Storing large stack dumps on the device could
  pose a security risk, particularly if the device is compromised.

Strategies for Obtaining Longer Stack Dumps

1. Using Logcat

Logcat is a powerful tool that captures system logs, including stack traces
from crashes. You can increase the stack trace size by configuring
logcat to capture more log lines. Here’s how:

adb shell logcat -v time -b main -s crash -r 10000

This command:

• -v time: Sets the log format to include timestamps.
• -b main: Specifies the main log buffer to capture data.
• -s crash: Filters log messages related to crashes.
• -r 10000: Sets the maximum number of lines to be captured.

This will enable you to capture significantly more log lines, potentially
containing a longer stack trace.

2. Using the Debugger

When debugging your app, you can use the debugger to obtain a more detailed
stack trace. You can leverage the following techniques:

• Breakpoints: Set breakpoints in your code to halt execution
  at specific points. This will give you more control over the execution
  flow and allows you to examine the call stack at various stages.
• Step-by-step debugging: Use the debugger’s “step over” and
  “step into” functionalities to traverse your code line by line. This enables
  you to analyze the state of the application and inspect variables at each
  step, aiding in pinpointing the source of the crash.

Debugger tools provide an interactive environment to monitor your app’s
execution, facilitating a more detailed investigation of crashes.

3. Using System Properties

Android allows you to modify system properties to influence stack dump
behavior. The following properties can be helpful:

a. persist.sys.crash.dump.size

This property determines the maximum size of the stack dump (in bytes).
Setting it to a higher value can increase the stack dump size.

adb shell setprop persist.sys.crash.dump.size 1048576

This command sets the stack dump size to 1MB.

b. debug.log.stacktrace.size

This property specifies the maximum number of stack frames to be
captured in a stack trace. Increasing this value can result in a longer
stack dump.

adb shell setprop debug.log.stacktrace.size 1000

This command sets the maximum stack trace size to 1000 frames.

4. Using Third-Party Tools

Several third-party tools offer features to enhance stack dump
generation and analysis:

• Android Studio: Provides a comprehensive debugging
  environment with advanced profiling and crash analysis capabilities.
• Firebase Crashlytics: Offers detailed crash reporting, stack
  trace analysis, and symbolication for easier crash debugging.

These tools offer features like:

• Increased stack trace depth
• Symbolication for converting raw addresses to meaningful function names
  and line numbers
• Visualization of call stacks for easier understanding
• Crash reporting and analysis to streamline the debugging process

Choosing the Right Approach

The most suitable method for obtaining longer stack dumps depends on your
specific needs and the nature of the crash. Refer to the table below for a
comparison of the available techniques.

Conclusion

By leveraging the techniques described above, you can obtain more comprehensive
stack dumps from your Android device, significantly aiding in the debugging
process. Choose the method that best aligns with your debugging workflow
and the nature of the crash to uncover the root cause and effectively resolve
issues.