- Flutter / React Native: One Flutter or React Native app spans both Android and iOS. The filter bar therefore also pins the
os_namefilter 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

- 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

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.
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

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: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.
Resource analysis

- 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
Why is the status code 0 for some network requests?
Why is the status code 0 for some network requests?
- 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
What's the difference between error count and Issue count?
What's the difference between error count and Issue count?
- 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
- 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
How to lower the crash rate?
How to lower the crash rate?
Locate High-frequency Crashes
Analyze Stack Information
Focus on System Compatibility
Monitor Version Quality
Enhance Exception Handling
What do P75, P50, P90 percentiles mean?
What do P75, P50, P90 percentiles mean?
What are slow frames, frozen frames, and long tasks?
What are slow frames, frozen frames, and long tasks?
- Complex calculations
- Large data processing
- Synchronous I/O operations
What is ANR?
What is ANR?
- 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
Where does the unresponsive time rate come from?
Where does the unresponsive time rate come from?
- iOS: Sourced from App Hangs, controlled by the SDK’s
appHangThreshold. This option defaults tonil, 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.
How to collect user information?
How to collect user information?
- Android: See Android User Session Configuration
- iOS: See iOS User Session Configuration
What is the data latency?
What is the data latency?
Why can't I see the phase timings of a request?
Why can't I see the phase timings of a request?
- iOS - Collected automatically by the SDK, no extra configuration needed
- Android - Only the total duration is recorded by default. Register
DatadogEventListener.Factoryon yourOkHttpClientto collect them. See Collect request phase timings - HarmonyOS - The current SDK reports only the total request duration; phase timings are not collected yet