ACTION PLAN

What is Sentry?
Sentry is a popular error tracking and monitoring tool that helps developers
identify and fix issues in their applications. When an error occurs, Sentry
captures it and provides insights into the type, severity, and context of the
issue. The types of errors and issues monitored by Sentry can generally be
categorized as follows:

1. Exceptions
These are typically runtime errors in your application. When an exception is
thrown, Sentry captures the stack trace, which helps developers understand the
flow of the code leading up to the error. The types of exceptions may vary
depending on the programming language or framework being used.

- JavaScript Errors: Includes common errors like `TypeError`, `ReferenceError`,

`SyntaxError`, etc.

2. Unhandled Errors
These are errors that weren't caught by the application. Sentry typically
captures unhandled exceptions that propagate up to the global exception
handler. These errors often indicate that the application didn't expect an issue in
that particular code path.

3. Handled Errors
These are errors that are intentionally caught by the application (using try-
catch blocks, for example) but still need to be reported for monitoring purposes.
Sentry can be configured to track these errors as well, even if the application
catches and deals with them.

4. Crashes
A crash is a serious failure where the application stops functioning or becomes
unstable. These are usually system-level errors or fatal exceptions that require
the application to be restarted. Sentry tracks crashes on mobile (iOS, Android),
desktop, and server-side applications.

5. Performance Issues
Sentry also monitors performance-related problems, such as:
- Slow Transactions: Tracks the duration of specific actions or endpoints (e.g., a
web request or API call) that exceed a threshold.
- Apdex Scores: Monitors application response times and tracks user
satisfaction with respect to response time.
 - Slow Database Queries: Detects queries that take too long to execute and
may affect application performance.

6. Release Errors
Sentry allows you to monitor errors tied to specific application releases. This
means that errors can be tracked by version, and you can quickly identify if a
particular version of the software introduced new issues.

7. User Feedback
Sentry allows users to submit feedback when they experience an issue. This
feedback is often used to capture user-related insights in addition to technical
details about the error.

8. Breadcrumbs
Breadcrumbs are small events (e.g., logging messages, network requests, UI
interactions) leading up to the error. These can be used to give more context
around what happened right before an error occurred, helping developers
diagnose the problem faster.

9. Security Issues (Security Warnings)

Sentry also helps in detecting potential security issues, such as:
- Sensitive Data Exposure: If an error contains sensitive information like
passwords or credit card numbers, Sentry may flag it.
- Authentication Issues: Problems like failed logins or unauthorized access
attempts.

10. Network Errors

For web applications, Sentry tracks issues related to network connectivity and
API requests, such as:
- Failed HTTP Requests: Non-2xx responses (e.g., 500, 400, 404, etc.).
- Timeouts: Errors related to network timeouts during requests.

11. Custom Errors

Sentry allows you to define and capture custom error types. Developers can
send their own error data to Sentry for tracking, such as application-specific
business logic failures or validation errors.

12. Unhandled Promise Rejections (JavaScript)

In JavaScript, unhandled promise rejections can be captured as errors by
Sentry. This typically happens when a promise is rejected and no `.catch()`
handler is provided to handle the rejection.

13. Manual Alerts / Triggers

Sentry provides the ability to configure custom alerts based on certain
conditions or thresholds, which might not always directly correlate with an error,
but rather with certain application behaviors.
 14. Environment-Specific Errors
Sentry also tracks errors in specific environments (e.g., development, staging,
production) and can filter or highlight issues based on which environment they
occur in.

15. Deprecation Warnings

Although not strictly errors, deprecation warnings for outdated or unsupported
features in your codebase may be captured and tracked in Sentry. This allows
developers to keep track of the progress in addressing deprecated code.

Summary
The types of errors in Sentry are diverse, ranging from application crashes,
exceptions, and performance bottlenecks to more specialized issues like
security problems or failed network requests. The tool helps aggregate all these
errors, providing insights into where issues arise in the software lifecycle,
making it easier to identify and fix bugs quickly.

Setup & Integration

1. Initial Setup and Integration

Goal: Get Sentry integrated with your application, so errors can be tracked and
insights gathered.

Step 1: Set Up Alert Rules

- Configure alert rules in Sentry to notify your team about critical issues.

- For example, set up notifications for:

- New issues (first time seen).

- Issue re-appearance (errors that recur).

- High severity errors.

- Performance degradation (slow API calls).

Step 2: Choose Notification Channels

- Sentry supports several notification channels:

- Email

- Slack

- Webhook (for custom integrations with systems like Jira, Trello, or others).

- Mobile push notifications for critical issues on mobile apps.

Step 3: Assign Ownership to Issues

- Set up automatic issue assignment to developers or teams based on tags or other

criteria.

- Use issue owners in Sentry to automatically assign a person/team to each new

issue.

---

4. Issue Management and Triage Process

Goal: Efficiently track, prioritize, and resolve errors.

Step 1: Prioritize Critical Errors

- Immediate action: Focus on high-severity errors that impact users the most (e.g.,
crashes, security issues, data corruption).

- Low-severity issues: Triage less important issues that can be addressed later.

Step 2: Use Sentry's Issue Grouping

- Sentry automatically groups similar errors into issues. Ensure that these groups are
correctly configured to avoid duplication.

- Review issues regularly to identify patterns or recurring problems.

Step 3: Assign Issues to Team Members

- Use Sentry’s issue tracking to assign tasks to developers based on their area of
expertise. If the error is critical, make sure it's assigned to the appropriate
developer/team immediately.

Step 4: Reproduce and Debug

- Use breadcrumbs and stack traces in Sentry to reproduce and debug the error.

- Explore the error's context (e.g., logs, user data, environment) to quickly identify
the root cause.

---
5. Fixing and Deploying Code

Goal: Resolve issues and ensure they are deployed without causing regressions.

Step 1: Implement Fixes

- Based on your analysis of the issue, implement a fix in the relevant code section.

- Test the fix locally and in staging environments.

Step 2: Use Release Management

- For a smooth release, integrate CI/CD pipelines with Sentry so that new releases
are automatically tracked.

- Link commits and pull requests to Sentry issues, helping developers see which
commit fixed a particular issue.

Step 3: Monitor Post-Release

- After deploying the fix, monitor Sentry for any new occurrences of the error.

- Use sentry.io performance monitoring to track if the issue caused any new
performance issues or regressions.

---

6. Post-Mortem and Continuous Improvement

Goal: Learn from errors and improve the application and monitoring process.

Step 1: Conduct a Post-Mortem

- For high-impact or recurring errors, conduct a post-mortem to understand:

- The root cause of the issue.

- Whether the issue could have been prevented.

- How to ensure it doesn’t happen again.

Step 2: Add Tests and Safeguards

- Based on the issues observed, create additional unit tests or integration tests to
prevent similar issues in the future.

- Implement error handling strategies and fail-safes to catch edge cases early in the
code.
Step 3: Review and Iterate on Alerts

- Regularly review the effectiveness of your alert rules. Avoid over-alerting and
ensure you're only notified about critical, actionable issues.

- Adjust thresholds for error frequency or severity over time.

Step 4: Educate Your Team

- Share error trends and lessons learned with your development team. Encourage
good practices like:

- Proper error handling.

- Meaningful logging.

- Using Sentry’s breadcrumbs and contextual data to better understand errors.

---

7. Ongoing Maintenance

Goal: Keep your Sentry setup effective and continuously improve error monitoring.

Step 1: Periodically Review Sentry Integrations

- Ensure that Sentry is properly integrated with all parts of your stack (back-end,
front-end, mobile, etc.).

- Periodically review the SDK versions and update them to benefit from bug fixes
and new features.

Step 2: Monitor User Feedback

- If you're using Sentry’s user feedback feature, regularly review feedback to gauge
the impact of errors on users and use that data to prioritize fixes.

Step 3: Optimize Performance Monitoring

- Regularly review performance issues and slow transactions to optimize the

application’s performance over time.

---
By following this action plan, you will set up an effective error monitoring and
response strategy with Sentry, ensuring that your application remains stable, user-
friendly, and performant over time.

1. Replays
2. Grouping - Error Aggregation & Grouping
3. Category-Different error types
4. DB slow query - Detect Performance Issues
5. N+1 query
6. Different for different environments
7. Alert system - Real-Time Error Tracking
8. Errors by Browser
9. Errors by Country
10. Historical Error Tracking
11. Can be assigned to different user to resolve error
12. Slowest functions
13. Mobile Error
14. Differentiate errors by frontend and backend
15. Monitor cron jobs
16. Number of user effected
17. Deep Insights & Context - captures detailed information of error

https://sentry.io/vs/logging/