claude-git-hooks 2.18.1 → 2.20.0

package/lib/utils/telemetry.js

@@ -88,11 +88,9 @@ const getCurrentLogFile = () => {
  *
  * @returns {boolean} True if telemetry is enabled (default: true)
  */
-const isTelemetryEnabled = () => 
+const isTelemetryEnabled = () =>
     // Enabled by default - only disabled if explicitly set to false
-    config.system?.telemetry !== false
-;
-
+    config.system?.telemetry !== false;
 /**
  * Ensure telemetry directory exists
  * Why: Create on first use
@@ -115,7 +113,7 @@ const ensureTelemetryDir = async () => {
 const appendEvent = async (event) => {
     try {
         const logFile = getCurrentLogFile();
-        const line = `${JSON.stringify(event)  }\n`;
+        const line = `${JSON.stringify(event)}\n`;
 
         // Append to file (create if doesn't exist)
         await fs.appendFile(logFile, line, 'utf8');
@@ -204,6 +202,8 @@ export const recordJsonParseFailure = async (options) => {
  * @param {Object} options - Success context
  * @param {number} options.retryAttempt - Current retry attempt (0-based)
  * @param {number} options.totalRetries - Total retry attempts configured
+ * @param {string} options.batchModel - Model used for this specific batch (orchestrated mode)
+ * @param {number} options.orchestrationTime - Time spent in orchestration (ms, first batch only)
  */
 export const recordBatchSuccess = async (options) => {
     await recordEvent(
@@ -214,7 +214,9 @@ export const recordBatchSuccess = async (options) => {
             batchIndex: options.batchIndex ?? -1,
             totalBatches: options.totalBatches || 0,
             model: options.model || 'unknown',
+            batchModel: options.batchModel || options.model || 'unknown',
             duration: options.duration || 0,
+            orchestrationTime: options.orchestrationTime || 0,
             responseLength: options.responseLength || 0,
             parallelMode: (options.totalBatches || 0) > 1,
             hook: options.hook || 'unknown'
@@ -240,7 +242,7 @@ const readTelemetryEvents = async (maxDays = 7) => {
         const files = await fs.readdir(dir);
 
         // Filter to .jsonl files only
-        const logFiles = files.filter(f => f.endsWith('.jsonl'));
+        const logFiles = files.filter((f) => f.endsWith('.jsonl'));
 
         // Sort by date (newest first)
         logFiles.sort().reverse();
@@ -262,7 +264,11 @@ const readTelemetryEvents = async (maxDays = 7) => {
                         events.push(JSON.parse(line));
                     } catch (parseError) {
                         // Skip invalid lines
-                        logger.debug('telemetry - readTelemetryEvents', 'Invalid JSON line', parseError);
+                        logger.debug(
+                            'telemetry - readTelemetryEvents',
+                            'Invalid JSON line',
+                            parseError
+                        );
                     }
                 }
             }
@@ -286,7 +292,8 @@ export const getStatistics = async (maxDays = 7) => {
     if (!isTelemetryEnabled()) {
         return {
             enabled: false,
-            message: 'Telemetry is disabled. To enable (default), remove or set "system.telemetry: true" in .claude/config.json'
+            message:
+                'Telemetry is disabled. To enable (default), remove or set "system.telemetry: true" in .claude/config.json'
         };
     }
 
@@ -299,26 +306,34 @@ export const getStatistics = async (maxDays = 7) => {
             totalEvents: events.length,
             jsonParseFailures: 0,
             batchSuccesses: 0,
-            failuresByBatchSize: {},
+            failuresByFileCount: {},
             failuresByModel: {},
             failuresByHook: {},
             successesByHook: {},
             avgFilesPerFailure: 0,
             avgFilesPerSuccess: 0,
-            failureRate: 0
+            failureRate: 0,
+            avgAnalysisTimeByModel: {},
+            avgOrchestrationTime: 0
         };
 
         let totalFilesInFailures = 0;
         let totalFilesInSuccesses = 0;
 
-        events.forEach(event => {
+        // For per-model timing aggregation
+        const modelDurations = {}; // model -> [durations]
+        let totalOrchestrationTime = 0;
+        let orchestrationCount = 0;
+
+        events.forEach((event) => {
             if (event.type === 'json_parse_failure') {
                 stats.jsonParseFailures++;
                 totalFilesInFailures += event.data.fileCount || 0;
 
-                // Group by batch size
-                const batchSize = event.data.batchSize || 0;
-                stats.failuresByBatchSize[batchSize] = (stats.failuresByBatchSize[batchSize] || 0) + 1;
+                // Group by file count
+                const fileCount = event.data.fileCount || 0;
+                stats.failuresByFileCount[fileCount] =
+                    (stats.failuresByFileCount[fileCount] || 0) + 1;
 
                 // Group by model
                 const model = event.data.model || 'unknown';
@@ -327,7 +342,6 @@ export const getStatistics = async (maxDays = 7) => {
                 // Group by hook
                 const hook = event.data.hook || 'unknown';
                 stats.failuresByHook[hook] = (stats.failuresByHook[hook] || 0) + 1;
-
             } else if (event.type === 'batch_success') {
                 stats.batchSuccesses++;
                 totalFilesInSuccesses += event.data.fileCount || 0;
@@ -335,21 +349,52 @@ export const getStatistics = async (maxDays = 7) => {
                 // Group by hook
                 const hook = event.data.hook || 'unknown';
                 stats.successesByHook[hook] = (stats.successesByHook[hook] || 0) + 1;
+
+                // Accumulate per-model timing
+                const batchModel = event.data.batchModel || event.data.model || 'unknown';
+                const duration = event.data.duration || 0;
+                if (duration > 0) {
+                    if (!modelDurations[batchModel]) modelDurations[batchModel] = [];
+                    modelDurations[batchModel].push(duration);
+                }
+
+                // Accumulate orchestration time (stored on first batch only)
+                if (event.data.orchestrationTime > 0) {
+                    totalOrchestrationTime += event.data.orchestrationTime;
+                    orchestrationCount++;
+                }
             }
         });
 
         // Calculate averages
         if (stats.jsonParseFailures > 0) {
-            stats.avgFilesPerFailure = parseFloat((totalFilesInFailures / stats.jsonParseFailures).toFixed(2));
+            stats.avgFilesPerFailure = parseFloat(
+                (totalFilesInFailures / stats.jsonParseFailures).toFixed(2)
+            );
         }
         if (stats.batchSuccesses > 0) {
-            stats.avgFilesPerSuccess = parseFloat((totalFilesInSuccesses / stats.batchSuccesses).toFixed(2));
+            stats.avgFilesPerSuccess = parseFloat(
+                (totalFilesInSuccesses / stats.batchSuccesses).toFixed(2)
+            );
         }
 
         // Calculate failure rate
         const totalAnalyses = stats.jsonParseFailures + stats.batchSuccesses;
         if (totalAnalyses > 0) {
-            stats.failureRate = parseFloat((stats.jsonParseFailures / totalAnalyses * 100).toFixed(2));
+            stats.failureRate = parseFloat(
+                ((stats.jsonParseFailures / totalAnalyses) * 100).toFixed(2)
+            );
+        }
+
+        // Calculate avg analysis time per model
+        for (const [model, durations] of Object.entries(modelDurations)) {
+            const avg = durations.reduce((a, b) => a + b, 0) / durations.length;
+            stats.avgAnalysisTimeByModel[model] = Math.round(avg);
+        }
+
+        // Calculate avg orchestration time
+        if (orchestrationCount > 0) {
+            stats.avgOrchestrationTime = Math.round(totalOrchestrationTime / orchestrationCount);
         }
 
         return stats;
@@ -379,7 +424,7 @@ export const rotateTelemetry = async (maxDays = 30) => {
         const files = await fs.readdir(dir);
 
         // Filter to .jsonl files
-        const logFiles = files.filter(f => f.endsWith('.jsonl'));
+        const logFiles = files.filter((f) => f.endsWith('.jsonl'));
 
         // Calculate cutoff date
         const cutoffDate = new Date();
@@ -395,7 +440,10 @@ export const rotateTelemetry = async (maxDays = 30) => {
                 if (fileDate < cutoffStr) {
                     const filePath = path.join(dir, file);
                     await fs.unlink(filePath);
-                    logger.debug('telemetry - rotateTelemetry', `Deleted old telemetry file: ${file}`);
+                    logger.debug(
+                        'telemetry - rotateTelemetry',
+                        `Deleted old telemetry file: ${file}`
+                    );
                 }
             }
         }
@@ -420,7 +468,7 @@ export const clearTelemetry = async () => {
 
         // Delete all .jsonl files
         const files = await fs.readdir(dir);
-        const logFiles = files.filter(f => f.endsWith('.jsonl'));
+        const logFiles = files.filter((f) => f.endsWith('.jsonl'));
 
         for (const file of logFiles) {
             const filePath = path.join(dir, file);
@@ -471,11 +519,11 @@ export const displayStatistics = async () => {
     console.log(`📊 Failure rate: ${stats.failureRate}%\n`);
 
     if (stats.jsonParseFailures > 0) {
-        console.log('━━━ FAILURES BY BATCH SIZE ━━━');
-        Object.entries(stats.failuresByBatchSize)
+        console.log('━━━ FAILURES BY FILE COUNT ━━━');
+        Object.entries(stats.failuresByFileCount)
             .sort((a, b) => b[1] - a[1])
-            .forEach(([size, count]) => {
-                console.log(`  Batch size ${size}: ${count} failures`);
+            .forEach(([fileCount, count]) => {
+                console.log(`  ${fileCount} file(s): ${count} failures`);
             });
         console.log();