Debug Error

# Systematically Debug and Fix Errors

Systematically debug and fix errors

## Instructions

Follow this comprehensive debugging methodology to resolve: **$ARGUMENTS**

1. **Error Information Gathering**
   - Collect the complete error message, stack trace, and error code
   - Note when the error occurs (timing, conditions, frequency)
   - Identify the environment where the error happens (dev, staging, prod)
   - Gather relevant logs from before and after the error

2. **Reproduce the Error**
   - Create a minimal test case that reproduces the error consistently
   - Document the exact steps needed to trigger the error
   - Test in different environments if possible
   - Note any patterns or conditions that affect error occurrence

3. **Stack Trace Analysis**
   - Read the stack trace from bottom to top to understand the call chain
   - Identify the exact line where the error originates
   - Trace the execution path leading to the error
   - Look for any obvious issues in the failing code

4. **Code Context Investigation**
   - Examine the code around the error location
   - Check recent changes that might have introduced the bug
   - Review variable values and state at the time of error
   - Analyze function parameters and return values

5. **Hypothesis Formation**
   - Based on evidence, form hypotheses about the root cause
   - Consider common causes:
     - Null pointer/undefined reference
     - Type mismatches
     - Race conditions
     - Resource exhaustion
     - Logic errors
     - External dependency failures

6. **Debugging Tools Setup**
   - Set up appropriate debugging tools for the technology stack
   - Use debugger, profiler, or logging as needed
   - Configure breakpoints at strategic locations
   - Set up monitoring and alerting if not already present

7. **Systematic Investigation**
   - Test each hypothesis methodically
   - Use binary search approach to isolate the problem
   - Add strategic logging or print statements
   - Check data flow and transformations step by step

8. **Data Validation**
   - Verify input data format and validity
   - Check for edge cases and boundary conditions
   - Validate assumptions about data state
   - Test with different data sets to isolate patterns

9. **Dependency Analysis**
   - Check external dependencies and their versions
   - Verify network connectivity and API availability
   - Review configuration files and environment variables
   - Test database connections and query execution

10. **Memory and Resource Analysis**
    - Check for memory leaks or excessive memory usage
    - Monitor CPU and I/O resource consumption
    - Analyze garbage collection patterns if applicable
    - Check for resource deadlocks or contention

11. **Concurrency Issues Investigation**
    - Look for race conditions in multi-threaded code
    - Check synchronization mechanisms and locks
    - Analyze async operations and promise handling
    - Test under different load conditions

12. **Root Cause Identification**
    - Once the cause is identified, understand why it happened
    - Determine if it's a logic error, design flaw, or external issue
    - Assess the scope and impact of the problem
    - Consider if similar issues exist elsewhere

13. **Solution Implementation**
    - Design a fix that addresses the root cause
    - Consider multiple solution approaches and trade-offs
    - Implement the fix with appropriate error handling
    - Add validation and defensive programming where needed

14. **Testing the Fix**
    - Test the fix against the original error case
    - Test edge cases and related scenarios
    - Run regression tests to ensure no new issues
    - Test under various load and stress conditions

15. **Prevention Measures**
    - Add appropriate unit and integration tests
    - Improve error handling and logging
    - Add input validation and defensive checks
    - Update documentation and code comments

16. **Monitoring and Alerting**
    - Set up monitoring for similar issues
    - Add metrics and health checks
    - Configure alerts for error thresholds
    - Implement better observability

17. **Documentation**
    - Document the error, investigation process, and solution
    - Update troubleshooting guides
    - Share learnings with the team
    - Update code comments with context

18. **Post-Resolution Review**
    - Analyze why the error wasn't caught earlier
    - Review development and testing processes
    - Consider improvements to prevent similar issues
    - Update coding standards or guidelines if needed

Remember to maintain detailed notes throughout the debugging process and consider the wider implications of both the error and the fix.

Preview capped at 60,000 characters. Download the bundle for every original file and notice.