Errors Tab
A comprehensive guide to tracking and resolving errors in Rybbit's Behavior Analytics
A Guide to Rybbit's Errors Tab
The Errors tab in Rybbit's Behavior Analytics section provides visibility into JavaScript errors and exceptions occurring on your website. While users often silently suffer through broken features and technical issues, the Errors tab brings these problems into the light, allowing you to quickly identify and resolve the bugs that degrade user experience and cost you conversions.
What is Error Tracking?
Error tracking monitors JavaScript errors that occur in the browser as users interact with your website. These might include syntax errors, network failures, unhandled exceptions, or any other JavaScript issues that break functionality or degrade the user experience.
By automatically capturing errors and the context in which they occur, Rybbit helps you transition from reactive debugging (users report problems) to proactive quality assurance (you identify and fix issues before they hurt your business).
Why Error Tracking Matters
JavaScript errors on your website directly impact your business:
Lost Conversions: A broken checkout button might prevent customers from completing purchases. Error tracking reveals these critical issues immediately.
Poor User Experience: Errors often cascade, breaking features and confusing users. Early detection prevents negative user experiences.
Hidden Problems: Many users silently abandon your site when they encounter errors. Without error tracking, you'd never know there was a problem.
Development Efficiency: Instead of developers chasing vague user reports ("your site is broken"), error tracking provides exact error messages and stack traces.
Quality Assurance: Errors that slip through testing in production are caught and fixed much faster with visibility into real user errors.
Accessing the Errors Tab
To view and analyze errors on your website:
- Log into your Rybbit dashboard
- Navigate to the Behavior section in the left sidebar
- Click on the Errors tab
You'll see a list of all JavaScript errors occurring on your website, grouped by error type and severity.
Key Error Metrics
When examining the Errors tab, you'll encounter important metrics about your website's health:
Error Type
The classification of the error (ReferenceError, TypeError, SyntaxError, NetworkError, etc.). This helps you categorize and prioritize fixes.
Error Message
The specific error message returned by JavaScript. This often clearly describes what went wrong.
Stack Trace
The chain of function calls that led to the error. This shows you exactly where in your code the error occurred.
Affected Users
The number of unique users who encountered this error. A single user seeing an error is less critical than hundreds of users affected.
Occurrence Count
How many times this specific error has been triggered. Frequent errors indicate high-priority issues.
First Seen
When the error first appeared. New errors might indicate recently introduced bugs.
Last Seen
When the error most recently occurred. Errors that went away might have been fixed. Errors that persist need attention.
Affected Pages
Which pages on your website generated this error. This reveals if the issue is site-wide or isolated to specific areas.
Severity Level
The impact level of the error (critical, major, minor). Critical errors often prevent core functionality.
Browser & Device
Which browsers and devices experience this error. Some errors only occur in specific environments.
Error Types and Causes
Understanding different error types helps you prioritize fixes:
Reference Errors
Caused by attempting to use undefined variables. Often indicates missing dependencies or incorrect variable names.
Type Errors
Occur when code tries to perform an operation on the wrong data type (e.g., calling a method on undefined). Common in code that doesn't validate input.
Syntax Errors
Issues in code structure. Usually caught during development but can occur in dynamically generated code.
Network Errors
Failed API calls or failed resource loading. Might indicate server issues, CDN problems, or user connectivity issues.
Permission Errors
Attempt to access restricted resources. Often indicates incorrect authentication or authorization.
Range Errors
Operations outside valid ranges (e.g., array access out of bounds).
Custom Errors
Errors thrown intentionally by your code for validation or business logic purposes.
Analyzing Error Patterns
The Errors tab becomes most valuable when you identify patterns:
Error Frequency
Monitor if errors are increasing, staying stable, or decreasing. Sudden spikes indicate new problems. Gradual increases suggest systematic issues.
Error Clustering
Multiple errors from the same user might indicate they're triggering a specific error condition. Look for patterns in which actions cause errors.
Device-Specific Errors
Some errors occur only on mobile or only on specific browsers. This helps you test in the right environment.
Timing Patterns
Do errors spike at specific times? This might correlate with deployments, heavy traffic periods, or external service outages.
Conversion Impact
Which errors are preventing users from completing important actions? Prioritize fixing errors on critical pages.
Common Use Cases
Identifying Critical Issues
When errors are preventing users from converting or accessing core features, fix them immediately.
Post-Deployment Monitoring
After deploying new code, monitor the Errors tab for sudden spikes indicating bugs introduced by the deployment.
Debugging User Reports
When users report problems, the Errors tab often provides the exact technical issue and stack trace.
Improving Stability
Regularly reviewing and fixing errors improves your overall application stability and user satisfaction.
A/B Testing Validation
After launching A/B tests or feature experiments, monitor errors to ensure new variants don't introduce bugs.
Performance Debugging
Some errors are caused by memory leaks or performance issues. Tracking errors helps identify performance problems.
Third-Party Integration Issues
Errors often indicate that third-party integrations (analytics, payment processors, chat tools) are malfunctioning.
Error Tracking Configuration
To use the Errors tab effectively:
- Enable Error Tracking: Ensure error tracking is enabled in your Rybbit configuration
- Proper Installation: Verify the Rybbit script is installed before other scripts that might throw errors
- Source Maps: If you use minified code, upload source maps for readable stack traces
- Environment Tagging: Tag errors by environment (production, staging, development) to ignore non-production errors
- Filtering: Configure the system to ignore known, harmless errors in your stack
Understanding Stack Traces
Stack traces show you the exact execution path that led to an error:
ReferenceError: cart is not defined
at checkout() (app.js:245)
at handlePaymentClick() (app.js:180)
at HTMLElement.onclick (checkout.html:50)This tells you:
- Error: Variable
cartis undefined - Root Location: Line 245 in app.js, in the
checkout()function - Call Chain:
checkout()was called fromhandlePaymentClick()which was called from a click handler
With this information, you can quickly find and fix the bug.
Prioritizing Error Fixes
Not all errors are equally important. Use these criteria to prioritize:
By Impact: How many users are affected? Critical = hundreds of users, Major = dozens, Minor = few
By Severity: Does it completely break functionality (critical) or just degrade it (major/minor)?
By Visibility: Does the error occur on frequently visited pages or obscure pages?
By Business Impact: Does the error prevent conversions or affect core features?
By Frequency: Is the error happening constantly (high priority) or rarely (lower priority)?
Best Practices for Error Management
Fix Frequently Occurring Errors First: Errors affecting many users should be fixed before edge-case errors.
Use Source Maps: Keep source maps handy so you can read stack traces in minified code.
Test Fixes: When fixing an error, verify the fix works before deploying to production.
Monitor After Fixes: After fixing an error, monitor the Errors tab to verify it's actually gone.
Set Up Alerts: Configure alerts for critical error spikes to catch new issues immediately.
Document Errors: Keep notes on errors you've fixed to avoid repeating mistakes.
Version Tracking: If possible, track which code version each error is associated with to isolate when bugs were introduced.
Advanced Error Debugging
Correlating Errors with Sessions
Find users who encountered errors and examine their sessions to understand what they were doing when the error occurred.
Analyzing Error Sequences
Sometimes multiple errors occur in sequence. Understanding the sequence helps identify root causes.
Monitoring Third-Party Errors
Track errors from third-party scripts (ads, analytics, chat widgets). Some can be ignored, others indicate integration failures.
Performance-Related Errors
Memory errors and timeout errors often indicate performance issues. Address these alongside traditional error fixes.
Error Recovery Success
Monitor whether errors automatically recover or if they break functionality. Unrecoverable errors are more critical.
Privacy Considerations
Rybbit's error tracking respects privacy:
- Error messages and stack traces don't automatically include PII
- You should review error data to ensure no sensitive information is leaking
- Users can opt out of error tracking
- Error data follows the same retention and security policies as other analytics
Be careful not to log sensitive information (passwords, API keys, personal data) in error messages.
Common Error Scenarios
Redux/State Management Errors
Often indicate components trying to access undefined state properties. Fix by ensuring proper state initialization.
Third-Party Library Errors
When errors come from libraries you didn't write, check for compatibility issues or incorrect usage.
Network Timeout Errors
Indicate slow API responses or failed requests. Consider implementing retry logic.
CORS Errors
Indicate requests blocked by browser security policies. Review your CORS configuration.
Memory Leak Errors
When browser memory consumption grows continuously, track down code creating unreferenced objects.
Timing-Related Errors
Errors that occur intermittently might be timing-related (race conditions, asynchronous issues).
Troubleshooting Error Tracking
No errors appearing
Check that error tracking is enabled and that you have JavaScript errors occurring on your site (they might be being caught elsewhere).
Errors seem inaccurate
Verify source maps are properly configured. Without source maps, minified code shows unhelpful stack traces.
Too many trivial errors
Configure the system to ignore errors that don't affect users, or filter them in your dashboard.
Missing error context
Ensure the Rybbit script loads early and before other scripts that might throw errors.
Connecting Errors with Other Analytics
Errors and Sessions
See in which sessions errors occurred to understand user impact.
Errors and Users
Identify which users are affected by specific errors, allowing for targeted support.
Errors and Events
Some errors might be preceded by specific events. Track these sequences to understand error causes.
Conclusion
The Errors tab in Rybbit's Behavior Analytics transforms your website monitoring from reactive (waiting for user complaints) to proactive (automatically detecting and fixing issues). By systematically reviewing and addressing errors, you dramatically improve user experience, increase conversions, and build a more stable product.
Make it a habit to check the Errors tab regularly, prioritize fixes based on user impact, and monitor after deployments for any unexpected issues. Combined with other Behavior Analytics features, error tracking gives you complete visibility into your website's health and your users' experience.
Additional Resources: