Skip to main content
Flashduty Native RUM Insights dashboard provides out-of-the-box visualization dashboards that automatically collect and analyze multi-dimensional data including user sessions, app performance, crash errors, and network requests. This helps you gain comprehensive insights into your mobile app’s real-world performance, quickly identify performance bottlenecks and issues, and continuously optimize user experience.
The Insights dashboard includes 4 core analysis dimensions: Overview, Performance Analysis, Error Analysis, Resource Analysis
Platform DifferencesThe Native dashboard applies to Android, iOS, HarmonyOS, Flutter, and React Native apps, with the following platform-specific differences:
  • Flutter / React Native: One Flutter or React Native app spans both Android and iOS. The filter bar therefore also pins the os_name filter so you can slice metrics by device OS. In the Overview and Error Analysis, the ANR Rate (from Android devices) and Unresponsive Time Rate (from App Hangs on iOS devices) cards are displayed side by side.
  • HarmonyOS: The SDK does not report performance or hang metrics yet, so hang-related cards are hidden and the “Performance” tab is not available.
  • Electron: Does not use the Native dashboard — Electron apps reuse the Web Insights dashboard, but UV counts distinct anonymous IDs (the Electron SDK does not report a user ID). See “Metrics Reference” below.

Overview

Native RUM Insights Overview showing UV, sessions, crash rate and other core health metrics
The Overview module focuses on core metrics across multiple dimensions for mobile apps:
  • Traffic Metrics - Monitor UV (Unique Visitors) and sessions to understand overall user activity trends
  • Core Health Metrics - Highlight three key mobile app metrics: crash count, crash rate, and unresponsive time rate for quick identification of stability issues
  • User Access Trends - Track UV and Session trends over time through time-series charts to understand user activity patterns
  • User Distribution - Analyze user sources by geographic location to understand regional user activity
  • Session Analysis - Track average session duration distribution trends to evaluate user engagement and usage depth
  • Version Distribution - Monitor user distribution across different system versions (Android/iOS) and app versions to support compatibility optimization and version iteration

Performance analysis

Performance analysis dashboard showing startup time, frame rate, CPU and memory usage metrics
The Performance Analysis module focuses on full-chain monitoring of core experience metrics including app startup, page rendering, and interaction smoothness.

Core performance metrics

The top section displays P75 percentile values for the metrics the platform reports:
  • App Startup Time (P75): Monitor the P75 percentile of app startup duration to evaluate startup performance. Startup time directly impacts user first impressions and willingness to use the app.
  • Frame Rate (P75): Display the P75 percentile of runtime frame rate to measure visual smoothness. Target is 60fps; higher values indicate smoother interactions. The SDKs normalize per-frame samples from high-refresh-rate screens (ProMotion, 120Hz Android devices) to a 60fps baseline and cap them at 60. The metric shows relative smoothness, not the display’s physical refresh rate.
  • CPU Usage (P75): CPU usage of the app process while the view is in the foreground, normalized by core count so it compares across device models. 100% means every core was busy with this app for the whole period, and a high value points to compute-heavy work or busy waiting. Shown for iOS apps only, and requires iOS SDK 0.9.0 or later; otherwise the card reports no data.
  • Main Thread CPU (P75): CPU usage of the main thread while the view is in the foreground; 100% means the main thread ran on the CPU the whole time. A high value means the main thread is overloaded and frames are more likely to drop, so read it together with frame rate and App Hang. Jank caused by locks or blocking I/O does not raise this metric. Like CPU Usage, shown for iOS apps only.
  • CPU Ticks (P75): Track the P75 percentile of CPU utilization to identify compute-intensive operations. High CPU usage leads to device heating and increased battery drain.
  • Memory Usage (P75): Monitor the P75 percentile of app memory usage to detect memory leaks or abnormal growth early.
  • JS Thread Frame Rate (P75): Monitor the P75 percentile of the React Native JS thread’s frame rate (FPS). Compared with the native frame rate, it reflects jank caused by business JavaScript more directly (re-renders, synchronous work on the bridge). Reported only by the React Native SDK.

App startup time analysis

  • Startup Time Trend Chart: Shows how app startup time changes over time, helping you evaluate optimization effectiveness and detect performance regressions.
  • Sample Distribution Histogram: Statistics of startup duration distribution by time intervals (for example, 0.9425s-0.9642s, 1.1162s-1.1379s), providing insights into real user startup experience distribution and identifying long-tail performance issues.

View performance details

