arabelatso/skills-4-se/bug-history-summarizer

Bug History Summarizer

Trace and summarize the complete lifecycle of a bug across code versions.

Workflow

Follow these steps to generate a comprehensive bug history summary:

1. Identify the Bug and Gather Context

Collect essential information:

• Bug identifier: Issue number, commit hash, or bug description
• Repository: Target codebase with version history
• Version range: Specific versions/commits to analyze (or entire history)
• Related artifacts: Issue reports, pull requests, commit messages, test results

2. Trace Bug Introduction

Identify when and how the bug was introduced:

Using git blame and bisect:

• Run git blame on affected files to find when problematic lines were added
• Use git bisect to pinpoint the exact commit that introduced the bug
• Analyze the introducing commit: author, date, purpose, related changes

Analyze introduction context:

• What was the original intent of the change?
• Was it a new feature, refactoring, or bug fix?
• Were there code review comments or warnings?
• What tests existed at the time?

3. Track Detection History

Document when and how the bug was discovered:

• Initial detection: When was the bug first reported or noticed?
• Detection method: User report, automated test, code review, production incident?
• Time to detection: How long between introduction and discovery?
• Severity assessment: How was the bug initially classified?

4. Analyze Fix Attempts

Chronicle all attempts to fix the bug:

For each fix attempt:

• Commit hash and date
• Author and reviewer
• Fix approach and code changes
• Test coverage added
• Whether the fix was successful or reverted

Identify patterns:

• Multiple fix attempts indicate complexity
• Reverted fixes suggest incomplete understanding
• Test additions show learning from the bug

5. Check for Regressions

Identify if the bug reappeared after being fixed:

• Search for related bug reports after the fix
• Check if the fix was reverted or modified
• Look for similar bugs in related code
• Analyze if the bug reoccurred in different contexts

6. Generate Summary Report

Create a structured timeline and analysis:

Timeline format:

## Bug History: [Bug Title/ID]
 
### Introduction
-**When**: [Date/Commit]
-**Where**: [File:Line]
-**How**: [Description of introducing change]
-**Context**: [Why the change was made]
 
### Detection
-**Discovered**: [Date]
-**Method**: [How it was found]
-**Time to Detection**: [Duration]
-**Initial Impact**: [Severity/Scope]
 
### Fix Attempts
1.**Attempt 1** ([Date/Commit])
   -Approach: [Description]
   -Outcome: [Success/Failure/Partial]
   -Tests Added: [Yes/No]
 
2.**Attempt 2** ([Date/Commit])
   -...
 
### Regressions
-**Regression 1** ([Date])
  -Cause: [Why it reappeared]
  -Fix: [How it was resolved]
 
### Current Status
-[Fixed/Open/Recurring]
-Last modified: [Date]
 
### Lessons Learned
-[Key insights from the bug's history]

Example

Input:

• Repository: myapp
• Bug: "Null pointer exception in user login"
• Issue: #456

Analysis Process:

1. Git blame shows the problematic code was added in commit abc123 on 2024-01-15
2. Commit analysis reveals it was part of a refactoring to improve performance
3. Issue tracker shows bug reported on 2024-02-20 (36 days after introduction)
4. Fix attempts:

• First fix (commit def456, 2024-02-21): Added null check, but incomplete
• Second fix (commit ghi789, 2024-02-25): Comprehensive fix with tests

1. Regression check: No regressions found

Generated Summary:

## Bug History: Null Pointer Exception in User Login (#456)
 
### Introduction
-**When**: 2024-01-15 (commit abc123)
-**Where**: src/auth/LoginHandler.java:45
-**How**: Refactoring removed null check during performance optimization
-**Context**: Part of PR #234 to reduce login latency
 
### Detection
-**Discovered**: 2024-02-20
-**Method**: Production incident report
-**Time to Detection**: 36 days
-**Initial Impact**: High severity - blocking user logins
 
### Fix Attempts
1.**Attempt 1** (2024-02-21, commit def456)
   -Approach: Added null check for user object
   -Outcome: Partial - fixed main case but missed edge case
   -Tests Added: Yes (1 unit test)
 
2.**Attempt 2** (2024-02-25, commit ghi789)
   -Approach: Comprehensive null handling with validation
   -Outcome: Success
   -Tests Added: Yes (3 unit tests + 1 integration test)
 
### Regressions
-None detected
 
### Current Status
-Fixed (as of 2024-02-25)
-Last modified: commit ghi789
 
### Lessons Learned
-Performance optimizations should maintain defensive checks
-Initial fix was too narrow - comprehensive testing revealed edge cases
-Added regression tests to prevent reintroduction

Output Format

Provide:

1. Structured timeline in Markdown format
2. Key metrics:

• Time to detection
• Number of fix attempts
• Time to resolution
• Regression count

1. Visual timeline (optional, using ASCII or Mermaid):

``` 2024-01-15: Bug introduced (commit abc123)

2024-02-20: Bug detected (issue #456)

2024-02-21: Fix attempt 1 (partial)

2024-02-25: Fix attempt 2 (success) ```

1. Lessons learned and recommendations

Git Commands Reference

Useful commands for bug history analysis:

# Find when a line was introduced
git blame <file>
 
# Find the commit that introduced a bug
git bisect start
git bisect bad <bad-commit>
git bisect good <good-commit>
 
# Search commit messages for bug references
git log --grep="<bug-id>" --oneline
 
# Show commits that modified a specific file
git log --follow -- <file>
 
# Show commits in a date range
git log --since="2024-01-01" --until="2024-12-31"
 
# Find commits by author
git log --author="<name>"
 
# Show detailed commit information
git show <commit-hash>

Tips for Effective Bug History Analysis

1. Start with the fix - Work backwards from the fix commit to understand the bug
2. Check related files - Bugs often span multiple files
3. Read commit messages - They provide context about intent
4. Review pull requests - Comments reveal decision-making
5. Check test history - Tests added after bugs show learning
6. Look for patterns - Similar bugs may have related causes
7. Consider context - Deadlines, team changes, and technical debt affect bug introduction