feat(bd-4jn): P4-004: Smart Error Grouping
Implement smart error grouping to cluster similar errors together and reduce noise in the activity stream. Uses pattern matching on error messages and stack traces to group related errors. Features: - Error categorization into 9 categories (network, permission, validation, etc.) - Pattern-based fingerprinting for grouping similar errors - Normalization of variable data (IPs, paths, UUIDs, timestamps) - Severity calculation based on frequency and recency - Integration with InMemoryEventStore for automatic error tracking New files: - src/errorGrouping.ts - Error grouping module - src/errorGrouping.test.ts - Comprehensive test suite (34 tests) 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
jeda
parent
32d3066ed5
commit
19097e7841
10 changed files with 1850 additions and 3 deletions
|
|
@ -53,7 +53,7 @@
|
|||
{"id":"bd-3sh","title":"ALERT: Worker claude-code-glm-5-bravo has no work available","description":"# Worker Starvation Alert\n\nWorker **claude-code-glm-5-bravo** has exhausted all priorities and found zero work.\n\nThis is considered an error state - there should always be more work.\n\n## Worker State\n\n- **Executor:** claude-code-glm-5\n- **Model:** glm-5\n- **Workspace:** /home/coder/FABRIC\n- **Root Boundary:** /home/coder/FABRIC\n- **Last completion:** \n- **Beads completed:** 0\n- **Claim success rate:** %\n- **Uptime:** 14608s (h)\n- **Consecutive empty iterations:** 5\n\n## Priorities Exhausted\n\n1. ✗ Local workspace (bottoms-up): No beads in /home/coder/FABRIC or subfolders\n2. ✗ Parent exploration: No suitable workspaces found\n3. ✓ Maintenance: Completed (cleaned orphaned claims/locks)\n4. ✗ Gap analysis: false - No gaps found or created\n5. ✗ HUMAN alternatives: true - No HUMAN beads found to unblock\n\n## Discovered Workspaces\n\nTotal: 1\n\n- /home/coder/FABRIC\n\n## Required Actions\n\n1. Review discovery roots: Are all project folders being scanned?\n2. Check if projects need new features/tasks\n3. Review ROADMAP.md files across projects\n4. Enable gap analysis if disabled: `--enable-gap-analysis`\n5. Enable HUMAN alternatives if disabled\n6. Create manual beads to bootstrap work\n\n---\n*This alert was created automatically by Priority 6*","status":"closed","priority":0,"issue_type":"human","created_at":"2026-03-03T08:27:00.144567748Z","created_by":"coder","updated_at":"2026-03-03T09:04:42.456513465Z","closed_at":"2026-03-03T09:04:42.456310900Z","source_repo":".","compaction_level":0,"original_size":0,"comments":[{"id":6,"issue_id":"bd-3sh","author":"Jed Arden","text":"Alternative analysis: Worker starvation is FALSE POSITIVE. 20 beads available. Use scripts/br-ready-wrapper.sh or .beads/ready-queue.json workaround.","created_at":"2026-03-03T08:37:53Z"},{"id":8,"issue_id":"bd-3sh","author":"Jed Arden","text":"Alternative solutions explored for worker starvation. Root cause: br ready schema bug (created_by column). 22 beads available in ready-queue.json. ALT-006 (bd-9rs) implemented: scripts/br-get-next-bead.sh reads ready-queue.json directly. Workers need fallback logic.","created_at":"2026-03-03T08:40:31Z"},{"id":15,"issue_id":"bd-3sh","author":"Jed Arden","text":"False positive - work available in ready-queue.json (22 beads). Same issue as bd-123.","created_at":"2026-03-03T09:04:42Z"}]}
|
||||
{"id":"bd-3sj","title":"P4-002: File Heatmap","description":"Implement file heatmap visualization - track which files are modified most frequently and by which workers. Helps identify hotspots and potential collision areas.","status":"open","priority":3,"issue_type":"task","created_at":"2026-03-03T11:42:55.763617113Z","created_by":"coder","updated_at":"2026-03-03T11:42:55.763617113Z","source_repo":".","compaction_level":0,"original_size":0,"labels":["intelligence","phase-4","visualization"]}
|
||||
{"id":"bd-3tj","title":"TEST-003: Add TUI component tests","description":"Test Coverage: Add tests for TUI components using blessed testing patterns. Test keyboard input, panel switching, filtering.","status":"closed","priority":3,"issue_type":"task","created_at":"2026-03-03T07:53:40.669404768Z","created_by":"coder","updated_at":"2026-03-03T07:53:40.669404768Z","closed_at":"2026-03-03T07:53:40.669404768Z","source_repo":".","compaction_level":0,"original_size":0,"labels":["testing","tui"]}
|
||||
{"id":"bd-4jn","title":"P4-004: Smart Error Grouping","description":"Implement smart error grouping - cluster similar errors together to reduce noise and highlight unique issues. Pattern matching on error messages and stack traces.","status":"open","priority":3,"issue_type":"task","created_at":"2026-03-03T11:43:00.067083820Z","created_by":"coder","updated_at":"2026-03-03T11:43:00.067083820Z","source_repo":".","compaction_level":0,"original_size":0,"labels":["error-handling","intelligence","phase-4"]}
|
||||
{"id":"bd-4jn","title":"P4-004: Smart Error Grouping","description":"Implement smart error grouping - cluster similar errors together to reduce noise and highlight unique issues. Pattern matching on error messages and stack traces.","status":"in_progress","priority":3,"issue_type":"task","assignee":"coder","created_at":"2026-03-03T11:43:00.067083820Z","created_by":"coder","updated_at":"2026-03-03T11:43:51.861144781Z","source_repo":".","compaction_level":0,"original_size":0,"labels":["error-handling","intelligence","phase-4"]}
|
||||
{"id":"bd-5eh","title":"TEST-001: Add comprehensive parser tests","description":"Test Coverage: Add unit tests for edge cases in parser.ts - malformed JSON, partial lines, unicode, very long messages. Target 90% coverage.","status":"closed","priority":2,"issue_type":"task","created_at":"2026-03-03T07:53:40.185664830Z","created_by":"coder","updated_at":"2026-03-03T10:40:00Z","closed_at":"2026-03-03T10:40:00Z","close_reason":"Parser tests complete: 36 tests","source_repo":".","compaction_level":0,"original_size":0,"labels":["parser","testing"]}
|
||||
{"id":"bd-5fh","title":"ALERT: Worker claude-code-glm-5-bravo has no work available","description":"# Worker Starvation Alert\n\nWorker **claude-code-glm-5-bravo** has exhausted all priorities and found zero work.\n\nThis is considered an error state - there should always be more work.\n\n## Worker State\n\n- **Executor:** claude-code-glm-5\n- **Model:** glm-5\n- **Workspace:** /home/coder/FABRIC\n- **Root Boundary:** /home/coder/FABRIC\n- **Last completion:** \n- **Beads completed:** 0\n- **Claim success rate:** %\n- **Uptime:** 18273s (h)\n- **Consecutive empty iterations:** 5\n\n## Priorities Exhausted\n\n1. ✗ Local workspace (bottoms-up): No beads in /home/coder/FABRIC or subfolders\n2. ✗ Parent exploration: No suitable workspaces found\n3. ✓ Maintenance: Completed (cleaned orphaned claims/locks)\n4. ✗ Gap analysis: false - No gaps found or created\n5. ✗ HUMAN alternatives: true - No HUMAN beads found to unblock\n\n## Discovered Workspaces\n\nTotal: 1\n\n- /home/coder/FABRIC\n\n## Required Actions\n\n1. Review discovery roots: Are all project folders being scanned?\n2. Check if projects need new features/tasks\n3. Review ROADMAP.md files across projects\n4. Enable gap analysis if disabled: `--enable-gap-analysis`\n5. Enable HUMAN alternatives if disabled\n6. Create manual beads to bootstrap work\n\n---\n*This alert was created automatically by Priority 6*","status":"closed","priority":0,"issue_type":"human","created_at":"2026-03-03T09:28:06.053300075Z","created_by":"coder","updated_at":"2026-03-03T09:29:55.150572522Z","closed_at":"2026-03-03T09:29:36.921679055Z","source_repo":".","compaction_level":0,"original_size":0,"comments":[{"id":19,"issue_id":"bd-5fh","author":"Jed Arden","text":"FALSE POSITIVE: Work available in ready-queue.json (22 beads)","created_at":"2026-03-03T09:29:55Z"}]}
|
||||
{"id":"bd-6xy","title":"ALERT: Worker claude-code-glm-5-bravo has no work available","description":"# Worker Starvation Alert\n\nWorker **claude-code-glm-5-bravo** has exhausted all priorities and found zero work.\n\nThis is considered an error state - there should always be more work.\n\n## Worker State\n\n- **Executor:** claude-code-glm-5\n- **Model:** glm-5\n- **Workspace:** /home/coder/FABRIC\n- **Root Boundary:** /home/coder/FABRIC\n- **Last completion:** \n- **Beads completed:** 0\n- **Claim success rate:** %\n- **Uptime:** 18748s (h)\n- **Consecutive empty iterations:** 5\n\n## Priorities Exhausted\n\n1. ✗ Local workspace (bottoms-up): No beads in /home/coder/FABRIC or subfolders\n2. ✗ Parent exploration: No suitable workspaces found\n3. ✓ Maintenance: Completed (cleaned orphaned claims/locks)\n4. ✗ Gap analysis: false - No gaps found or created\n5. ✗ HUMAN alternatives: true - No HUMAN beads found to unblock\n\n## Discovered Workspaces\n\nTotal: 1\n\n- /home/coder/FABRIC\n\n## Required Actions\n\n1. Review discovery roots: Are all project folders being scanned?\n2. Check if projects need new features/tasks\n3. Review ROADMAP.md files across projects\n4. Enable gap analysis if disabled: `--enable-gap-analysis`\n5. Enable HUMAN alternatives if disabled\n6. Create manual beads to bootstrap work\n\n---\n*This alert was created automatically by Priority 6*","status":"closed","priority":0,"issue_type":"human","created_at":"2026-03-03T09:36:00.727780827Z","created_by":"coder","updated_at":"2026-03-03T09:37:27.774940828Z","closed_at":"2026-03-03T09:37:27.774712168Z","source_repo":".","compaction_level":0,"original_size":0}
|
||||
|
|
|
|||
90
src/cli.ts
90
src/cli.ts
|
|
@ -6,15 +6,18 @@
|
|||
* fabric tui - Launch terminal UI
|
||||
* fabric web - Launch web dashboard
|
||||
* fabric tail - Raw log tail
|
||||
* fabric replay - Replay session history
|
||||
*/
|
||||
|
||||
import { Command } from 'commander';
|
||||
import * as blessed from 'blessed';
|
||||
import { VERSION } from './index.js';
|
||||
import { LogTailer, tailLogFile } from './tailer.js';
|
||||
import { formatEvent } from './parser.js';
|
||||
import { getStore } from './store.js';
|
||||
import { createTuiApp } from './tui/index.js';
|
||||
import { createWebServer } from './web/index.js';
|
||||
import { SessionReplay } from './tui/components/SessionReplay.js';
|
||||
|
||||
const program = new Command();
|
||||
|
||||
|
|
@ -211,4 +214,91 @@ program
|
|||
}
|
||||
});
|
||||
|
||||
program
|
||||
.command('replay')
|
||||
.description('Replay worker session history chronologically')
|
||||
.option('-f, --file <path>', 'Log file to replay', '~/.needle/logs/workers.log')
|
||||
.option('-w, --worker <id>', 'Filter by worker ID')
|
||||
.option('-l, --level <level>', 'Filter by log level (debug/info/warn/error)')
|
||||
.option('-s, --speed <speed>', 'Playback speed (0.5/1/2/5/10)', '1')
|
||||
.option('--auto', 'Start playback automatically')
|
||||
.action(async (options) => {
|
||||
const filePath = options.file.replace('~', process.env.HOME || '');
|
||||
const speed = parseFloat(options.speed) as 0.5 | 1 | 2 | 5 | 10;
|
||||
|
||||
console.log(`FABRIC Session Replay - Loading: ${filePath}`);
|
||||
|
||||
const validLevels = ['debug', 'info', 'warn', 'error'];
|
||||
const levelFilter = options.level?.toLowerCase();
|
||||
if (levelFilter && !validLevels.includes(levelFilter)) {
|
||||
console.error(`Invalid level: ${options.level}. Must be one of: ${validLevels.join(', ')}`);
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
try {
|
||||
// Create blessed screen
|
||||
const screen = blessed.screen({
|
||||
smartCSR: true,
|
||||
title: 'FABRIC Session Replay',
|
||||
fullUnicode: true,
|
||||
});
|
||||
|
||||
// Create session replay component
|
||||
const replay = new SessionReplay({
|
||||
parent: screen,
|
||||
top: 0,
|
||||
left: 0,
|
||||
width: '100%',
|
||||
height: '100%',
|
||||
onEvent: (event, index, total) => {
|
||||
// Could emit to store if needed
|
||||
},
|
||||
onStateChange: (state) => {
|
||||
if (state === 'ended') {
|
||||
// Show ended message
|
||||
}
|
||||
},
|
||||
});
|
||||
|
||||
// Set initial speed
|
||||
if ([0.5, 1, 2, 5, 10].includes(speed)) {
|
||||
replay.setSpeed(speed);
|
||||
}
|
||||
|
||||
// Bind global keys
|
||||
screen.key(['q', 'C-c'], () => {
|
||||
replay.destroy();
|
||||
screen.destroy();
|
||||
process.exit(0);
|
||||
});
|
||||
|
||||
screen.key(['escape'], () => {
|
||||
replay.destroy();
|
||||
screen.destroy();
|
||||
process.exit(0);
|
||||
});
|
||||
|
||||
// Build filter
|
||||
const filter: { worker?: string; level?: string } = {};
|
||||
if (options.worker) filter.worker = options.worker;
|
||||
if (levelFilter) filter.level = levelFilter;
|
||||
|
||||
// Load the log file
|
||||
await replay.loadFile(filePath, Object.keys(filter).length > 0 ? filter : undefined);
|
||||
|
||||
// Focus and render
|
||||
replay.focus();
|
||||
screen.render();
|
||||
|
||||
// Auto-start if requested
|
||||
if (options.auto) {
|
||||
setTimeout(() => replay.play(), 500);
|
||||
}
|
||||
|
||||
} catch (err) {
|
||||
console.error(`Failed to start replay: ${(err as Error).message}`);
|
||||
process.exit(1);
|
||||
}
|
||||
});
|
||||
|
||||
program.parse();
|
||||
|
|
|
|||
435
src/errorGrouping.test.ts
Normal file
435
src/errorGrouping.test.ts
Normal file
|
|
@ -0,0 +1,435 @@
|
|||
/**
|
||||
* Tests for Error Grouping Module
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
|
||||
import {
|
||||
categorizeError,
|
||||
fingerprintError,
|
||||
fingerprintsMatch,
|
||||
ErrorGroupManager,
|
||||
getErrorGroupManager,
|
||||
resetErrorGroupManager,
|
||||
} from './errorGrouping.js';
|
||||
import { LogEvent, ErrorCategory } from './types.js';
|
||||
|
||||
describe('categorizeError', () => {
|
||||
it('should categorize network errors', () => {
|
||||
expect(categorizeError('ECONNREFUSED')).toBe('network');
|
||||
expect(categorizeError('Connection refused to 192.168.1.1:8080')).toBe('network');
|
||||
expect(categorizeError('ETIMEDOUT connecting to server')).toBe('network');
|
||||
expect(categorizeError('DNS lookup failed')).toBe('network');
|
||||
expect(categorizeError('socket hang up')).toBe('network');
|
||||
});
|
||||
|
||||
it('should categorize permission errors', () => {
|
||||
expect(categorizeError('EACCES: permission denied')).toBe('permission');
|
||||
expect(categorizeError('Access denied for user admin')).toBe('permission');
|
||||
expect(categorizeError('Unauthorized (401)')).toBe('permission');
|
||||
expect(categorizeError('Forbidden: insufficient permissions')).toBe('permission');
|
||||
});
|
||||
|
||||
it('should categorize not found errors', () => {
|
||||
expect(categorizeError('ENOENT: no such file')).toBe('not_found');
|
||||
expect(categorizeError('404 Not Found')).toBe('not_found');
|
||||
expect(categorizeError('Resource does not exist')).toBe('not_found');
|
||||
});
|
||||
|
||||
it('should categorize timeout errors', () => {
|
||||
expect(categorizeError('ETIMEDOUT')).toBe('timeout');
|
||||
expect(categorizeError('Request timeout after 30000ms')).toBe('timeout');
|
||||
expect(categorizeError('Timeout expired')).toBe('timeout');
|
||||
});
|
||||
|
||||
it('should categorize resource errors', () => {
|
||||
expect(categorizeError('ENOMEM: out of memory')).toBe('resource');
|
||||
expect(categorizeError('Disk full, no space left')).toBe('resource');
|
||||
expect(categorizeError('Rate limit exceeded (429)')).toBe('resource');
|
||||
expect(categorizeError('Quota exceeded for user')).toBe('resource');
|
||||
});
|
||||
|
||||
it('should categorize validation errors', () => {
|
||||
expect(categorizeError('Invalid input format')).toBe('validation');
|
||||
expect(categorizeError('Cannot read property "x" of undefined')).toBe('validation');
|
||||
expect(categorizeError('Expected string but got number')).toBe('validation');
|
||||
expect(categorizeError('undefined is not a function')).toBe('validation');
|
||||
});
|
||||
|
||||
it('should categorize syntax errors', () => {
|
||||
expect(categorizeError('SyntaxError: Unexpected token')).toBe('syntax');
|
||||
expect(categorizeError('JSON parse error at line 42')).toBe('syntax');
|
||||
expect(categorizeError('YAML parse error')).toBe('syntax');
|
||||
expect(categorizeError('invalid format: malformed input')).toBe('syntax');
|
||||
});
|
||||
|
||||
it('should categorize tool errors', () => {
|
||||
expect(categorizeError('Tool execution failed')).toBe('tool');
|
||||
expect(categorizeError('Command failed with exit code 1')).toBe('tool');
|
||||
expect(categorizeError('spawn child process error')).toBe('tool');
|
||||
});
|
||||
|
||||
it('should return unknown for unrecognized errors', () => {
|
||||
expect(categorizeError('Something weird happened')).toBe('unknown');
|
||||
expect(categorizeError('Oops')).toBe('unknown');
|
||||
});
|
||||
});
|
||||
|
||||
describe('fingerprintError', () => {
|
||||
const createErrorEvent = (msg: string, error?: string): LogEvent => ({
|
||||
ts: Date.now(),
|
||||
worker: 'w-test',
|
||||
level: 'error',
|
||||
msg,
|
||||
error,
|
||||
});
|
||||
|
||||
it('should create consistent fingerprints for similar errors', () => {
|
||||
const event1 = createErrorEvent('Connection refused', 'ECONNREFUSED 192.168.1.1:8080');
|
||||
const event2 = createErrorEvent('Connection refused', 'ECONNREFUSED 10.0.0.1:3000');
|
||||
|
||||
const fp1 = fingerprintError(event1);
|
||||
const fp2 = fingerprintError(event2);
|
||||
|
||||
expect(fp1.hash).toBe(fp2.hash);
|
||||
expect(fp1.category).toBe('network');
|
||||
expect(fp2.category).toBe('network');
|
||||
});
|
||||
|
||||
it('should create different fingerprints for different error types', () => {
|
||||
const event1 = createErrorEvent('Error', 'ECONNREFUSED');
|
||||
const event2 = createErrorEvent('Error', 'Permission denied');
|
||||
|
||||
const fp1 = fingerprintError(event1);
|
||||
const fp2 = fingerprintError(event2);
|
||||
|
||||
expect(fp1.hash).not.toBe(fp2.hash);
|
||||
expect(fp1.category).toBe('network');
|
||||
expect(fp2.category).toBe('permission');
|
||||
});
|
||||
|
||||
it('should normalize IP addresses', () => {
|
||||
const event = createErrorEvent('Network error', 'ECONNREFUSED 192.168.1.100:443');
|
||||
|
||||
const fp = fingerprintError(event);
|
||||
|
||||
// IP addresses should be normalized to wildcards
|
||||
expect(fp.signature).toMatch(/\*:\*/);
|
||||
expect(fp.category).toBe('network');
|
||||
});
|
||||
|
||||
it('should normalize file paths', () => {
|
||||
const event = createErrorEvent('File error', 'ENOENT: no such file "/home/user/data.json"');
|
||||
|
||||
const fp = fingerprintError(event);
|
||||
|
||||
expect(fp.signature).not.toContain('/home/user/data.json');
|
||||
expect(fp.category).toBe('not_found');
|
||||
});
|
||||
|
||||
it('should normalize UUIDs', () => {
|
||||
const event = createErrorEvent('Error', 'Invalid UUID 123e4567-e89b-12d3-a456-426614174000');
|
||||
|
||||
const fp = fingerprintError(event);
|
||||
|
||||
expect(fp.signature).not.toContain('123e4567-e89b-12d3-a456-426614174000');
|
||||
expect(fp.signature).toContain('*UUID*');
|
||||
});
|
||||
|
||||
it('should use event.msg when event.error is not present', () => {
|
||||
const event = createErrorEvent('ECONNREFUSED connection failed');
|
||||
|
||||
const fp = fingerprintError(event);
|
||||
|
||||
expect(fp.sampleMessage).toBe('ECONNREFUSED connection failed');
|
||||
expect(fp.category).toBe('network');
|
||||
});
|
||||
|
||||
it('should truncate long signatures', () => {
|
||||
const longMessage = 'ECONNREFUSED ' + 'x'.repeat(300);
|
||||
const event = createErrorEvent('Error', longMessage);
|
||||
|
||||
const fp = fingerprintError(event);
|
||||
|
||||
expect(fp.signature.length).toBeLessThanOrEqual(203); // 200 + '...'
|
||||
});
|
||||
|
||||
it('should remove stack traces from signature', () => {
|
||||
const event = createErrorEvent('Error', 'TypeError: Cannot read property "x"\n at Object.foo\n at bar');
|
||||
|
||||
const fp = fingerprintError(event);
|
||||
|
||||
expect(fp.signature).not.toContain('at Object.foo');
|
||||
expect(fp.signature).toContain('TypeError');
|
||||
});
|
||||
});
|
||||
|
||||
describe('fingerprintsMatch', () => {
|
||||
it('should return true for matching fingerprints', () => {
|
||||
const event: LogEvent = {
|
||||
ts: Date.now(),
|
||||
worker: 'w-test',
|
||||
level: 'error',
|
||||
msg: 'ECONNREFUSED',
|
||||
};
|
||||
|
||||
const fp1 = fingerprintError(event);
|
||||
const fp2 = fingerprintError(event);
|
||||
|
||||
expect(fingerprintsMatch(fp1, fp2)).toBe(true);
|
||||
});
|
||||
|
||||
it('should return false for different fingerprints', () => {
|
||||
const event1: LogEvent = {
|
||||
ts: Date.now(),
|
||||
worker: 'w-test',
|
||||
level: 'error',
|
||||
msg: 'ECONNREFUSED',
|
||||
};
|
||||
const event2: LogEvent = {
|
||||
ts: Date.now(),
|
||||
worker: 'w-test',
|
||||
level: 'error',
|
||||
msg: 'Permission denied',
|
||||
};
|
||||
|
||||
const fp1 = fingerprintError(event1);
|
||||
const fp2 = fingerprintError(event2);
|
||||
|
||||
expect(fingerprintsMatch(fp1, fp2)).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('ErrorGroupManager', () => {
|
||||
let manager: ErrorGroupManager;
|
||||
|
||||
beforeEach(() => {
|
||||
manager = new ErrorGroupManager();
|
||||
});
|
||||
|
||||
const createErrorEvent = (msg: string, worker = 'w-test'): LogEvent => ({
|
||||
ts: Date.now(),
|
||||
worker,
|
||||
level: 'error',
|
||||
msg,
|
||||
});
|
||||
|
||||
describe('addError', () => {
|
||||
it('should create a new group for first error', () => {
|
||||
const event = createErrorEvent('ECONNREFUSED');
|
||||
const group = manager.addError(event);
|
||||
|
||||
expect(group.count).toBe(1);
|
||||
expect(group.events).toHaveLength(1);
|
||||
expect(group.fingerprint.category).toBe('network');
|
||||
expect(group.affectedWorkers).toContain('w-test');
|
||||
});
|
||||
|
||||
it('should add to existing group for similar errors', () => {
|
||||
const event1 = createErrorEvent('ECONNREFUSED 192.168.1.1:8080');
|
||||
const event2 = createErrorEvent('ECONNREFUSED 10.0.0.1:3000');
|
||||
|
||||
const group1 = manager.addError(event1);
|
||||
const group2 = manager.addError(event2);
|
||||
|
||||
expect(group1.id).toBe(group2.id);
|
||||
expect(group2.count).toBe(2);
|
||||
});
|
||||
|
||||
it('should track multiple workers', () => {
|
||||
const event1 = createErrorEvent('ECONNREFUSED', 'w-worker1');
|
||||
const event2 = createErrorEvent('ECONNREFUSED', 'w-worker2');
|
||||
const event3 = createErrorEvent('ECONNREFUSED', 'w-worker1');
|
||||
|
||||
manager.addError(event1);
|
||||
manager.addError(event2);
|
||||
const group = manager.addError(event3);
|
||||
|
||||
expect(group.affectedWorkers).toHaveLength(2);
|
||||
expect(group.affectedWorkers).toContain('w-worker1');
|
||||
expect(group.affectedWorkers).toContain('w-worker2');
|
||||
expect(group.count).toBe(3);
|
||||
});
|
||||
|
||||
it('should create separate groups for different error types', () => {
|
||||
const event1 = createErrorEvent('ECONNREFUSED');
|
||||
const event2 = createErrorEvent('Permission denied');
|
||||
|
||||
const group1 = manager.addError(event1);
|
||||
const group2 = manager.addError(event2);
|
||||
|
||||
expect(group1.id).not.toBe(group2.id);
|
||||
expect(manager.size).toBe(2);
|
||||
});
|
||||
});
|
||||
|
||||
describe('getGroups', () => {
|
||||
it('should return all groups sorted by severity and activity', () => {
|
||||
// Add multiple errors of different types
|
||||
for (let i = 0; i < 10; i++) {
|
||||
manager.addError(createErrorEvent('ECONNREFUSED'));
|
||||
}
|
||||
for (let i = 0; i < 5; i++) {
|
||||
manager.addError(createErrorEvent('Permission denied'));
|
||||
}
|
||||
manager.addError(createErrorEvent('Timeout'));
|
||||
|
||||
const groups = manager.getGroups();
|
||||
|
||||
// First group should be the one with most occurrences (network)
|
||||
expect(groups[0].count).toBe(10);
|
||||
expect(groups[0].fingerprint.category).toBe('network');
|
||||
});
|
||||
});
|
||||
|
||||
describe('getActiveGroups', () => {
|
||||
it('should return only active groups', () => {
|
||||
manager.addError(createErrorEvent('ECONNREFUSED'));
|
||||
|
||||
const activeGroups = manager.getActiveGroups();
|
||||
|
||||
expect(activeGroups).toHaveLength(1);
|
||||
});
|
||||
|
||||
it('should not return inactive groups', () => {
|
||||
// Create manager with very short active window
|
||||
const shortManager = new ErrorGroupManager({ activeWindowMs: 1 });
|
||||
const event: LogEvent = {
|
||||
ts: Date.now() - 10000, // 10 seconds ago
|
||||
worker: 'w-test',
|
||||
level: 'error',
|
||||
msg: 'ECONNREFUSED',
|
||||
};
|
||||
|
||||
shortManager.addError(event);
|
||||
const activeGroups = shortManager.getActiveGroups();
|
||||
|
||||
expect(activeGroups).toHaveLength(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('getWorkerGroups', () => {
|
||||
it('should return groups affecting specific worker', () => {
|
||||
manager.addError(createErrorEvent('ECONNREFUSED', 'w-worker1'));
|
||||
manager.addError(createErrorEvent('Permission denied', 'w-worker2'));
|
||||
|
||||
const worker1Groups = manager.getWorkerGroups('w-worker1');
|
||||
const worker2Groups = manager.getWorkerGroups('w-worker2');
|
||||
|
||||
expect(worker1Groups).toHaveLength(1);
|
||||
expect(worker1Groups[0].fingerprint.category).toBe('network');
|
||||
|
||||
expect(worker2Groups).toHaveLength(1);
|
||||
expect(worker2Groups[0].fingerprint.category).toBe('permission');
|
||||
});
|
||||
});
|
||||
|
||||
describe('getGroupsByCategory', () => {
|
||||
it('should return groups by category', () => {
|
||||
manager.addError(createErrorEvent('ECONNREFUSED connection refused'));
|
||||
manager.addError(createErrorEvent('Permission denied access error'));
|
||||
manager.addError(createErrorEvent('File not found'));
|
||||
|
||||
const networkGroups = manager.getGroupsByCategory('network');
|
||||
const permissionGroups = manager.getGroupsByCategory('permission');
|
||||
const notFoundGroups = manager.getGroupsByCategory('not_found');
|
||||
|
||||
expect(networkGroups).toHaveLength(1);
|
||||
expect(permissionGroups).toHaveLength(1);
|
||||
expect(notFoundGroups).toHaveLength(1);
|
||||
expect(manager.size).toBe(3);
|
||||
});
|
||||
});
|
||||
|
||||
describe('getStats', () => {
|
||||
it('should return correct statistics', () => {
|
||||
for (let i = 0; i < 5; i++) {
|
||||
manager.addError(createErrorEvent('ECONNREFUSED'));
|
||||
}
|
||||
for (let i = 0; i < 3; i++) {
|
||||
manager.addError(createErrorEvent('Permission denied'));
|
||||
}
|
||||
|
||||
const stats = manager.getStats();
|
||||
|
||||
expect(stats.totalGroups).toBe(2);
|
||||
expect(stats.totalErrors).toBe(8);
|
||||
expect(stats.activeGroups).toBe(2);
|
||||
expect(stats.byCategory.network).toBe(1);
|
||||
expect(stats.byCategory.permission).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe('clear', () => {
|
||||
it('should clear all groups', () => {
|
||||
manager.addError(createErrorEvent('ECONNREFUSED'));
|
||||
manager.addError(createErrorEvent('Permission denied'));
|
||||
|
||||
expect(manager.size).toBe(2);
|
||||
|
||||
manager.clear();
|
||||
|
||||
expect(manager.size).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('maxGroups option', () => {
|
||||
it('should trim groups when exceeding maxGroups', () => {
|
||||
const smallManager = new ErrorGroupManager({ maxGroups: 5 });
|
||||
|
||||
// Add 10 different error types
|
||||
for (let i = 0; i < 10; i++) {
|
||||
smallManager.addError(createErrorEvent(`Unique error ${i}`));
|
||||
}
|
||||
|
||||
expect(smallManager.size).toBeLessThanOrEqual(5);
|
||||
});
|
||||
});
|
||||
|
||||
describe('severity calculation', () => {
|
||||
it('should increase severity with count', () => {
|
||||
const manager = new ErrorGroupManager({
|
||||
highSeverityThreshold: 3,
|
||||
criticalSeverityThreshold: 5,
|
||||
});
|
||||
|
||||
for (let i = 0; i < 5; i++) {
|
||||
manager.addError(createErrorEvent('ECONNREFUSED'));
|
||||
}
|
||||
|
||||
const groups = manager.getGroups();
|
||||
expect(groups[0].severity).toBe('critical');
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('Global manager', () => {
|
||||
beforeEach(() => {
|
||||
resetErrorGroupManager();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
resetErrorGroupManager();
|
||||
});
|
||||
|
||||
it('should return singleton instance', () => {
|
||||
const manager1 = getErrorGroupManager();
|
||||
const manager2 = getErrorGroupManager();
|
||||
|
||||
expect(manager1).toBe(manager2);
|
||||
});
|
||||
|
||||
it('should reset singleton', () => {
|
||||
const manager1 = getErrorGroupManager();
|
||||
manager1.addError({
|
||||
ts: Date.now(),
|
||||
worker: 'w-test',
|
||||
level: 'error',
|
||||
msg: 'Test error',
|
||||
});
|
||||
|
||||
resetErrorGroupManager();
|
||||
|
||||
const manager2 = getErrorGroupManager();
|
||||
expect(manager2.size).toBe(0);
|
||||
});
|
||||
});
|
||||
546
src/errorGrouping.ts
Normal file
546
src/errorGrouping.ts
Normal file
|
|
@ -0,0 +1,546 @@
|
|||
/**
|
||||
* FABRIC Error Grouping Module
|
||||
*
|
||||
* Clusters similar errors together to reduce noise and highlight unique issues.
|
||||
* Uses pattern matching on error messages and stack traces to group related errors.
|
||||
*/
|
||||
|
||||
import { LogEvent, ErrorFingerprint, ErrorCategory, ErrorGroup, ErrorGroupingOptions } from './types.js';
|
||||
|
||||
// Simple hash function for signatures
|
||||
function simpleHash(str: string): string {
|
||||
let hash = 0;
|
||||
for (let i = 0; i < str.length; i++) {
|
||||
const char = str.charCodeAt(i);
|
||||
hash = ((hash << 5) - hash) + char;
|
||||
hash = hash & hash; // Convert to 32bit integer
|
||||
}
|
||||
return Math.abs(hash).toString(16).padStart(8, '0');
|
||||
}
|
||||
|
||||
// Pattern matchers for error categorization
|
||||
interface ErrorPattern {
|
||||
category: ErrorCategory;
|
||||
patterns: RegExp[];
|
||||
normalizers: Array<(msg: string) => string>;
|
||||
}
|
||||
|
||||
const ERROR_PATTERNS: ErrorPattern[] = [
|
||||
{
|
||||
category: 'network',
|
||||
patterns: [
|
||||
/ECONNREFUSED/i,
|
||||
/ECONNRESET/i,
|
||||
/EPIPE/i,
|
||||
/ENOTFOUND/i,
|
||||
/EAI_AGAIN/i,
|
||||
/ETIMEDOUT.*connect/i,
|
||||
/socket hang up/i,
|
||||
/network unreachable/i,
|
||||
/connection refused/i,
|
||||
/connection reset/i,
|
||||
/connection closed/i,
|
||||
/getaddrinfo/i,
|
||||
/DNS/i,
|
||||
],
|
||||
normalizers: [
|
||||
// Normalize host:port patterns
|
||||
(msg) => msg.replace(/(\d{1,3}\.){3}\d{1,3}(:\d+)?/g, '*:*'),
|
||||
(msg) => msg.replace(/[a-zA-Z0-9-]+\.[a-zA-Z]{2,}(:\d+)?/g, '*:*'),
|
||||
// Normalize connection IDs
|
||||
(msg) => msg.replace(/connection #[\d]+/gi, 'connection #*'),
|
||||
],
|
||||
},
|
||||
{
|
||||
category: 'permission',
|
||||
patterns: [
|
||||
/EACCES/i,
|
||||
/EPERM/i,
|
||||
/permission denied/i,
|
||||
/access denied/i,
|
||||
/unauthorized/i,
|
||||
/forbidden/i,
|
||||
/authentication failed/i,
|
||||
/invalid.*credentials/i,
|
||||
/not authorized/i,
|
||||
/insufficient permissions/i,
|
||||
/403/i,
|
||||
/401/i,
|
||||
],
|
||||
normalizers: [
|
||||
// Normalize file paths
|
||||
(msg) => msg.replace(/\/[\w./-]+/g, '/*'),
|
||||
// Normalize usernames
|
||||
(msg) => msg.replace(/user ['"][\w@.-]+['"]/gi, 'user "*"'),
|
||||
],
|
||||
},
|
||||
{
|
||||
category: 'not_found',
|
||||
patterns: [
|
||||
/ENOENT/i,
|
||||
/no such file/i,
|
||||
/not found/i,
|
||||
/does not exist/i,
|
||||
/404/i,
|
||||
/resource not found/i,
|
||||
/no matching/i,
|
||||
],
|
||||
normalizers: [
|
||||
// Normalize file paths
|
||||
(msg) => msg.replace(/['"]\/[\w./-]+['"]/g, '"/*"'),
|
||||
(msg) => msg.replace(/['"][\w-]+\.[\w]+['"]/g, '"*"'),
|
||||
],
|
||||
},
|
||||
{
|
||||
category: 'timeout',
|
||||
patterns: [
|
||||
/ETIMEDOUT/i,
|
||||
/timed? out/i,
|
||||
/timeout expired/i,
|
||||
/deadline exceeded/i,
|
||||
/request timeout/i,
|
||||
],
|
||||
normalizers: [
|
||||
// Normalize durations
|
||||
(msg) => msg.replace(/\d+\s*(ms|seconds?|minutes?|s|m)/gi, '*ms'),
|
||||
(msg) => msg.replace(/after \d+/gi, 'after *'),
|
||||
],
|
||||
},
|
||||
{
|
||||
category: 'resource',
|
||||
patterns: [
|
||||
/ENOMEM/i,
|
||||
/out of memory/i,
|
||||
/disk full/i,
|
||||
/no space left/i,
|
||||
/quota exceeded/i,
|
||||
/limit exceeded/i,
|
||||
/rate limit/i,
|
||||
/too many requests/i,
|
||||
/429/i,
|
||||
/resource exhausted/i,
|
||||
],
|
||||
normalizers: [
|
||||
// Normalize numbers
|
||||
(msg) => msg.replace(/\d+(?:\.\d+)?\s*(bytes?|kb|mb|gb|tb)/gi, '*B'),
|
||||
(msg) => msg.replace(/limit of \d+/gi, 'limit of *'),
|
||||
],
|
||||
},
|
||||
// Syntax errors must be checked BEFORE validation errors
|
||||
// because "SyntaxError: unexpected token" should match syntax, not validation
|
||||
{
|
||||
category: 'syntax',
|
||||
patterns: [
|
||||
/SyntaxError/i,
|
||||
/parse error/i,
|
||||
/JSON parse/i,
|
||||
/YAML parse/i,
|
||||
/invalid format/i,
|
||||
],
|
||||
normalizers: [
|
||||
// Normalize line numbers
|
||||
(msg) => msg.replace(/at line \d+/gi, 'at line *'),
|
||||
(msg) => msg.replace(/position \d+/gi, 'position *'),
|
||||
// Normalize quoted strings
|
||||
(msg) => msg.replace(/['"][^'"]{1,30}['"]/g, '"*"'),
|
||||
],
|
||||
},
|
||||
{
|
||||
category: 'validation',
|
||||
patterns: [
|
||||
/invalid/i,
|
||||
/malformed/i,
|
||||
/unexpected token/i,
|
||||
/expected.*but got/i,
|
||||
/validation failed/i,
|
||||
/schema validation/i,
|
||||
/type error/i,
|
||||
/cannot read/i,
|
||||
/cannot set/i,
|
||||
/undefined is not/i,
|
||||
/null is not/i,
|
||||
/is not a function/i,
|
||||
/is not defined/i,
|
||||
],
|
||||
normalizers: [
|
||||
// Normalize property names
|
||||
(msg) => msg.replace(/property ['"][\w.]+['"]/gi, 'property "*"'),
|
||||
(msg) => msg.replace(/['"][\w.]+['"] is not/gi, '"*" is not'),
|
||||
// Normalize types
|
||||
(msg) => msg.replace(/expected [\w<>[\]]+/gi, 'expected *'),
|
||||
],
|
||||
},
|
||||
{
|
||||
category: 'tool',
|
||||
patterns: [
|
||||
/tool.*failed/i,
|
||||
/tool.*error/i,
|
||||
/execution failed/i,
|
||||
/command failed/i,
|
||||
/exit code \d+/i,
|
||||
/non-zero exit/i,
|
||||
/spawn.*error/i,
|
||||
/child process/i,
|
||||
],
|
||||
normalizers: [
|
||||
// Normalize command arguments
|
||||
(msg) => msg.replace(/--[\w-]+=\S+/g, '--*=*'),
|
||||
(msg) => msg.replace(/exit code \d+/gi, 'exit code *'),
|
||||
],
|
||||
},
|
||||
];
|
||||
|
||||
/**
|
||||
* Default grouping options
|
||||
*/
|
||||
const DEFAULT_OPTIONS: Required<ErrorGroupingOptions> = {
|
||||
activeWindowMs: 5 * 60 * 1000, // 5 minutes
|
||||
highSeverityThreshold: 5,
|
||||
criticalSeverityThreshold: 10,
|
||||
maxGroups: 100,
|
||||
};
|
||||
|
||||
/**
|
||||
* Categorize an error message
|
||||
*/
|
||||
export function categorizeError(message: string): ErrorCategory {
|
||||
for (const pattern of ERROR_PATTERNS) {
|
||||
for (const regex of pattern.patterns) {
|
||||
if (regex.test(message)) {
|
||||
return pattern.category;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 'unknown';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a fingerprint for an error event
|
||||
*/
|
||||
export function fingerprintError(event: LogEvent): ErrorFingerprint {
|
||||
const message = event.error || event.msg;
|
||||
|
||||
// Find matching category and normalizers
|
||||
let category: ErrorCategory = 'unknown';
|
||||
let normalizers: Array<(msg: string) => string> = [];
|
||||
|
||||
for (const pattern of ERROR_PATTERNS) {
|
||||
for (const regex of pattern.patterns) {
|
||||
if (regex.test(message)) {
|
||||
category = pattern.category;
|
||||
normalizers = pattern.normalizers;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (category !== 'unknown') break;
|
||||
}
|
||||
|
||||
// Apply normalizers to create signature
|
||||
let signature = message;
|
||||
for (const normalize of normalizers) {
|
||||
signature = normalize(signature);
|
||||
}
|
||||
|
||||
// Also normalize common patterns
|
||||
signature = signature
|
||||
// UUIDs
|
||||
.replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, '*UUID*')
|
||||
// Hex strings (longer than 8 chars)
|
||||
.replace(/0x[0-9a-f]{8,}/gi, '*HEX*')
|
||||
// Numbers
|
||||
.replace(/\b\d{4,}\b/g, '*')
|
||||
// Timestamps
|
||||
.replace(/\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}/g, '*TIMESTAMP*')
|
||||
// Stack traces - keep first line only
|
||||
.split('\n')[0]
|
||||
.trim();
|
||||
|
||||
// Truncate very long signatures
|
||||
if (signature.length > 200) {
|
||||
signature = signature.substring(0, 200) + '...';
|
||||
}
|
||||
|
||||
const hash = simpleHash(signature + ':' + category);
|
||||
|
||||
return {
|
||||
signature,
|
||||
category,
|
||||
sampleMessage: message,
|
||||
hash,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if two fingerprints represent the same error group
|
||||
*/
|
||||
export function fingerprintsMatch(a: ErrorFingerprint, b: ErrorFingerprint): boolean {
|
||||
return a.hash === b.hash;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate severity based on count and recency
|
||||
*/
|
||||
function calculateSeverity(
|
||||
count: number,
|
||||
lastSeen: number,
|
||||
options: Required<ErrorGroupingOptions>
|
||||
): 'low' | 'medium' | 'high' | 'critical' {
|
||||
const now = Date.now();
|
||||
const isActive = (now - lastSeen) < options.activeWindowMs;
|
||||
|
||||
if (!isActive) {
|
||||
return 'low';
|
||||
}
|
||||
|
||||
if (count >= options.criticalSeverityThreshold) {
|
||||
return 'critical';
|
||||
}
|
||||
|
||||
if (count >= options.highSeverityThreshold) {
|
||||
return 'high';
|
||||
}
|
||||
|
||||
if (count >= 2) {
|
||||
return 'medium';
|
||||
}
|
||||
|
||||
return 'low';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a unique group ID
|
||||
*/
|
||||
function generateGroupId(): string {
|
||||
return `eg-${Date.now().toString(36)}-${Math.random().toString(36).substring(2, 8)}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Error Group Manager
|
||||
*
|
||||
* Manages error groups and provides grouping functionality.
|
||||
*/
|
||||
export class ErrorGroupManager {
|
||||
private groups: Map<string, ErrorGroup> = new Map();
|
||||
private hashToGroup: Map<string, string> = new Map(); // hash -> groupId
|
||||
private options: Required<ErrorGroupingOptions>;
|
||||
|
||||
constructor(options: ErrorGroupingOptions = {}) {
|
||||
this.options = { ...DEFAULT_OPTIONS, ...options };
|
||||
}
|
||||
|
||||
/**
|
||||
* Add an error event to the appropriate group
|
||||
*/
|
||||
addError(event: LogEvent): ErrorGroup {
|
||||
const fingerprint = fingerprintError(event);
|
||||
const existingGroupId = this.hashToGroup.get(fingerprint.hash);
|
||||
|
||||
if (existingGroupId) {
|
||||
// Add to existing group
|
||||
const group = this.groups.get(existingGroupId)!;
|
||||
group.events.push(event);
|
||||
group.count++;
|
||||
group.lastSeen = event.ts;
|
||||
|
||||
if (!group.affectedWorkers.includes(event.worker)) {
|
||||
group.affectedWorkers.push(event.worker);
|
||||
}
|
||||
|
||||
// Update severity
|
||||
group.severity = calculateSeverity(group.count, group.lastSeen, this.options);
|
||||
group.isActive = (Date.now() - group.lastSeen) < this.options.activeWindowMs;
|
||||
|
||||
return group;
|
||||
}
|
||||
|
||||
// Create new group
|
||||
const groupId = generateGroupId();
|
||||
const group: ErrorGroup = {
|
||||
id: groupId,
|
||||
fingerprint,
|
||||
events: [event],
|
||||
firstSeen: event.ts,
|
||||
lastSeen: event.ts,
|
||||
count: 1,
|
||||
affectedWorkers: [event.worker],
|
||||
isActive: true,
|
||||
severity: 'low',
|
||||
};
|
||||
|
||||
this.groups.set(groupId, group);
|
||||
this.hashToGroup.set(fingerprint.hash, groupId);
|
||||
|
||||
// Trim if over limit
|
||||
if (this.groups.size > this.options.maxGroups) {
|
||||
this.trimGroups();
|
||||
}
|
||||
|
||||
return group;
|
||||
}
|
||||
|
||||
/**
|
||||
* Trim oldest/inactive groups when over limit
|
||||
*/
|
||||
private trimGroups(): void {
|
||||
// Sort groups by lastSeen (oldest first)
|
||||
const sortedGroups = Array.from(this.groups.entries())
|
||||
.sort((a, b) => a[1].lastSeen - b[1].lastSeen);
|
||||
|
||||
// Remove oldest inactive groups first
|
||||
const toRemove: string[] = [];
|
||||
for (const [groupId, group] of sortedGroups) {
|
||||
if (!group.isActive && this.groups.size - toRemove.length > this.options.maxGroups * 0.8) {
|
||||
toRemove.push(groupId);
|
||||
}
|
||||
}
|
||||
|
||||
// If still over limit, remove oldest regardless of status
|
||||
while (this.groups.size - toRemove.length > this.options.maxGroups) {
|
||||
const oldest = sortedGroups.find(([id]) => !toRemove.includes(id));
|
||||
if (oldest) {
|
||||
toRemove.push(oldest[0]);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Remove selected groups
|
||||
for (const groupId of toRemove) {
|
||||
const group = this.groups.get(groupId);
|
||||
if (group) {
|
||||
this.hashToGroup.delete(group.fingerprint.hash);
|
||||
this.groups.delete(groupId);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all error groups
|
||||
*/
|
||||
getGroups(): ErrorGroup[] {
|
||||
// Update active status before returning
|
||||
const now = Date.now();
|
||||
for (const group of this.groups.values()) {
|
||||
group.isActive = (now - group.lastSeen) < this.options.activeWindowMs;
|
||||
group.severity = calculateSeverity(group.count, group.lastSeen, this.options);
|
||||
}
|
||||
|
||||
return Array.from(this.groups.values())
|
||||
.sort((a, b) => {
|
||||
// Sort by: active first, then severity, then count
|
||||
if (a.isActive !== b.isActive) return a.isActive ? -1 : 1;
|
||||
const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
|
||||
if (severityOrder[a.severity] !== severityOrder[b.severity]) {
|
||||
return severityOrder[a.severity] - severityOrder[b.severity];
|
||||
}
|
||||
return b.count - a.count;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Get active error groups only
|
||||
*/
|
||||
getActiveGroups(): ErrorGroup[] {
|
||||
return this.getGroups().filter(g => g.isActive);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a specific group by ID
|
||||
*/
|
||||
getGroup(groupId: string): ErrorGroup | undefined {
|
||||
return this.groups.get(groupId);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get groups affecting a specific worker
|
||||
*/
|
||||
getWorkerGroups(workerId: string): ErrorGroup[] {
|
||||
return this.getGroups().filter(g => g.affectedWorkers.includes(workerId));
|
||||
}
|
||||
|
||||
/**
|
||||
* Get groups by category
|
||||
*/
|
||||
getGroupsByCategory(category: ErrorCategory): ErrorGroup[] {
|
||||
return this.getGroups().filter(g => g.fingerprint.category === category);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get summary statistics
|
||||
*/
|
||||
getStats(): {
|
||||
totalGroups: number;
|
||||
activeGroups: number;
|
||||
totalErrors: number;
|
||||
byCategory: Record<ErrorCategory, number>;
|
||||
bySeverity: Record<string, number>;
|
||||
} {
|
||||
const groups = this.getGroups();
|
||||
const byCategory: Record<ErrorCategory, number> = {
|
||||
network: 0,
|
||||
permission: 0,
|
||||
validation: 0,
|
||||
resource: 0,
|
||||
not_found: 0,
|
||||
timeout: 0,
|
||||
syntax: 0,
|
||||
tool: 0,
|
||||
unknown: 0,
|
||||
};
|
||||
const bySeverity: Record<string, number> = {
|
||||
critical: 0,
|
||||
high: 0,
|
||||
medium: 0,
|
||||
low: 0,
|
||||
};
|
||||
|
||||
let totalErrors = 0;
|
||||
for (const group of groups) {
|
||||
byCategory[group.fingerprint.category]++;
|
||||
bySeverity[group.severity]++;
|
||||
totalErrors += group.count;
|
||||
}
|
||||
|
||||
return {
|
||||
totalGroups: groups.length,
|
||||
activeGroups: groups.filter(g => g.isActive).length,
|
||||
totalErrors,
|
||||
byCategory,
|
||||
bySeverity,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear all groups
|
||||
*/
|
||||
clear(): void {
|
||||
this.groups.clear();
|
||||
this.hashToGroup.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get number of tracked groups
|
||||
*/
|
||||
get size(): number {
|
||||
return this.groups.size;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a singleton manager instance
|
||||
*/
|
||||
let globalManager: ErrorGroupManager | undefined;
|
||||
|
||||
export function getErrorGroupManager(): ErrorGroupManager {
|
||||
if (!globalManager) {
|
||||
globalManager = new ErrorGroupManager();
|
||||
}
|
||||
return globalManager;
|
||||
}
|
||||
|
||||
export function resetErrorGroupManager(): void {
|
||||
globalManager = undefined;
|
||||
}
|
||||
|
||||
// Re-export types
|
||||
export type { ErrorFingerprint, ErrorCategory, ErrorGroup, ErrorGroupingOptions };
|
||||
53
src/store.ts
53
src/store.ts
|
|
@ -3,9 +3,11 @@
|
|||
*
|
||||
* Stores and indexes LogEvents for efficient querying.
|
||||
* Includes collision detection for concurrent file modifications.
|
||||
* Includes error grouping for smart error clustering.
|
||||
*/
|
||||
|
||||
import { LogEvent, WorkerInfo, WorkerStatus, EventFilter, EventStore, FileCollision } from './types.js';
|
||||
import { LogEvent, WorkerInfo, WorkerStatus, EventFilter, EventStore, FileCollision, ErrorGroup, ErrorCategory } from './types.js';
|
||||
import { ErrorGroupManager, getErrorGroupManager } from './errorGrouping.js';
|
||||
|
||||
/** Time window (in ms) to consider events as concurrent */
|
||||
const COLLISION_WINDOW_MS = 5000;
|
||||
|
|
@ -17,10 +19,12 @@ export class InMemoryEventStore implements EventStore {
|
|||
private events: LogEvent[] = [];
|
||||
private workers: Map<string, WorkerInfo> = new Map();
|
||||
private collisions: Map<string, FileCollision> = new Map();
|
||||
private errorGroupManager: ErrorGroupManager;
|
||||
private maxEvents: number;
|
||||
|
||||
constructor(maxEvents: number = 10000) {
|
||||
this.maxEvents = maxEvents;
|
||||
this.errorGroupManager = new ErrorGroupManager();
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -31,6 +35,11 @@ export class InMemoryEventStore implements EventStore {
|
|||
this.updateWorkerInfo(event);
|
||||
this.detectCollision(event);
|
||||
|
||||
// Track errors in error groups
|
||||
if (event.level === 'error') {
|
||||
this.errorGroupManager.addError(event);
|
||||
}
|
||||
|
||||
// Trim if over limit
|
||||
if (this.events.length > this.maxEvents) {
|
||||
this.events.shift();
|
||||
|
|
@ -93,6 +102,48 @@ export class InMemoryEventStore implements EventStore {
|
|||
this.events = [];
|
||||
this.workers.clear();
|
||||
this.collisions.clear();
|
||||
this.errorGroupManager.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all error groups
|
||||
*/
|
||||
getErrorGroups(): ErrorGroup[] {
|
||||
return this.errorGroupManager.getGroups();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get active error groups only
|
||||
*/
|
||||
getActiveErrorGroups(): ErrorGroup[] {
|
||||
return this.errorGroupManager.getActiveGroups();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get error groups for a specific worker
|
||||
*/
|
||||
getWorkerErrorGroups(workerId: string): ErrorGroup[] {
|
||||
return this.errorGroupManager.getWorkerGroups(workerId);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get error groups by category
|
||||
*/
|
||||
getErrorGroupsByCategory(category: ErrorCategory): ErrorGroup[] {
|
||||
return this.errorGroupManager.getGroupsByCategory(category);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get error group statistics
|
||||
*/
|
||||
getErrorStats(): {
|
||||
totalGroups: number;
|
||||
activeGroups: number;
|
||||
totalErrors: number;
|
||||
byCategory: Record<ErrorCategory, number>;
|
||||
bySeverity: Record<string, number>;
|
||||
} {
|
||||
return this.errorGroupManager.getStats();
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
574
src/tui/components/SessionReplay.ts
Normal file
574
src/tui/components/SessionReplay.ts
Normal file
|
|
@ -0,0 +1,574 @@
|
|||
/**
|
||||
* SessionReplay Component
|
||||
*
|
||||
* Provides session replay functionality - ability to replay worker activity
|
||||
* history chronologically with playback controls.
|
||||
*/
|
||||
|
||||
import * as blessed from 'blessed';
|
||||
import * as fs from 'fs';
|
||||
import { EventEmitter } from 'events';
|
||||
import { LogEvent, ReplaySpeed, ReplayState, EventFilter } from '../../types.js';
|
||||
import { parseLogLine } from '../../parser.js';
|
||||
import { colors, getLevelColor } from '../utils/colors.js';
|
||||
|
||||
export interface SessionReplayOptions {
|
||||
/** Parent screen */
|
||||
parent: blessed.Widgets.Screen;
|
||||
|
||||
/** Position from top */
|
||||
top: number | string;
|
||||
|
||||
/** Position from left */
|
||||
left: number | string;
|
||||
|
||||
/** Width of the panel */
|
||||
width: number | string;
|
||||
|
||||
/** Height of the panel */
|
||||
height: number | string;
|
||||
|
||||
/** Callback when event is emitted during playback */
|
||||
onEvent?: (event: LogEvent, index: number, total: number) => void;
|
||||
|
||||
/** Callback when state changes */
|
||||
onStateChange?: (state: ReplayState) => void;
|
||||
}
|
||||
|
||||
export interface ReplaySessionData {
|
||||
sourcePath: string;
|
||||
events: LogEvent[];
|
||||
startTime: number;
|
||||
endTime: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* SessionReplay handles loading and playing back historical log events
|
||||
*/
|
||||
export class SessionReplay extends EventEmitter {
|
||||
private container: blessed.Widgets.BoxElement;
|
||||
private timelineBox: blessed.Widgets.BoxElement;
|
||||
private logBox: blessed.Widgets.Log;
|
||||
private controlsBox: blessed.Widgets.BoxElement;
|
||||
private parent: blessed.Widgets.Screen;
|
||||
|
||||
private events: LogEvent[] = [];
|
||||
private filteredEvents: LogEvent[] = [];
|
||||
private currentIndex: number = 0;
|
||||
private state: ReplayState = 'idle';
|
||||
private speed: ReplaySpeed = 1;
|
||||
private filter?: EventFilter;
|
||||
private playbackTimer?: NodeJS.Timeout;
|
||||
private sourcePath: string = '';
|
||||
|
||||
private onEventCallback?: (event: LogEvent, index: number, total: number) => void;
|
||||
private onStateChangeCallback?: (state: ReplayState) => void;
|
||||
|
||||
constructor(options: SessionReplayOptions) {
|
||||
super();
|
||||
|
||||
this.parent = options.parent;
|
||||
this.onEventCallback = options.onEvent;
|
||||
this.onStateChangeCallback = options.onStateChange;
|
||||
|
||||
// Main container
|
||||
this.container = blessed.box({
|
||||
parent: options.parent,
|
||||
top: options.top,
|
||||
left: options.left,
|
||||
width: options.width,
|
||||
height: options.height,
|
||||
label: ' Session Replay ',
|
||||
border: { type: 'line' },
|
||||
style: {
|
||||
border: { fg: colors.border },
|
||||
label: { fg: colors.header },
|
||||
},
|
||||
});
|
||||
|
||||
// Timeline bar at top
|
||||
this.timelineBox = blessed.box({
|
||||
parent: this.container,
|
||||
top: 0,
|
||||
left: 0,
|
||||
right: 0,
|
||||
height: 1,
|
||||
content: this.formatTimeline(),
|
||||
style: {
|
||||
fg: colors.text,
|
||||
bg: colors.background,
|
||||
},
|
||||
});
|
||||
|
||||
// Log display area
|
||||
this.logBox = blessed.log({
|
||||
parent: this.container,
|
||||
top: 1,
|
||||
left: 0,
|
||||
right: 0,
|
||||
bottom: 2,
|
||||
scrollable: true,
|
||||
alwaysScroll: true,
|
||||
keys: true,
|
||||
vi: true,
|
||||
mouse: true,
|
||||
style: {
|
||||
fg: colors.text,
|
||||
},
|
||||
});
|
||||
|
||||
// Controls bar at bottom
|
||||
this.controlsBox = blessed.box({
|
||||
parent: this.container,
|
||||
bottom: 0,
|
||||
left: 0,
|
||||
right: 0,
|
||||
height: 2,
|
||||
content: this.formatControls(),
|
||||
style: {
|
||||
fg: colors.muted,
|
||||
},
|
||||
});
|
||||
|
||||
this.bindKeys();
|
||||
}
|
||||
|
||||
/**
|
||||
* Bind keyboard shortcuts
|
||||
*/
|
||||
private bindKeys(): void {
|
||||
this.container.key(['space'], () => this.toggle());
|
||||
this.container.key(['p'], () => this.toggle());
|
||||
this.container.key(['right'], () => this.stepForward());
|
||||
this.container.key(['left'], () => this.stepBackward());
|
||||
this.container.key(['n'], () => this.stepForward());
|
||||
this.container.key(['b'], () => this.stepBackward());
|
||||
this.container.key(['up'], () => this.increaseSpeed());
|
||||
this.container.key(['down'], () => this.decreaseSpeed());
|
||||
this.container.key(['home'], () => this.seekTo(0));
|
||||
this.container.key(['end'], () => this.seekTo(this.filteredEvents.length - 1));
|
||||
this.container.key(['r'], () => this.reset());
|
||||
this.container.key(['1'], () => this.setSpeed(0.5));
|
||||
this.container.key(['2'], () => this.setSpeed(1));
|
||||
this.container.key(['3'], () => this.setSpeed(2));
|
||||
this.container.key(['4'], () => this.setSpeed(5));
|
||||
this.container.key(['5'], () => this.setSpeed(10));
|
||||
}
|
||||
|
||||
/**
|
||||
* Load events from a log file
|
||||
*/
|
||||
loadFile(filePath: string, filter?: EventFilter): Promise<number> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const expandedPath = filePath.startsWith('~')
|
||||
? filePath.replace('~', process.env.HOME || '')
|
||||
: filePath;
|
||||
|
||||
if (!fs.existsSync(expandedPath)) {
|
||||
reject(new Error(`Log file not found: ${expandedPath}`));
|
||||
return;
|
||||
}
|
||||
|
||||
this.sourcePath = expandedPath;
|
||||
this.filter = filter;
|
||||
|
||||
const content = fs.readFileSync(expandedPath, 'utf-8');
|
||||
const lines = content.split('\n');
|
||||
|
||||
this.events = [];
|
||||
for (const line of lines) {
|
||||
if (line.trim()) {
|
||||
const event = parseLogLine(line);
|
||||
if (event) {
|
||||
this.events.push(event);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Sort by timestamp
|
||||
this.events.sort((a, b) => a.ts - b.ts);
|
||||
|
||||
// Apply filter
|
||||
this.applyFilter();
|
||||
|
||||
// Reset state
|
||||
this.currentIndex = 0;
|
||||
this.state = 'idle';
|
||||
this.updateDisplay();
|
||||
this.emit('loaded', this.events.length);
|
||||
|
||||
resolve(this.events.length);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Load events from array
|
||||
*/
|
||||
loadEvents(events: LogEvent[], filter?: EventFilter): void {
|
||||
this.events = [...events].sort((a, b) => a.ts - b.ts);
|
||||
this.filter = filter;
|
||||
this.applyFilter();
|
||||
this.currentIndex = 0;
|
||||
this.state = 'idle';
|
||||
this.updateDisplay();
|
||||
this.emit('loaded', this.events.length);
|
||||
}
|
||||
|
||||
/**
|
||||
* Apply current filter to events
|
||||
*/
|
||||
private applyFilter(): void {
|
||||
if (!this.filter) {
|
||||
this.filteredEvents = [...this.events];
|
||||
return;
|
||||
}
|
||||
|
||||
this.filteredEvents = this.events.filter(event => {
|
||||
if (this.filter!.worker && event.worker !== this.filter!.worker) return false;
|
||||
if (this.filter!.level && event.level !== this.filter!.level) return false;
|
||||
if (this.filter!.bead && event.bead !== this.filter!.bead) return false;
|
||||
if (this.filter!.path && event.path !== this.filter!.path) return false;
|
||||
if (this.filter!.since && event.ts < this.filter!.since) return false;
|
||||
if (this.filter!.until && event.ts > this.filter!.until) return false;
|
||||
return true;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Set filter and reapply
|
||||
*/
|
||||
setFilter(filter?: EventFilter): void {
|
||||
this.filter = filter;
|
||||
this.applyFilter();
|
||||
this.currentIndex = Math.min(this.currentIndex, Math.max(0, this.filteredEvents.length - 1));
|
||||
this.updateDisplay();
|
||||
}
|
||||
|
||||
/**
|
||||
* Start or resume playback
|
||||
*/
|
||||
play(): void {
|
||||
if (this.state === 'ended' || this.filteredEvents.length === 0) return;
|
||||
|
||||
this.state = 'playing';
|
||||
this.onStateChangeCallback?.(this.state);
|
||||
this.updateDisplay();
|
||||
this.scheduleNextEvent();
|
||||
}
|
||||
|
||||
/**
|
||||
* Pause playback
|
||||
*/
|
||||
pause(): void {
|
||||
if (this.state !== 'playing') return;
|
||||
|
||||
this.state = 'paused';
|
||||
this.onStateChangeCallback?.(this.state);
|
||||
this.clearTimer();
|
||||
this.updateDisplay();
|
||||
}
|
||||
|
||||
/**
|
||||
* Toggle play/pause
|
||||
*/
|
||||
toggle(): void {
|
||||
if (this.state === 'playing') {
|
||||
this.pause();
|
||||
} else {
|
||||
this.play();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Step forward one event
|
||||
*/
|
||||
stepForward(): void {
|
||||
if (this.currentIndex >= this.filteredEvents.length - 1) return;
|
||||
|
||||
this.pause();
|
||||
this.currentIndex++;
|
||||
this.displayCurrentEvent();
|
||||
this.updateDisplay();
|
||||
}
|
||||
|
||||
/**
|
||||
* Step backward one event
|
||||
*/
|
||||
stepBackward(): void {
|
||||
if (this.currentIndex <= 0) return;
|
||||
|
||||
this.pause();
|
||||
this.currentIndex--;
|
||||
this.displayCurrentEvent();
|
||||
this.updateDisplay();
|
||||
}
|
||||
|
||||
/**
|
||||
* Jump to specific index
|
||||
*/
|
||||
seekTo(index: number): void {
|
||||
const safeIndex = Math.max(0, Math.min(index, this.filteredEvents.length - 1));
|
||||
if (safeIndex === this.currentIndex) return;
|
||||
|
||||
this.pause();
|
||||
this.currentIndex = safeIndex;
|
||||
this.displayCurrentEvent();
|
||||
this.updateDisplay();
|
||||
}
|
||||
|
||||
/**
|
||||
* Seek to percentage (0-100)
|
||||
*/
|
||||
seekToPercent(percent: number): void {
|
||||
const index = Math.floor((percent / 100) * (this.filteredEvents.length - 1));
|
||||
this.seekTo(index);
|
||||
}
|
||||
|
||||
/**
|
||||
* Set playback speed
|
||||
*/
|
||||
setSpeed(speed: ReplaySpeed): void {
|
||||
this.speed = speed;
|
||||
this.updateDisplay();
|
||||
|
||||
// Reschedule if playing
|
||||
if (this.state === 'playing') {
|
||||
this.clearTimer();
|
||||
this.scheduleNextEvent();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Increase speed
|
||||
*/
|
||||
increaseSpeed(): void {
|
||||
const speeds: ReplaySpeed[] = [0.5, 1, 2, 5, 10];
|
||||
const currentIdx = speeds.indexOf(this.speed);
|
||||
if (currentIdx < speeds.length - 1) {
|
||||
this.setSpeed(speeds[currentIdx + 1]);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Decrease speed
|
||||
*/
|
||||
decreaseSpeed(): void {
|
||||
const speeds: ReplaySpeed[] = [0.5, 1, 2, 5, 10];
|
||||
const currentIdx = speeds.indexOf(this.speed);
|
||||
if (currentIdx > 0) {
|
||||
this.setSpeed(speeds[currentIdx - 1]);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset replay to beginning
|
||||
*/
|
||||
reset(): void {
|
||||
this.pause();
|
||||
this.currentIndex = 0;
|
||||
this.state = 'idle';
|
||||
this.logBox.setContent('');
|
||||
this.updateDisplay();
|
||||
this.emit('reset');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get current state
|
||||
*/
|
||||
getState(): ReplayState {
|
||||
return this.state;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get current speed
|
||||
*/
|
||||
getSpeed(): ReplaySpeed {
|
||||
return this.speed;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get progress info
|
||||
*/
|
||||
getProgress(): { current: number; total: number; percent: number } {
|
||||
const total = this.filteredEvents.length;
|
||||
const current = this.currentIndex;
|
||||
const percent = total > 0 ? Math.round((current / total) * 100) : 0;
|
||||
return { current, total, percent };
|
||||
}
|
||||
|
||||
/**
|
||||
* Get session time range
|
||||
*/
|
||||
getTimeRange(): { start: number; end: number } | null {
|
||||
if (this.filteredEvents.length === 0) return null;
|
||||
return {
|
||||
start: this.filteredEvents[0].ts,
|
||||
end: this.filteredEvents[this.filteredEvents.length - 1].ts,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Schedule next event playback
|
||||
*/
|
||||
private scheduleNextEvent(): void {
|
||||
if (this.state !== 'playing') return;
|
||||
if (this.currentIndex >= this.filteredEvents.length) {
|
||||
this.state = 'ended';
|
||||
this.onStateChangeCallback?.(this.state);
|
||||
this.updateDisplay();
|
||||
this.emit('ended');
|
||||
return;
|
||||
}
|
||||
|
||||
// Calculate delay based on time difference and speed
|
||||
let delay = 100; // Default 100ms between events
|
||||
|
||||
if (this.currentIndex > 0 && this.currentIndex < this.filteredEvents.length) {
|
||||
const prevEvent = this.filteredEvents[this.currentIndex - 1];
|
||||
const currEvent = this.filteredEvents[this.currentIndex];
|
||||
const timeDiff = currEvent.ts - prevEvent.ts;
|
||||
delay = Math.max(10, Math.min(5000, timeDiff / this.speed));
|
||||
}
|
||||
|
||||
this.playbackTimer = setTimeout(() => {
|
||||
this.displayCurrentEvent();
|
||||
this.currentIndex++;
|
||||
this.onEventCallback?.(
|
||||
this.filteredEvents[this.currentIndex - 1],
|
||||
this.currentIndex,
|
||||
this.filteredEvents.length
|
||||
);
|
||||
this.updateDisplay();
|
||||
this.scheduleNextEvent();
|
||||
}, delay);
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear playback timer
|
||||
*/
|
||||
private clearTimer(): void {
|
||||
if (this.playbackTimer) {
|
||||
clearTimeout(this.playbackTimer);
|
||||
this.playbackTimer = undefined;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Display current event
|
||||
*/
|
||||
private displayCurrentEvent(): void {
|
||||
if (this.currentIndex >= this.filteredEvents.length) return;
|
||||
|
||||
const event = this.filteredEvents[this.currentIndex];
|
||||
const formatted = this.formatEvent(event);
|
||||
this.logBox.log(formatted);
|
||||
this.emit('event', event, this.currentIndex, this.filteredEvents.length);
|
||||
}
|
||||
|
||||
/**
|
||||
* Format event for display
|
||||
*/
|
||||
private formatEvent(event: LogEvent): string {
|
||||
const time = new Date(event.ts).toLocaleTimeString();
|
||||
const levelColor = getLevelColor(event.level as 'debug' | 'info' | 'warn' | 'error');
|
||||
const workerShort = event.worker.slice(0, 8);
|
||||
|
||||
let msg = event.msg;
|
||||
if (event.tool) {
|
||||
msg = `[{cyan-fg}${event.tool}{/}] ${msg}`;
|
||||
}
|
||||
if (event.bead) {
|
||||
msg = `{blue-fg}${event.bead}{/} ${msg}`;
|
||||
}
|
||||
|
||||
return `{gray-fg}${time}{/} {bold}${workerShort}{/} {${levelColor}-fg}${event.level.toUpperCase()}{/} ${msg}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Format timeline display
|
||||
*/
|
||||
private formatTimeline(): string {
|
||||
const { current, total, percent } = this.getProgress();
|
||||
const timeRange = this.getTimeRange();
|
||||
|
||||
// Create progress bar
|
||||
const barWidth = 30;
|
||||
const filled = Math.round((percent / 100) * barWidth);
|
||||
const empty = barWidth - filled;
|
||||
const progressBar = '█'.repeat(filled) + '░'.repeat(empty);
|
||||
|
||||
let timeInfo = '';
|
||||
if (timeRange) {
|
||||
const startTime = new Date(timeRange.start).toLocaleTimeString();
|
||||
const endTime = new Date(timeRange.end).toLocaleTimeString();
|
||||
timeInfo = `${startTime} - ${endTime}`;
|
||||
}
|
||||
|
||||
const stateIcon = this.getStateIcon();
|
||||
|
||||
return ` ${stateIcon} [${progressBar}] ${percent}% (${current}/${total}) ${timeInfo}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get icon for current state
|
||||
*/
|
||||
private getStateIcon(): string {
|
||||
switch (this.state) {
|
||||
case 'playing': return '▶';
|
||||
case 'paused': return '⏸';
|
||||
case 'ended': return '⏹';
|
||||
default: return '⏵';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Format controls display
|
||||
*/
|
||||
private formatControls(): string {
|
||||
const speedDisplay = `${this.speed}x`;
|
||||
return ` Speed: ${speedDisplay} | [Space] Play/Pause | [←/→] Step | [↑/↓] Speed | [1-5] 0.5x-10x | [Home/End] Jump | [r] Reset`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Update display elements
|
||||
*/
|
||||
private updateDisplay(): void {
|
||||
this.timelineBox.setContent(this.formatTimeline());
|
||||
this.controlsBox.setContent(this.formatControls());
|
||||
this.container.setLabel(` Session Replay ${this.sourcePath ? `- ${this.sourcePath.split('/').pop()} ` : ' '}`);
|
||||
this.parent.render();
|
||||
}
|
||||
|
||||
/**
|
||||
* Focus this component
|
||||
*/
|
||||
focus(): void {
|
||||
this.container.focus();
|
||||
}
|
||||
|
||||
/**
|
||||
* Show the component
|
||||
*/
|
||||
show(): void {
|
||||
this.container.show();
|
||||
this.parent.render();
|
||||
}
|
||||
|
||||
/**
|
||||
* Hide the component
|
||||
*/
|
||||
hide(): void {
|
||||
this.container.hide();
|
||||
this.parent.render();
|
||||
}
|
||||
|
||||
/**
|
||||
* Clean up resources
|
||||
*/
|
||||
destroy(): void {
|
||||
this.clearTimer();
|
||||
this.container.destroy();
|
||||
}
|
||||
}
|
||||
|
||||
export default SessionReplay;
|
||||
|
|
@ -17,3 +17,6 @@ export type { CommandPaletteOptions, CommandSuggestion } from './CommandPalette.
|
|||
|
||||
export { DiffView, parseDiff } from './DiffView.js';
|
||||
export type { DiffViewOptions, DiffLine, DiffHunk } from './DiffView.js';
|
||||
|
||||
export { SessionReplay } from './SessionReplay.js';
|
||||
export type { SessionReplayOptions, ReplaySessionData } from './SessionReplay.js';
|
||||
|
|
|
|||
|
|
@ -9,3 +9,4 @@ export * from './utils/colors.js';
|
|||
export * from './utils/keyboard.js';
|
||||
export * from './utils/stuckDetection.js';
|
||||
export * from './utils/costTracking.js';
|
||||
export * from './components/index.js';
|
||||
|
|
|
|||
147
src/types.ts
147
src/types.ts
|
|
@ -128,3 +128,150 @@ export interface EventStore {
|
|||
/** Get collisions for a specific worker */
|
||||
getWorkerCollisions(workerId: string): FileCollision[];
|
||||
}
|
||||
|
||||
// ============================================
|
||||
// Error Grouping Types
|
||||
// ============================================
|
||||
|
||||
/**
|
||||
* Error fingerprint - used to identify similar errors
|
||||
*/
|
||||
export interface ErrorFingerprint {
|
||||
/** Normalized pattern signature (e.g., "ECONNREFUSED_*:*" for connection errors) */
|
||||
signature: string;
|
||||
|
||||
/** Category of error (network, permission, validation, etc.) */
|
||||
category: ErrorCategory;
|
||||
|
||||
/** Original error message (first occurrence) */
|
||||
sampleMessage: string;
|
||||
|
||||
/** Hash of the signature for quick comparison */
|
||||
hash: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Error categories for grouping
|
||||
*/
|
||||
export type ErrorCategory =
|
||||
| 'network' // Connection errors, timeouts, DNS issues
|
||||
| 'permission' // Auth failures, access denied
|
||||
| 'validation' // Invalid input, schema errors
|
||||
| 'resource' // Out of memory, disk full, quota exceeded
|
||||
| 'not_found' // File not found, 404 errors
|
||||
| 'timeout' // Operation timed out
|
||||
| 'syntax' // Parse errors, malformed data
|
||||
| 'tool' // Tool-specific failures
|
||||
| 'unknown'; // Uncategorized errors
|
||||
|
||||
/**
|
||||
* Grouped error - clusters similar errors together
|
||||
*/
|
||||
export interface ErrorGroup {
|
||||
/** Unique group ID */
|
||||
id: string;
|
||||
|
||||
/** Fingerprint identifying this group */
|
||||
fingerprint: ErrorFingerprint;
|
||||
|
||||
/** All error events in this group */
|
||||
events: LogEvent[];
|
||||
|
||||
/** First occurrence timestamp */
|
||||
firstSeen: number;
|
||||
|
||||
/** Most recent occurrence timestamp */
|
||||
lastSeen: number;
|
||||
|
||||
/** Number of occurrences */
|
||||
count: number;
|
||||
|
||||
/** Workers that have encountered this error */
|
||||
affectedWorkers: string[];
|
||||
|
||||
/** Whether this error group is currently active (seen recently) */
|
||||
isActive: boolean;
|
||||
|
||||
/** Severity based on frequency and recency */
|
||||
severity: 'low' | 'medium' | 'high' | 'critical';
|
||||
}
|
||||
|
||||
/**
|
||||
* Options for error grouping
|
||||
*/
|
||||
export interface ErrorGroupingOptions {
|
||||
/** Time window to consider errors as active (ms), default 5 minutes */
|
||||
activeWindowMs?: number;
|
||||
|
||||
/** Minimum occurrences for high severity */
|
||||
highSeverityThreshold?: number;
|
||||
|
||||
/** Minimum occurrences for critical severity */
|
||||
criticalSeverityThreshold?: number;
|
||||
|
||||
/** Maximum groups to track */
|
||||
maxGroups?: number;
|
||||
}
|
||||
|
||||
// ============================================
|
||||
// Session Replay Types
|
||||
// ============================================
|
||||
|
||||
export type ReplaySpeed = 0.5 | 1 | 2 | 5 | 10;
|
||||
|
||||
export type ReplayState = 'idle' | 'playing' | 'paused' | 'ended';
|
||||
|
||||
export interface ReplaySession {
|
||||
/** Unique session identifier */
|
||||
id: string;
|
||||
|
||||
/** Source log file path */
|
||||
sourcePath: string;
|
||||
|
||||
/** Total events in the session */
|
||||
totalEvents: number;
|
||||
|
||||
/** Current playback position (event index) */
|
||||
currentIndex: number;
|
||||
|
||||
/** Playback state */
|
||||
state: ReplayState;
|
||||
|
||||
/** Playback speed multiplier */
|
||||
speed: ReplaySpeed;
|
||||
|
||||
/** Start timestamp of session (first event) */
|
||||
startTime: number;
|
||||
|
||||
/** End timestamp of session (last event) */
|
||||
endTime: number;
|
||||
|
||||
/** Filter applied during replay */
|
||||
filter?: EventFilter;
|
||||
}
|
||||
|
||||
export interface ReplayControls {
|
||||
/** Start or resume playback */
|
||||
play(): void;
|
||||
|
||||
/** Pause playback */
|
||||
pause(): void;
|
||||
|
||||
/** Toggle play/pause */
|
||||
toggle(): void;
|
||||
|
||||
/** Step to next event */
|
||||
stepForward(): void;
|
||||
|
||||
/** Step to previous event */
|
||||
stepBackward(): void;
|
||||
|
||||
/** Jump to specific event index */
|
||||
seekTo(index: number): void;
|
||||
|
||||
/** Set playback speed */
|
||||
setSpeed(speed: ReplaySpeed): void;
|
||||
|
||||
/** Stop and reset replay */
|
||||
reset(): void;
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because one or more lines are too long
Loading…
Add table
Reference in a new issue