Команда debug-error

Systematically Debug and Fix Errors

Systematically debug and fix errors

Instructions

Follow this comprehensive debugging methodology to resolve: $ARGUMENTS

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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.