Traffic Metrics: Monitor UV (unique visitors) and session count to help you grasp overall user activity trends.
Core Health Metrics: Highlight three mobile application core metrics: crash count, crash-free rate, and app freeze rate, quickly identifying application stability issues.
User Activity Trends: Track UV and Session change trends through time-series charts to understand user activity patterns.
User Distribution: Analyze user sources based on geographic location to understand regional user activity.
Session Analysis: Track distribution trends of average session duration to evaluate user stickiness and usage depth.
Version Distribution: Monitor user distribution across different system versions (Android/iOS) and application versions to support compatibility optimization and version iteration.
Application Startup Time (P75): Monitors the P75 percentile of app startup time to evaluate startup performance. Startup time directly impacts user first impressions and willingness to use.
Frame Rate (P75): Shows the P75 percentile of app runtime frame rate to measure screen smoothness. Target is 60fps; higher values indicate smoother interactions.
CPU Consumption (P75): Tracks the P75 percentile of CPU usage to identify compute-intensive operations. Excessive CPU consumption leads to device heating and increased power drain.
Memory Usage (P75): Monitors the P75 percentile of app memory usage to detect memory leaks or abnormal growth in time.
Startup Time Trend Chart: Shows app startup time trends over time to help you evaluate startup optimization effectiveness and detect performance regression in time.
Sample Distribution Histogram: Counts startup time distribution by time intervals (e.g., 0.9425s-0.9642s, 1.1162s-1.1379s), understanding real user startup experience distribution characteristics and identifying long-tail performance issues.
Visit Count: Shows visit volume for each view, identifying core high-frequency pages.
Startup Time: Monitors loading time for each view, locating slow-loading pages.
Frame Rate: Tracks frame rate performance of each view during runtime, identifying rendering performance issues.
CPU Consumption: Counts CPU usage for each view, optimizing compute-intensive pages.
Memory Usage: Monitors memory usage for each view, discovering memory leak risks.
Slow Frames: Counts frames with rendering time exceeding threshold (typically 16.67ms, below 60fps), identifying stutter issues. Slow frames cause users to perceive obvious interface unsmoothness.
Frozen Frames: Records completely frozen interface frames (typically exceeding 700ms), these are serious performance issues significantly affecting user experience.
Long Tasks: Tracks the number of long-running tasks on the main thread (typically threshold of 100ms or longer), locating performance bottlenecks. Long tasks block user interaction and interface updates.
Freeze Frequency: Counts app freeze occurrence frequency (times/second), evaluating overall smoothness performance.
Average Memory: Shows average memory usage for each view, understanding regular memory consumption levels.
Peak Memory: Records memory usage peaks during view runtime, identifying memory pressure peaks to prevent system termination due to insufficient memory (OOM).
P75 Memory: Shows P75 percentile of memory usage, reflecting memory usage for most users, more representative of real experience than average values.
Crash Count: Monitors total app crash occurrences and trends, detecting abnormal peaks in time. Crashes force apps to exit, seriously affecting user experience.
Crash-free Rate: Tracks the proportion of crash-free sessions, evaluating overall app stability performance. Industry standards recommend maintaining crash-free rate above 99.5%.
ANR Rate: Counts Android Application Not Responding occurrence proportion. ANR indicates app main thread blocked for more than 5 seconds, users see "Application Not Responding" dialog.
App Freeze Rate: Monitors the proportion of sessions with freezes out of total sessions, evaluating the impact scope of app smoothness issues. Freezes typically refer to interface freezing, delayed response, or frame rate drops due to main thread blocking for extended periods, affecting user interaction experience.
Error Type: Crash exception type (e.g., java.lang.RuntimeException, SIGTRAP, etc.)
Error Message: Detailed error description to help quickly locate issues
Error Count: Total occurrences of this error on this page
Session Count: Number of sessions (user visits) affected by this error
Error Type: Primary error type of the Issue (e.g., java.lang.RuntimeException, TypeError, ReferenceError, etc.)
Error Message: Typical error description of the Issue, click to view detailed stack and session information
Error Count: Total error occurrences contained in this Issue
Session Count: Number of sessions affected by this Issue
Error Type Proportion (Pie Chart): Shows proportion of different error types (e.g., ReferenceError, java.lang.RuntimeException, etc.), quickly identifying main error sources.
Error Type Distribution Trend (Stacked Area Chart): Monitors change trends of each error type over time, detecting new error types or abnormal growth of certain errors in time.
Version Crash Distribution (Pie Chart): Counts crash distribution across different app versions, identifying high-risk versions.
Version Crash Distribution Trend (Stacked Area Chart): Monitors crash changes for each version over time, evaluating new version quality, performing hot fixes or rollbacks when necessary.
System Version Exception Distribution (Pie Chart): Counts exception distribution across different OS versions (e.g., Android 11, Android 12, iOS 15, etc.), identifying system compatibility issues.
System Version Exception Trend (Stacked Area Chart): Monitors exception changes for each system version over time, providing data support for system compatibility optimization.
Request Count: Monitors network request volume change trends, understanding app network activity.
Request Success Rate: Tracks proportion of successful requests, detecting network anomalies in time.
Median Request Time: Shows median request duration changes (e.g., p50, p75, p95), evaluating overall network performance level.
Slow Requests: Counts slow request trends with response time exceeding threshold, locating performance bottlenecks.
Abnormal Requests: Monitors failed or error request occurrences, quickly identifying API issues.
Request Status Distribution:Request Status Code Proportion: Shows distribution of different HTTP status codes through pie chart (e.g., 200, 404, 500), identifying abnormal request types.
Request Status Code Trend: Monitors status code changes over time, detecting abnormal peaks in time.
Request Method Distribution:Request Method Proportion: Shows usage distribution of different HTTP methods (GET, POST, etc.).
Request Method Trend: Analyzes time-series changes of each request method.
Static Resource Call Ranking: Lists most frequently called static resources (e.g., images, fonts, config files), understanding resource usage popularity.
Static Resource Response Ranking: Identifies slowest responding static resources, optimizing resource loading performance.
Host Ranking: Counts request count by request source (Host), identifying main dependent service endpoints.
Resource Duration Ranking: Lists longest duration network requests, including duration details (DNS resolution, TCP connection, SSL handshake, first byte time, response time, etc.), precisely locating performance bottlenecks.
1.
Request Canceled: User left page or canceled operation before request completion, causing request interruption.
2.
Network Interruption or Timeout: Request encountered network interruption, timeout, or other exceptions during sending, possibly causing status code not to return normally.
3.
Certificate Verification Failed: HTTPS request SSL certificate verification failed, connection interrupted before establishment.
4.
SDK Compatibility: In rare cases, specific system versions or devices may have compatibility issues, causing incomplete data collection.
Error Count: Refers to total count of raw error events, including every error occurrence record.
Issue Count: Refers to count of problems after aggregation. Flashduty aggregates similar errors into the same Issue based on error stack, error type, occurrence location, and other information.
Facilitate locating problem root cause: errors with same root cause grouped into one Issue, avoiding duplicate processing
Priority sorting: identify problems most needing fixes through impact scope (error count, session count)
Track fix effectiveness: after fixing one Issue, observe whether all errors under that Issue disappear
1.
Locate High-frequency Crashes: Quickly locate most impactful crash issues through "Page Crash Ranking" and "Top Issues".
2.
Analyze Stack Information: Click specific Issue to view detailed error stack and user environment information, precisely locating problem code.
3.
Focus on System Compatibility: Identify specific system version compatibility issues through "System Crash Distribution".
4.
Monitor Version Quality: Evaluate new version quality through "Version Distribution", perform hot fixes or rollbacks when necessary.
5.
Enhance Exception Capture: Properly use try-catch, global exception handlers to avoid uncaught exceptions causing crashes.
1.
View "Application Startup Time (P75)" metric to understand most users' startup experience
Evaluate optimization effectiveness through "Startup Time Trend Chart", avoiding performance regression
View "Sample Distribution Histogram" to identify long-tail issues, ensuring minority users also get good experience
2.
Delay Non-critical Initialization: Defer non-essential initialization operations until after first screen render to shorten startup time.
3.
Optimize Dependency Loading: Reduce third-party SDKs and libraries loaded during startup, adopt lazy loading strategy.
4.
Simplify First Screen Layout: Reduce homepage view hierarchy complexity, decrease first render time.
5.
Use Startup Optimization Tools:Android: Use App Startup Library to manage component initialization order
iOS: Utilize Lazy Initialization to defer non-critical component initialization
6.
Monitor Startup Phase Duration: Track duration of each phase through custom timing points, precisely locating bottleneck stages.
P50 (Median): 50% of users have better experience than this value, 50% have worse
P75: 75% of users have better experience than this value, 25% have worse
P90: 90% of users have better experience than this value, 10% have worse
P95: 95% of users have better experience than this value, 5% have worse
When app main thread is blocked for more than 5 seconds, system pops up "Application Not Responding" dialog
User can choose "Wait" or "Close App"
ANR seriously affects user experience, may cause user to uninstall app
1.
Locate Freeze Sources: Identify specific code causing freezes through "Long Task Monitoring" and "Freeze Duration Distribution".
2.
Optimize Main Thread Tasks: Move time-consuming operations (like network requests, database read/write, complex calculations, large file I/O) to background threads.
3.
Reduce view hierarchy, lower layout complexity
Avoid complex view calculations on main thread
Use optimization techniques for RecyclerView (Android) or UITableView/UICollectionView (iOS)
Properly use hardware acceleration
4.
Optimize List Performance:Implement view reuse mechanism
Optimize item layout complexity
Avoid time-consuming operations during item binding
5.
Combine Monitoring Tools: Use performance analysis dashboard in combination with system tools (Android Profiler, Xcode Instruments) to locate specific freeze code.
6.
Set Reasonable Thresholds: Set reasonable freeze detection thresholds (recommended 200-500ms) based on business characteristics and user expectations.
微信扫码交流