Performance metrics by view name (Page/Activity/ViewController):
  • Visit Count: Shows visit volume for each view to identify high-frequency core pages.
  • Startup Time: Monitor loading duration for each view to locate slow-loading pages.
  • Frame Rate: Track runtime frame rate performance for each view to identify rendering issues.
  • JS Thread Frame Rate: Track each view’s React Native JS thread frame rate (FPS) to spot jank in business JavaScript. Only the React Native SDK reports it, so the column is empty for other platforms.
  • CPU Ticks: Statistics of CPU utilization for each view to optimize compute-intensive pages.
  • CPU Usage / Main Thread CPU: iOS apps additionally show these two columns as P75 values. They use the same definitions as the cards above and are reported only by iOS SDK 0.9.0 and later.
  • Memory Usage: Monitor memory usage for each view to detect memory leak risks.

Smoothness analysis

App smoothness metrics by view name:
  • Slow Frame Share: Share of the measured time spent on slow frames. A slow frame is one that exceeds the display’s frame budget (about 16.67ms at 60fps, less on high-refresh screens) without reaching the frozen-frame threshold. The higher this value, the more stuttering users perceive. Mobile SDKs report only this share, not a slow-frame count.
  • Frozen Frames: Count of single main-thread tasks running longer than 700ms, which leave the UI completely stuck and unresponsive.
  • Long Tasks: Count of main-thread tasks running past the threshold (100ms by default on both Android and iOS, configurable), used to locate performance bottlenecks. Long tasks block user interactions and UI updates.
  • Freeze Frequency: Frozen frames per second of view time (frozen frames / time spent), evaluating overall smoothness performance.
  • JS Frame Rate (Average): The average JS-thread frame rate across that view’s updates; highlighted below 50 FPS. Reported only by the React Native SDK.
  • JS Frame Rate (Minimum): The lowest JS-thread frame rate recorded in any single update of that view — the worst jank a user encountered; highlighted below 30 FPS. Reported only by the React Native SDK.
Frozen Frames, Long Tasks and Freeze Frequency all come from one source. On mobile, frozen frames aren’t counted from rendered frames. They’re the long tasks that run past 700ms, and Freeze Frequency is derived from the frozen-frame count. So once long-task collection is disabled in the SDK, all three columns sit at 0 at the same time — meaning “not measured”, not “no freezes”.Slow Frame Share travels a separate path and is unaffected. A table showing a Slow Frame Share alongside three zeroed columns is therefore the expected result of disabling long-task collection, not missing data.If you disabled long-task collection to reduce event volume, raising the threshold is a better option than turning it off — see Android performance impact.
Slow Frame Share is not comparable across platforms. The numerator is slow-frame time on both, but the denominator differs: Android divides by total frame render time, iOS by view duration. The same experience usually scores much higher on Android. A static screen produces almost no frames, so the denominator is small, and the first frame is always slow. Compare values within a single platform over time.

Memory analysis

Memory usage details by view name:
  • Average Memory: Shows average memory usage for each view to understand typical memory consumption levels.
  • Peak Memory: Records peak memory usage during view runtime to identify memory pressure peaks and prevent system termination due to insufficient memory (OOM).
  • P75 Memory: Shows the P75 percentile of memory usage, reflecting memory usage for most users, more representative of real experience than averages.

Error analysis

Error analysis dashboard showing crash count, crash rate, ANR rate and unresponsive time rate
The Error Analysis module provides comprehensive error monitoring and diagnosis capabilities.

Core stability metrics

  • Crash Count: Monitor total crash occurrences and trends to detect abnormal spikes early. Crashes force app termination and severely impact user experience. Each crash counts once; a crash known only from the beacon the app sent while it died — the user has not opened the app again yet — counts too, while one reported more than 24 hours late does not. ANRs and App Hangs, fatal or not, are not counted here; the ANR rate covers them. When reports are still outstanding the card’s tooltip gives how many, and the details arrive once those users open the app again.
  • Crash Rate: Track the share of sessions that crashed (sessions with at least one crash ÷ total sessions) to evaluate overall app stability. Industry standard recommends keeping the crash rate below 0.5%, which is a crash-free rate above 99.5%.
  • Crash Device Rate: Share of devices that crashed in the foreground, showing how many devices a problem reached. Crashes are counted as in Crash Count, but only those that happened in the foreground; devices are deduplicated by the SDK’s anonymous ID. The denominator is active devices; where the app has none to read, the card title is marked (session basis) and the denominator becomes the devices with a session in the period.
  • ANR Rate: Statistics of Android Application Not Responding occurrence rate. ANR indicates the app’s main thread has been blocked for more than 5 seconds, causing users to see the “App Not Responding” dialog.
  • Unresponsive Time Rate: Seconds the main thread was unresponsive per hour of view time (seconds/hour), averaged by view time and counted only over views the SDK finished measuring. This card is shown for iOS and Flutter apps only; Android-only apps show the ANR Rate above instead. See “How to reduce unresponsive time rate?” below.

