fix: aggregate file processing errors in telemetry to reduce volume

- Replace individual error telemetry events with aggregated reporting
- Collect errors during batch processing and send single consolidated event
- Include error count, type breakdown, and sanitized examples
- Add comprehensive tests for error aggregation behavior

Author: daniel-lxs

src/services/code-index/processors/__tests__/file-watcher.spec.ts

@@ -3,6 +3,8 @@
 import * as vscode from "vscode"
 
 import { FileWatcher } from "../file-watcher"
+import { TelemetryService } from "@roo-code/telemetry"
+import { TelemetryEventName } from "@roo-code/types"
 
 // Mock TelemetryService
 vi.mock("../../../../../packages/telemetry/src/TelemetryService", () => ({
@@ -17,6 +19,14 @@ vi.mock("../../../../../packages/telemetry/src/TelemetryService", () => ({
 vi.mock("../../cache-manager")
 vi.mock("../../../core/ignore/RooIgnoreController")
 vi.mock("ignore")
+vi.mock("../parser", () => ({
+	codeParser: {
+		parseFile: vi.fn().mockResolvedValue([]),
+	},
+}))
+vi.mock("../../../glob/ignore-utils", () => ({
+	isPathInIgnoredDirectory: vi.fn().mockReturnValue(false),
+}))
 
 // Mock vscode module
 vi.mock("vscode", () => ({
@@ -29,6 +39,10 @@ vi.mock("vscode", () => ({
 				},
 			},
 		],
+		fs: {
+			stat: vi.fn().mockResolvedValue({ size: 1000 }),
+			readFile: vi.fn().mockResolvedValue(Buffer.from("test content")),
+		},
 	},
 	RelativePattern: vi.fn().mockImplementation((base, pattern) => ({ base, pattern })),
 	Uri: {
@@ -101,6 +115,7 @@ describe("FileWatcher", () => {
 		mockVectorStore = {
 			upsertPoints: vi.fn().mockResolvedValue(undefined),
 			deletePointsByFilePath: vi.fn().mockResolvedValue(undefined),
+			deletePointsByMultipleFilePaths: vi.fn().mockResolvedValue(undefined),
 		}
 
 		mockIgnoreInstance = {
@@ -268,4 +283,196 @@ describe("FileWatcher", () => {
 			expect(mockWatcher.dispose).toHaveBeenCalled()
 		})
 	})
+
+	describe("error aggregation", () => {
+		beforeEach(() => {
+			// Reset telemetry mock
+			vi.mocked(TelemetryService.instance.captureEvent).mockClear()
+		})
+
+		it("should aggregate file processing errors and send a single telemetry event", async () => {
+			// Initialize the file watcher
+			await fileWatcher.initialize()
+
+			// Mock processFile to throw errors for some files
+			const processFileSpy = vi.spyOn(fileWatcher, "processFile")
+			processFileSpy
+				.mockRejectedValueOnce(new Error("File read error"))
+				.mockRejectedValueOnce(new Error("Parse error"))
+				.mockResolvedValueOnce({ path: "/mock/workspace/file3.ts", status: "skipped", reason: "Too large" })
+
+			// Trigger file creation events
+			await mockOnDidCreate({ fsPath: "/mock/workspace/file1.ts" })
+			await mockOnDidCreate({ fsPath: "/mock/workspace/file2.ts" })
+			await mockOnDidCreate({ fsPath: "/mock/workspace/file3.ts" })
+
+			// Wait for batch processing
+			await new Promise((resolve) => setTimeout(resolve, 600))
+
+			// Verify that only one aggregated telemetry event was sent
+			const telemetryCalls = vi.mocked(TelemetryService.instance.captureEvent).mock.calls
+			const codeIndexErrorCalls = telemetryCalls.filter((call) => call[0] === TelemetryEventName.CODE_INDEX_ERROR)
+
+			// Should have exactly one aggregated error event
+			expect(codeIndexErrorCalls).toHaveLength(1)
+
+			const aggregatedEvent = codeIndexErrorCalls[0][1]
+			expect(aggregatedEvent).toMatchObject({
+				error: expect.stringContaining("Batch processing completed with 2 errors"),
+				errorCount: 2,
+				errorTypes: expect.objectContaining({
+					Error: 2,
+				}),
+				sampleErrors: expect.arrayContaining([
+					expect.objectContaining({
+						path: expect.any(String),
+						error: expect.any(String),
+						location: "_processFilesAndPrepareUpserts",
+					}),
+				]),
+				location: "processBatch_aggregated",
+			})
+		})
+
+		it("should not send telemetry event when no errors occur", async () => {
+			// Initialize the file watcher
+			await fileWatcher.initialize()
+
+			// Mock processFile to succeed for all files
+			const processFileSpy = vi.spyOn(fileWatcher, "processFile")
+			processFileSpy.mockResolvedValue({
+				path: "/mock/workspace/file.ts",
+				status: "processed_for_batching",
+				pointsToUpsert: [],
+			})
+
+			// Trigger file creation events
+			await mockOnDidCreate({ fsPath: "/mock/workspace/file1.ts" })
+			await mockOnDidCreate({ fsPath: "/mock/workspace/file2.ts" })
+
+			// Wait for batch processing
+			await new Promise((resolve) => setTimeout(resolve, 600))
+
+			// Verify no telemetry events were sent
+			const telemetryCalls = vi.mocked(TelemetryService.instance.captureEvent).mock.calls
+			const codeIndexErrorCalls = telemetryCalls.filter((call) => call[0] === TelemetryEventName.CODE_INDEX_ERROR)
+
+			expect(codeIndexErrorCalls).toHaveLength(0)
+		})
+
+		it("should include deletion errors in aggregated telemetry", async () => {
+			// Initialize the file watcher
+			await fileWatcher.initialize()
+
+			// Mock vector store to fail on deletion
+			mockVectorStore.deletePointsByMultipleFilePaths.mockRejectedValueOnce(
+				new Error("Database connection error"),
+			)
+
+			// Trigger file deletion events
+			await mockOnDidDelete({ fsPath: "/mock/workspace/file1.ts" })
+			await mockOnDidDelete({ fsPath: "/mock/workspace/file2.ts" })
+
+			// Wait for batch processing
+			await new Promise((resolve) => setTimeout(resolve, 600))
+
+			// Verify aggregated telemetry event includes deletion errors
+			const telemetryCalls = vi.mocked(TelemetryService.instance.captureEvent).mock.calls
+			const codeIndexErrorCalls = telemetryCalls.filter((call) => call[0] === TelemetryEventName.CODE_INDEX_ERROR)
+
+			expect(codeIndexErrorCalls).toHaveLength(1)
+
+			const aggregatedEvent = codeIndexErrorCalls[0][1]
+			expect(aggregatedEvent).toMatchObject({
+				error: expect.stringContaining("Batch processing completed with 2 errors"),
+				errorCount: 2,
+				sampleErrors: expect.arrayContaining([
+					expect.objectContaining({
+						location: "_handleBatchDeletions",
+					}),
+				]),
+			})
+		})
+
+		it("should include upsert errors in aggregated telemetry", async () => {
+			// Initialize the file watcher
+			await fileWatcher.initialize()
+
+			// Spy on processFile to make it return points for upserting
+			const processFileSpy = vi.spyOn(fileWatcher, "processFile")
+			processFileSpy.mockResolvedValue({
+				path: "/mock/workspace/file.ts",
+				status: "processed_for_batching",
+				newHash: "abc123",
+				pointsToUpsert: [
+					{
+						id: "test-id",
+						vector: [0.1, 0.2, 0.3],
+						payload: {
+							filePath: "file.ts",
+							codeChunk: "test code",
+							startLine: 1,
+							endLine: 10,
+						},
+					},
+				],
+			})
+
+			// Mock vector store to fail on upsert
+			mockVectorStore.upsertPoints.mockRejectedValue(new Error("Vector dimension mismatch"))
+
+			// Trigger file creation event
+			await mockOnDidCreate({ fsPath: "/mock/workspace/file.ts" })
+
+			// Wait for batch processing
+			await new Promise((resolve) => setTimeout(resolve, 700))
+
+			// Verify aggregated telemetry event includes upsert errors
+			const telemetryCalls = vi.mocked(TelemetryService.instance.captureEvent).mock.calls
+			const codeIndexErrorCalls = telemetryCalls.filter((call) => call[0] === TelemetryEventName.CODE_INDEX_ERROR)
+
+			expect(codeIndexErrorCalls).toHaveLength(1)
+
+			const aggregatedEvent = codeIndexErrorCalls[0][1]
+			expect(aggregatedEvent).toMatchObject({
+				error: expect.stringContaining("Batch processing completed with 1 errors"),
+				errorCount: 1,
+				sampleErrors: expect.arrayContaining([
+					expect.objectContaining({
+						location: "_executeBatchUpsertOperations",
+					}),
+				]),
+			})
+		})
+
+		it("should limit sample errors to 3 in telemetry", async () => {
+			// Initialize the file watcher
+			await fileWatcher.initialize()
+
+			// Mock processFile to throw different errors
+			const processFileSpy = vi.spyOn(fileWatcher, "processFile")
+			for (let i = 0; i < 10; i++) {
+				processFileSpy.mockRejectedValueOnce(new Error(`Error ${i + 1}`))
+			}
+
+			// Trigger many file creation events
+			for (let i = 0; i < 10; i++) {
+				await mockOnDidCreate({ fsPath: `/mock/workspace/file${i + 1}.ts` })
+			}
+
+			// Wait for batch processing
+			await new Promise((resolve) => setTimeout(resolve, 600))
+
+			// Verify telemetry event has limited sample errors
+			const telemetryCalls = vi.mocked(TelemetryService.instance.captureEvent).mock.calls
+			const codeIndexErrorCalls = telemetryCalls.filter((call) => call[0] === TelemetryEventName.CODE_INDEX_ERROR)
+
+			expect(codeIndexErrorCalls).toHaveLength(1)
+
+			const aggregatedEvent = codeIndexErrorCalls[0][1]
+			expect(aggregatedEvent).toBeDefined()
+			expect(aggregatedEvent!.errorCount).toBe(10)
+			expect(aggregatedEvent!.sampleErrors).toHaveLength(3) // Limited to 3 samples
+		})
+	})
 })