@buoy-gg/highlight-updates 2.1.9 → 2.1.11

package/lib/module/highlight-updates/utils/PerformanceLogger.js

@@ -1 +1,353 @@
-"use strict";let lastEventTimestamp=0,pendingBatchId=null;export function markEventReceived(){return lastEventTimestamp=performance.now(),lastEventTimestamp}export function markOverlayRendered(t,e){lastEventTimestamp>0&&t>0&&(lastEventTimestamp=0)}class PerformanceLoggerSingleton{enabled=!1;batchCounter=0;listeners=new Set;rollingStats={batchCount:0,totalNodes:0,totalFiltered:0,totalProcessed:0,totalTime:0,maxTime:0,minTime:1/0,avgMeasurementTime:0};recentBatches=[];MAX_HISTORY=100;summaryInterval=null;SUMMARY_INTERVAL_MS=1e4;setEnabled(t){const e=this.enabled;this.enabled=t,t&&!e?this.resetStats():!t&&e&&this.stopSummaryInterval()}isEnabled(){return this.enabled}startBatch(t,e){const a="batch_"+ ++this.batchCounter,n=performance.now();let r,i=null,s=null,o=null,l=null,m=null,c=0,h=0,d=0,g=0;return{markFilteringComplete:(t,e)=>{i=performance.now(),c=t,h=e},markMeasurementStart:()=>{s=performance.now()},markMeasurementComplete:(t,e)=>{o=performance.now(),d=t,g=e},markTrackingComplete:()=>{l=performance.now()},markCallbackComplete:()=>{m=performance.now()},setOverlayRenderTime:t=>{r=t},getBatchId:()=>a,finish:()=>{const u=performance.now(),T={batchId:a,timestamp:Date.now(),nodesReceived:t,nodesFiltered:c,nodesToProcess:h,batchSize:e,nodesInBatch:Math.min(h,e),filteringTime:i?i-n:0,measurementTime:s&&o?o-s:0,trackingTime:o&&l?l-o:0,callbackTime:l&&m?m-l:0,totalTime:u-n,measurementSuccessCount:d,measurementFailCount:g,overlayRenderTime:r};return this.enabled&&this.recordMetrics(T),T}}}recordMetrics(t){this.rollingStats.batchCount++,this.rollingStats.totalNodes+=t.nodesReceived,this.rollingStats.totalFiltered+=t.nodesFiltered,this.rollingStats.totalProcessed+=t.nodesInBatch,this.rollingStats.totalTime+=t.totalTime,this.rollingStats.maxTime=Math.max(this.rollingStats.maxTime,t.totalTime),this.rollingStats.minTime=Math.min(this.rollingStats.minTime,t.totalTime);const e=this.rollingStats.avgMeasurementTime,a=this.rollingStats.batchCount;this.rollingStats.avgMeasurementTime=e+(t.measurementTime-e)/a,this.recentBatches.push(t),this.recentBatches.length>this.MAX_HISTORY&&this.recentBatches.shift(),this.notifyListeners(t)}logBatch(t){const{batchId:e,nodesReceived:a,nodesFiltered:n,nodesInBatch:r,batchSize:i,filteringTime:s,measurementTime:o,trackingTime:l,callbackTime:m,totalTime:c,measurementSuccessCount:h,measurementFailCount:d,overlayRenderTime:g}=t;console.log(`[HighlightPerf] ${e} | In:${a} Filt:${n} Proc:${r}/${i} | Filter:${s.toFixed(1)}ms Measure:${o.toFixed(1)}ms Track:${l.toFixed(1)}ms Callback:${m.toFixed(1)}ms | Total:${c.toFixed(1)}ms`+(g?` Render:${g.toFixed(1)}ms`:"")+` | Success:${h} Fail:${d}`),c>100&&console.warn(`[HighlightPerf] ⚠️ SLOW BATCH: ${c.toFixed(1)}ms - Measurement phase: ${o.toFixed(1)}ms (${(o/c*100).toFixed(0)}%)`)}logSummary(){if(0===this.rollingStats.batchCount)return;const t=this.rollingStats,e=t.totalTime/t.batchCount,a=t.totalNodes/t.batchCount;console.log(`\n[HighlightPerf] ════════ SUMMARY (last ${this.SUMMARY_INTERVAL_MS/1e3}s) ════════\n  Batches: ${t.batchCount}\n  Avg nodes/batch: ${a.toFixed(1)} (filtered: ${(t.totalFiltered/t.batchCount).toFixed(1)})\n  Avg total time: ${e.toFixed(1)}ms\n  Avg measurement time: ${t.avgMeasurementTime.toFixed(1)}ms\n  Min/Max time: ${t.minTime.toFixed(1)}ms / ${t.maxTime.toFixed(1)}ms\n══════════════════════════════════════════════\n`),this.resetStats()}resetStats(){this.rollingStats={batchCount:0,totalNodes:0,totalFiltered:0,totalProcessed:0,totalTime:0,maxTime:0,minTime:1/0,avgMeasurementTime:0}}startSummaryInterval(){this.stopSummaryInterval(),this.summaryInterval=setInterval(()=>{this.logSummary()},this.SUMMARY_INTERVAL_MS)}stopSummaryInterval(){this.summaryInterval&&(clearInterval(this.summaryInterval),this.summaryInterval=null)}subscribe(t){return this.listeners.add(t),()=>{this.listeners.delete(t)}}notifyListeners(t){for(const e of this.listeners)try{e(t)}catch(t){console.error("[HighlightPerf] Error in metrics listener:",t)}}getRecentBatches(){return[...this.recentBatches]}getRollingStats(){return{...this.rollingStats}}clear(){this.recentBatches=[],this.resetStats(),this.batchCounter=0}generateReport(){const t=this.recentBatches;if(0===t.length)return"No performance data collected yet.";const e=t.reduce((t,e)=>t+e.totalTime,0)/t.length,a=t.reduce((t,e)=>t+e.measurementTime,0)/t.length,n=t.filter(t=>t.totalTime>100),r=t.filter(t=>t.totalTime<20);return`\n╔══════════════════════════════════════════════════════════════╗\n║              HIGHLIGHT UPDATES PERFORMANCE REPORT            ║\n╠══════════════════════════════════════════════════════════════╣\n║ Total batches analyzed: ${t.length.toString().padStart(5)}                              ║\n║ Average total time:     ${e.toFixed(1).padStart(5)}ms                             ║\n║ Average measure time:   ${a.toFixed(1).padStart(5)}ms (${(a/e*100).toFixed(0)}% of total)           ║\n╠══════════════════════════════════════════════════════════════╣\n║ Fast batches (<20ms):   ${r.length.toString().padStart(5)} (${(r.length/t.length*100).toFixed(0)}%)                          ║\n║ Slow batches (>100ms):  ${n.length.toString().padStart(5)} (${(n.length/t.length*100).toFixed(0)}%)                          ║\n╠══════════════════════════════════════════════════════════════╣\n║ Time breakdown (avg):                                        ║\n║   Filtering:    ${t.reduce((t,e)=>t+e.filteringTime,0/t.length).toFixed(1).padStart(6)}ms                                    ║\n║   Measurement:  ${a.toFixed(1).padStart(6)}ms  ← Primary bottleneck              ║\n║   Tracking:     ${(t.reduce((t,e)=>t+e.trackingTime,0)/t.length).toFixed(1).padStart(6)}ms                                    ║\n║   Callback:     ${(t.reduce((t,e)=>t+e.callbackTime,0)/t.length).toFixed(1).padStart(6)}ms                                    ║\n╚══════════════════════════════════════════════════════════════╝\n`}}export const PerformanceLogger=new PerformanceLoggerSingleton;export default PerformanceLogger;
+/**
+ * PerformanceLogger
+ *
+ * Dedicated performance measurement utility for the Highlight Updates feature.
+ * Tracks timing metrics across the render detection pipeline to identify bottlenecks
+ * and measure optimization improvements.
+ *
+ * Usage:
+ *   PerformanceLogger.setEnabled(true);  // Enable logging
+ *   const batch = PerformanceLogger.startBatch(nodesReceived);
+ *   batch.markFilteringComplete(nodesFiltered, nodesToProcess);
+ *   batch.markMeasurementComplete(successCount, failCount);
+ *   batch.markTrackingComplete();
+ *   batch.markCallbackComplete();
+ *   batch.finish();  // Logs the complete metrics
+ */
+
+"use strict";
+
+// Declare performance API available in React Native's JavaScript environment
+// Track the last event timestamp to measure end-to-end latency
+let lastEventTimestamp = 0;
+let pendingBatchId = null;
+
+/**
+ * Call this when a traceUpdates event is received to track end-to-end latency
+ */
+export function markEventReceived() {
+  lastEventTimestamp = performance.now();
+  return lastEventTimestamp;
+}
+
+/**
+ * Call this from the overlay when highlights are actually rendered
+ */
+export function markOverlayRendered(highlightCount, renderTime) {
+  if (lastEventTimestamp > 0 && highlightCount > 0) {
+    // Reset to avoid double-counting (end-to-end logging removed - silent by default)
+    lastEventTimestamp = 0;
+  }
+}
+
+// Rolling statistics for summary logging
+
+class PerformanceLoggerSingleton {
+  enabled = false;
+  batchCounter = 0;
+  listeners = new Set();
+
+  // Rolling stats for periodic summaries
+  rollingStats = {
+    batchCount: 0,
+    totalNodes: 0,
+    totalFiltered: 0,
+    totalProcessed: 0,
+    totalTime: 0,
+    maxTime: 0,
+    minTime: Infinity,
+    avgMeasurementTime: 0
+  };
+
+  // Recent batch history for analysis
+  recentBatches = [];
+  MAX_HISTORY = 100;
+
+  // Summary logging interval
+  summaryInterval = null;
+  SUMMARY_INTERVAL_MS = 10000; // Log summary every 10s
+
+  /**
+   * Enable or disable performance logging
+   */
+  setEnabled(enabled) {
+    const wasEnabled = this.enabled;
+    this.enabled = enabled;
+    if (enabled && !wasEnabled) {
+      this.resetStats();
+      // Summary interval removed - no periodic logging
+    } else if (!enabled && wasEnabled) {
+      this.stopSummaryInterval();
+    }
+    // Silent enable/disable - no console logs
+  }
+
+  /**
+   * Check if logging is enabled
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+
+  /**
+   * Start timing a new batch of render updates
+   */
+  startBatch(nodesReceived, batchSize) {
+    const batchId = `batch_${++this.batchCounter}`;
+    const startTime = performance.now();
+    let filteringEndTime = null;
+    let measurementStartTime = null;
+    let measurementEndTime = null;
+    let trackingEndTime = null;
+    let callbackEndTime = null;
+    let nodesFiltered = 0;
+    let nodesToProcess = 0;
+    let measurementSuccessCount = 0;
+    let measurementFailCount = 0;
+    let overlayRenderTime;
+    const timer = {
+      markFilteringComplete: (filtered, toProcess) => {
+        filteringEndTime = performance.now();
+        nodesFiltered = filtered;
+        nodesToProcess = toProcess;
+      },
+      markMeasurementStart: () => {
+        measurementStartTime = performance.now();
+      },
+      markMeasurementComplete: (success, fail) => {
+        measurementEndTime = performance.now();
+        measurementSuccessCount = success;
+        measurementFailCount = fail;
+      },
+      markTrackingComplete: () => {
+        trackingEndTime = performance.now();
+      },
+      markCallbackComplete: () => {
+        callbackEndTime = performance.now();
+      },
+      setOverlayRenderTime: timeMs => {
+        overlayRenderTime = timeMs;
+      },
+      getBatchId: () => batchId,
+      finish: () => {
+        const endTime = performance.now();
+        const metrics = {
+          batchId,
+          timestamp: Date.now(),
+          nodesReceived,
+          nodesFiltered,
+          nodesToProcess,
+          batchSize,
+          nodesInBatch: Math.min(nodesToProcess, batchSize),
+          filteringTime: filteringEndTime ? filteringEndTime - startTime : 0,
+          measurementTime: measurementStartTime && measurementEndTime ? measurementEndTime - measurementStartTime : 0,
+          trackingTime: measurementEndTime && trackingEndTime ? trackingEndTime - measurementEndTime : 0,
+          callbackTime: trackingEndTime && callbackEndTime ? callbackEndTime - trackingEndTime : 0,
+          totalTime: endTime - startTime,
+          measurementSuccessCount,
+          measurementFailCount,
+          overlayRenderTime
+        };
+        if (this.enabled) {
+          this.recordMetrics(metrics);
+        }
+        return metrics;
+      }
+    };
+    return timer;
+  }
+
+  /**
+   * Record metrics and log them
+   */
+  recordMetrics(metrics) {
+    // Update rolling stats
+    this.rollingStats.batchCount++;
+    this.rollingStats.totalNodes += metrics.nodesReceived;
+    this.rollingStats.totalFiltered += metrics.nodesFiltered;
+    this.rollingStats.totalProcessed += metrics.nodesInBatch;
+    this.rollingStats.totalTime += metrics.totalTime;
+    this.rollingStats.maxTime = Math.max(this.rollingStats.maxTime, metrics.totalTime);
+    this.rollingStats.minTime = Math.min(this.rollingStats.minTime, metrics.totalTime);
+
+    // Update rolling average for measurement time
+    const prevAvg = this.rollingStats.avgMeasurementTime;
+    const n = this.rollingStats.batchCount;
+    this.rollingStats.avgMeasurementTime = prevAvg + (metrics.measurementTime - prevAvg) / n;
+
+    // Store in history
+    this.recentBatches.push(metrics);
+    if (this.recentBatches.length > this.MAX_HISTORY) {
+      this.recentBatches.shift();
+    }
+
+    // Notify listeners
+    this.notifyListeners(metrics);
+  }
+
+  /**
+   * Log a single batch's metrics
+   */
+  logBatch(metrics) {
+    const {
+      batchId,
+      nodesReceived,
+      nodesFiltered,
+      nodesInBatch,
+      batchSize,
+      filteringTime,
+      measurementTime,
+      trackingTime,
+      callbackTime,
+      totalTime,
+      measurementSuccessCount,
+      measurementFailCount,
+      overlayRenderTime
+    } = metrics;
+
+    // Compact single-line log for quick scanning
+    console.log(`[HighlightPerf] ${batchId} | ` + `In:${nodesReceived} Filt:${nodesFiltered} Proc:${nodesInBatch}/${batchSize} | ` + `Filter:${filteringTime.toFixed(1)}ms Measure:${measurementTime.toFixed(1)}ms ` + `Track:${trackingTime.toFixed(1)}ms Callback:${callbackTime.toFixed(1)}ms | ` + `Total:${totalTime.toFixed(1)}ms` + (overlayRenderTime ? ` Render:${overlayRenderTime.toFixed(1)}ms` : "") + ` | Success:${measurementSuccessCount} Fail:${measurementFailCount}`);
+
+    // Flag slow batches
+    if (totalTime > 100) {
+      console.warn(`[HighlightPerf] ⚠️ SLOW BATCH: ${totalTime.toFixed(1)}ms - ` + `Measurement phase: ${measurementTime.toFixed(1)}ms (${(measurementTime / totalTime * 100).toFixed(0)}%)`);
+    }
+  }
+
+  /**
+   * Log periodic summary stats
+   */
+  logSummary() {
+    if (this.rollingStats.batchCount === 0) return;
+    const stats = this.rollingStats;
+    const avgTime = stats.totalTime / stats.batchCount;
+    const avgNodes = stats.totalNodes / stats.batchCount;
+    console.log(`\n[HighlightPerf] ════════ SUMMARY (last ${this.SUMMARY_INTERVAL_MS / 1000}s) ════════\n` + `  Batches: ${stats.batchCount}\n` + `  Avg nodes/batch: ${avgNodes.toFixed(1)} (filtered: ${(stats.totalFiltered / stats.batchCount).toFixed(1)})\n` + `  Avg total time: ${avgTime.toFixed(1)}ms\n` + `  Avg measurement time: ${stats.avgMeasurementTime.toFixed(1)}ms\n` + `  Min/Max time: ${stats.minTime.toFixed(1)}ms / ${stats.maxTime.toFixed(1)}ms\n` + `══════════════════════════════════════════════\n`);
+
+    // Reset rolling stats for next interval
+    this.resetStats();
+  }
+
+  /**
+   * Reset rolling statistics
+   */
+  resetStats() {
+    this.rollingStats = {
+      batchCount: 0,
+      totalNodes: 0,
+      totalFiltered: 0,
+      totalProcessed: 0,
+      totalTime: 0,
+      maxTime: 0,
+      minTime: Infinity,
+      avgMeasurementTime: 0
+    };
+  }
+
+  /**
+   * Start the summary logging interval
+   */
+  startSummaryInterval() {
+    this.stopSummaryInterval();
+    this.summaryInterval = setInterval(() => {
+      this.logSummary();
+    }, this.SUMMARY_INTERVAL_MS);
+  }
+
+  /**
+   * Stop the summary logging interval
+   */
+  stopSummaryInterval() {
+    if (this.summaryInterval) {
+      clearInterval(this.summaryInterval);
+      this.summaryInterval = null;
+    }
+  }
+
+  /**
+   * Subscribe to metrics updates
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  /**
+   * Notify all listeners of new metrics
+   */
+  notifyListeners(metrics) {
+    for (const listener of this.listeners) {
+      try {
+        listener(metrics);
+      } catch (error) {
+        console.error("[HighlightPerf] Error in metrics listener:", error);
+      }
+    }
+  }
+
+  /**
+   * Get recent batch history
+   */
+  getRecentBatches() {
+    return [...this.recentBatches];
+  }
+
+  /**
+   * Get current rolling stats
+   */
+  getRollingStats() {
+    return {
+      ...this.rollingStats
+    };
+  }
+
+  /**
+   * Clear all history and stats
+   */
+  clear() {
+    this.recentBatches = [];
+    this.resetStats();
+    this.batchCounter = 0;
+  }
+
+  /**
+   * Generate a detailed report of recent performance
+   */
+  generateReport() {
+    const batches = this.recentBatches;
+    if (batches.length === 0) {
+      return "No performance data collected yet.";
+    }
+    const totalTime = batches.reduce((sum, b) => sum + b.totalTime, 0);
+    const avgTime = totalTime / batches.length;
+    const totalMeasureTime = batches.reduce((sum, b) => sum + b.measurementTime, 0);
+    const avgMeasureTime = totalMeasureTime / batches.length;
+    const slowBatches = batches.filter(b => b.totalTime > 100);
+    const fastBatches = batches.filter(b => b.totalTime < 20);
+    const report = `
+╔══════════════════════════════════════════════════════════════╗
+║              HIGHLIGHT UPDATES PERFORMANCE REPORT            ║
+╠══════════════════════════════════════════════════════════════╣
+║ Total batches analyzed: ${batches.length.toString().padStart(5)}                              ║
+║ Average total time:     ${avgTime.toFixed(1).padStart(5)}ms                             ║
+║ Average measure time:   ${avgMeasureTime.toFixed(1).padStart(5)}ms (${(avgMeasureTime / avgTime * 100).toFixed(0)}% of total)           ║
+╠══════════════════════════════════════════════════════════════╣
+║ Fast batches (<20ms):   ${fastBatches.length.toString().padStart(5)} (${(fastBatches.length / batches.length * 100).toFixed(0)}%)                          ║
+║ Slow batches (>100ms):  ${slowBatches.length.toString().padStart(5)} (${(slowBatches.length / batches.length * 100).toFixed(0)}%)                          ║
+╠══════════════════════════════════════════════════════════════╣
+║ Time breakdown (avg):                                        ║
+║   Filtering:    ${batches.reduce((s, b) => s + b.filteringTime, 0 / batches.length).toFixed(1).padStart(6)}ms                                    ║
+║   Measurement:  ${avgMeasureTime.toFixed(1).padStart(6)}ms  ← Primary bottleneck              ║
+║   Tracking:     ${(batches.reduce((s, b) => s + b.trackingTime, 0) / batches.length).toFixed(1).padStart(6)}ms                                    ║
+║   Callback:     ${(batches.reduce((s, b) => s + b.callbackTime, 0) / batches.length).toFixed(1).padStart(6)}ms                                    ║
+╚══════════════════════════════════════════════════════════════╝
+`;
+    return report;
+  }
+}
+
+// Export singleton instance
+export const PerformanceLogger = new PerformanceLoggerSingleton();
+export default PerformanceLogger;