Error statistics

  • Error Count: Shows total error count and time-series trends to understand overall app health changes.
  • Error Type Distribution Trend Chart: Stacked bar chart showing distribution changes of crash errors (crash_count) and non-crash errors (non_crash_count) over time, quickly identifying abnormal periods and error type change trends.
    • Crash Errors (crash_count): Severe errors causing forced app termination
    • Non-crash Errors (non_crash_count): Caught exceptions where the app can continue running but functionality may be affected

Page Crash Ranking and top issues (top 10)

Both rankings show the same fields: Page Crash Ranking lists the pages or view controllers with the most crashes; Top Issues ranks Issues by the users they affect. Each Issue groups errors with the same root cause; see Error Grouping.

Error type distribution

  • Error Type Proportion (Pie Chart): Shows proportion of different error types (for example, ReferenceError, java.lang.RuntimeException) to quickly identify main error sources.
  • Error Type Distribution Trend (Stacked Bar Chart): Monitor changes in each error type over time to detect new error types or abnormal growth of certain errors.

Version crash distribution

  • Version Crash Distribution (Pie Chart): Statistics of crash distribution across different app versions to identify high-risk versions.
  • Version Crash Distribution Trend (Stacked Bar Chart): Monitor crash changes across versions over time to evaluate new version quality and perform hotfixes or rollbacks when necessary.

System version error distribution

  • System Version Error Distribution (Pie Chart): Statistics of error distribution across different OS versions (for example, Android 11, Android 12, iOS 15) to identify system compatibility issues.
  • System Version Error Trend (Stacked Bar Chart): Monitor error changes across system versions over time to support system compatibility optimization.
For in-depth analysis of specific errors, see Error Tracking to learn how to investigate critical errors, view error stacks, track new error occurrences, and verify fixes.

Resource analysis

Resource analysis dashboard showing request count, success rate, response time and resource timing rankings
The Resource Analysis module helps you gain deep insights into your app’s network request performance and identify optimization opportunities:
  • Request Count: Monitor network request volume trends to understand app network activity.
  • Request Success Rate: Track successful request percentage to detect network anomalies early.
  • Median Request Time: Shows median request duration changes (for example, p50, p75, p95) to evaluate overall network performance levels.
  • Slow Requests: Statistics of slow request trends exceeding response time thresholds to locate performance bottlenecks.
  • Failed Requests: Monitor occurrence of failed or error requests to quickly identify API issues.
  • Resource Request Status Distribution:
    • Request Status Code Proportion: Pie chart showing distribution of different HTTP status codes (for example, 200, 404, 500) to identify abnormal request types.
    • Request Status Code Trend: Monitor status code changes over time to detect abnormal spikes.
  • Request Method Distribution:
    • Request Method Proportion: Shows usage distribution of different HTTP methods (GET, POST).
    • Request Method Trend: Analyze time-series changes of each request method.
  • Static Resources:
    • Static Resource Call Ranking: Lists most frequently called static resources (for example, images, fonts, config files) to understand resource usage popularity.
    • Static Resource Response Ranking: Identifies slowest responding static resources to optimize resource loading performance.
  • Network Call Ranking:
    • Host Ranking: Statistics of request count by source (Host) to identify main dependent service endpoints.
    • Resource Timing Ranking: Lists longest-duration network requests with timing details (DNS resolution, TCP connection, SSL handshake, time to first byte, response time) for precise performance bottleneck identification.

FAQ

Status code 0 is typically caused by:
  • Request Cancelled - User left the page or cancelled the operation before the request completed, causing request interruption
  • Network Interruption or Timeout - Request encountered network interruption, timeout, or other anomalies during transmission, potentially preventing normal status code return
  • Certificate Validation Failed - HTTPS request SSL certificate validation failed, connection interrupted before establishment
  • SDK Compatibility - In rare cases, specific system versions or devices may have compatibility issues causing incomplete data collection
  • Error Count - Total count of raw error events, including every error occurrence record
  • Issue Count - Count of aggregated issues. Flashduty aggregates similar errors into the same Issue based on error stack, error type, occurrence location, and other information
Example:
This means 100 errors were aggregated into 5 different Issues, each potentially caused by different root causes.
Benefits of aggregation:
  • Easier root cause identification: Errors with the same root cause are grouped into one Issue, avoiding duplicate handling
  • Priority ranking: Identify issues most needing fixes through impact scope (error count, session count)
  • Track fix effectiveness: After fixing an Issue, observe whether all errors under that Issue disappear
