Error grouping

Overview

Raygun groups errors to help you maintain a manageable list of bugs, so you can identify and prioritize issues effectively. By using a combination of grouping hashers, Raygun reads specific parts of an error instance to group them together. This process minimizes noise and helps you focus on the critical issues impacting your application. We offer various grouping methods to suit your application’s error reporting patterns.

Why error grouping matters

Without efficient error grouping, teams can quickly become overwhelmed by similar errors that appear separately in the dashboard. Raygun helps you streamline your error tracking by using sophisticated grouping strategies, making sure errors that originate from the same issue are grouped together. If you're seeing many similar errors like multiple "Script error" groups, it may be time to review your grouping strategy.

How Raygun automatically groups errors

At the core of Raygun's error grouping is the stack trace. Raygun groups errors based on the exception type, class name, method name, and the location within the stack trace. This ensures that errors originating from the same line of code with the same type are grouped together, significantly reducing noise.

For example:

• Errors thrown from different parts of the application, even if they share the same exception type, will be placed in separate groups.
• If a single error type occurs at different stack levels, it will be grouped separately to avoid incorrect assumptions about the error's origin.

Types of error grouping

1. Provider-based grouping

For most supported languages and frameworks, Raygun uses provider-based grouping. This approach groups errors by reading the exception type, class name, and method name from each line in the stack trace. This ensures that exceptions occurring at the same point in your code are grouped together.

• Example: In .NET, Raygun groups errors based on the full method signature (namespace.class.method), ensuring accuracy when grouping exceptions across similar methods.

Raygun continuously updates the hashers for each provider. You can check which hasher version is being used in the application settings, and it’s recommended to always use the latest version to benefit from the most recent improvements.

2. Message-based grouping

Message-based grouping is available for applications where stack traces might not be relevant or useful. Raygun groups errors purely by the error message. Two errors with the same message will be grouped together, regardless of their stack traces.

• Use Case: This is particularly useful in client-side JavaScript applications, where different browsers might produce different stack traces for the same underlying error.

3. Custom grouping

When the built-in grouping methods don’t suit your needs, you can implement custom grouping. This allows you to define your own grouping logic by generating a custom grouping key in your application code. This key is passed to Raygun with the error payload and overrides the default grouping logic.

• Custom Key Example: You might group errors based on a specific user action, such as "user_login_failed", instead of the stack trace. The flexibility of custom grouping allows you to incorporate business logic into how errors are grouped.

Monitoring and improving grouping accuracy

1. Update to the latest grouping strategy

Raygun is continuously improving its grouping hashers. To ensure optimal error grouping, make sure your application is running on the latest grouping strategy. You can view and update the current grouping strategy in your application's Crash Reporting settings.

• Hasher Versions: Raygun assigns a specific hasher based on the data being sent. You can verify the hasher version for your provider and update it if a newer version is available.

2. Audit log and communication

Changes in grouping strategies should be communicated to your team. If error groups change unexpectedly, consult the audit log to see if someone updated the grouping settings or merged error groups. Internal communication is key when modifying the grouping strategy to avoid confusion or data loss.

3. Custom error grouping

If you need more control over how errors are grouped, consider implementing custom error grouping. This allows you to override Raygun’s default behavior, but use it with caution — there’s no undo button, and improper implementation can result in misgrouped errors.

Best practices for effective grouping

• Review Your Errors Regularly: Periodically review your error groups to ensure that similar issues are grouped together. If you notice fragmentation (e.g., multiple error groups with similar root causes), it might be time to adjust your strategy.
• Use Alerts: Set up alerts for specific error groups to quickly identify critical issues. Alerts can notify you when certain conditions are met, helping you respond to errors faster.
• Minimize Noise: Focus on the data points that matter. Ensure your error handling logic only generates meaningful errors to avoid overwhelming your dashboard with minor or irrelevant issues.

Need more help?

If you're struggling to get your error grouping right, contact us with specific details about your setup, such as the provider and language you’re using. Our team can help you optimize your error grouping to suit your application.