@buoy-gg/highlight-updates 7.0.36 → 7.0.38

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

@@ -1,353 +1 @@
-/**
- * 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;
+"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;