Learn more about Error Grouping.
1

Locate High-frequency Crashes

Use “Page Crash Ranking” and “Top Issues” to quickly locate the most impactful crash issues.
2

Analyze Stack Information

Click on specific Issues to view detailed error stacks and user environment information for precise problem code location.
3

Focus on System Compatibility

Use “System Version Crash Distribution” to identify compatibility issues with specific system versions.
4

Monitor Version Quality

Use “Version Crash Distribution” to evaluate new version quality and perform hotfixes or rollbacks when necessary.
5

Enhance Exception Handling

Use try-catch and global exception handlers appropriately to prevent uncaught exceptions from causing crashes.
Percentiles are important statistical indicators for measuring data distribution:
Why use P75 instead of average?
  • Averages are easily skewed by extreme values and may not represent most users’ real experience
  • P75 better reflects the experience of most users and is an industry-standard performance evaluation metric
  • Google recommends using P75 as a core performance metric
Example:
These are important metrics for measuring app smoothness:
Common causes of long tasks:
  • Complex calculations
  • Large data processing
  • Synchronous I/O operations
ANR (Application Not Responding) is Android’s app unresponsive mechanism:
  • When the app’s main thread is blocked for more than 5 seconds, the system displays an “App Not Responding” dialog
  • Users can choose “Wait” or “Close App”
  • ANR severely impacts user experience and may lead to app uninstallation
Common ANR causes:
  • Main thread executing time-consuming operations: Synchronous network requests, large file I/O, complex calculations, database operations
  • Main thread waiting for locks: Multi-thread deadlocks, waiting for other threads to release locks
  • Insufficient system resources: CPU occupied by other apps, insufficient memory causing frequent GC
The data source and threshold differ per platform:
  • iOS: Sourced from App Hangs, controlled by the SDK’s appHangThreshold. This option defaults to nil, meaning detection is off — it must be set explicitly before any data is produced. A value of 0.25–0.5 seconds is recommended. See iOS advanced configuration.
  • Android: Sourced from main-thread freezes, counted only once a main-thread task reaches 5 seconds. The threshold is fixed and cannot be configured. Android-only apps do not show this metric — use the ANR Rate instead.
  • Flutter: One app spans both OSes, so ANR Rate and Unresponsive Time Rate appear side by side. Their thresholds differ, so do not compare them directly.
Logged-in User IdentificationFor apps requiring user login (for example, e-commerce, social, finance), you can call the SDK’s user identification method after user login:Apps without login stateReport a user ID from your own account system as the user identifier. Don’t derive a user ID from device identifiers such as IMEI, Android ID, or advertising ID.
Flashduty RUM typically completes data collection and display within 1-3 minutes after data generation. Under good network conditions, most data can achieve near real-time updates.
Whether a resource shows phase timings (DNS lookup, connection setup, TLS handshake, time to first byte, download) depends on the platform:
  • iOS - Collected automatically by the SDK, no extra configuration needed
  • Android - Only the total duration is recorded by default. Register DatadogEventListener.Factory on your OkHttpClient to collect them. See Collect request phase timings
  • HarmonyOS - The current SDK reports only the total request duration; phase timings are not collected yet
A request that reuses an existing connection has no DNS lookup or connection setup phase, so those phases not appearing is expected.

Metrics reference

Overview metrics

UV definition: On the Native (Android/iOS/HarmonyOS/Flutter) dashboard and app cards, UV counts distinct devices by anonymous ID, and by user ID when a device has no anonymous ID. The anonymous ID persists across login, so an anonymous session and the same person’s later logged-in session count as one user. When anonymous user tracking is off, UV counts distinct user IDs. Web (browser) and Mini Program dashboards count distinct user IDs. Electron apps use the Web dashboard, but their UV counts distinct anonymous IDs, like the Native dashboard, because the Electron SDK doesn’t report a user ID.

Performance metric thresholds

Smoothness metrics

Stability metrics

Further reading

SDK integration and configuration

Android SDK Integration Guide

Learn how to integrate RUM SDK in Android apps

iOS SDK Integration Guide

Learn how to integrate RUM SDK in iOS apps

Android Advanced Configuration

Configure advanced Android RUM SDK features

iOS Advanced Configuration

Configure advanced iOS RUM SDK features

Android Data Collection

Learn about data types collected by Android RUM SDK

iOS Data Collection

Learn about data types collected by iOS RUM SDK

Data analysis and monitoring

RUM Explorer

Learn how to use RUM Explorer for in-depth data analysis

Error Tracking

Master error tracking and debugging techniques

Error Grouping

Understand error grouping mechanisms