@dynamicu/chromedebug-mcp 2.6.7 → 2.7.1

package/chrome-extension/pro/function-tracker.js

@@ -0,0 +1,843 @@
+// Function Tracker for Chrome Debug Full Data Recording
+// Wraps JavaScript functions to track execution flow and variable states
+
+// Constants for batching and flushing
+const DEFAULT_BATCH_SIZE = 100;
+const FLUSH_INTERVAL_MS = 5000;
+
+class FunctionTracker {
+  constructor(performanceMonitor, piiRedactor, onDataReady) {
+    this.isTracking = false;
+    this.trackedFunctions = new Map(); // Original function references
+    this.executionBuffer = [];
+    this.bufferFlushDelay = 3000; // Flush every 3 seconds
+    this.flushTimer = null;
+    this.recordingId = null;
+    this.callStack = []; // Track call hierarchy
+    
+    // Configuration - LIGHTWEIGHT MODE BY DEFAULT
+    this.maxCallDepth = 5; // Reduced from 10
+    this.maxArgumentSize = 50; // DRASTICALLY reduced from 1024 - just capture basic info
+    this.trackReturnValues = false; // DON'T track return values
+    this.trackExecutionTime = true;
+    this.trackCallStack = false; // DON'T track full call stacks
+    this.lightweightMode = true; // NEW: Enable lightweight mode
+    this.batchSize = DEFAULT_BATCH_SIZE;
+    
+    // Sensitive data patterns to redact
+    this.sensitivePatterns = [
+      'password', 'passwd', 'pwd',
+      'token', 'apikey', 'api_key', 'apiKey',
+      'secret', 'private', 'credential',
+      'authorization', 'auth',
+      'ssn', 'social_security',
+      'credit_card', 'creditcard', 'cc_number',
+      'cvv', 'cvc',
+      'pin', 'passcode'
+    ];
+    
+    // Callbacks and dependencies
+    this.onDataReady = onDataReady || null;
+    this.piiRedactor = piiRedactor || null;
+    this.performanceMonitor = performanceMonitor || null;
+    
+    // Create bound flush method for event listeners
+    this.boundFlush = this.flush.bind(this);
+    this.flushInterval = null;
+    
+    // Function categories to wrap
+    this.targetCategories = {
+      userDefined: true,      // User-defined functions
+      eventHandlers: true,    // Event handlers
+      asyncFunctions: true,   // Promises, async/await
+      domMethods: false,      // DOM manipulation (too noisy by default)
+      nativeAPIs: false      // Native browser APIs (very noisy)
+    };
+    
+    // Patterns for function identification
+    this.wrappingPatterns = {
+      // User-defined functions (detected by scope)
+      userFunctions: [],
+      
+      // Event handling
+      eventMethods: [
+        'addEventListener',
+        'removeEventListener',
+        'onclick',
+        'onload',
+        'onchange',
+        'onsubmit'
+      ],
+      
+      // Async patterns
+      asyncMethods: [
+        'fetch',
+        'setTimeout',
+        'setInterval',
+        'requestAnimationFrame'
+      ],
+      
+      // DOM methods (optional)
+      domMethods: [
+        'querySelector',
+        'getElementById',
+        'createElement',
+        'appendChild',
+        'removeChild'
+      ]
+    };
+  }
+
+  init(options = {}) {
+    this.recordingId = options.recordingId || 'default';
+    this.onDataReady = options.onDataReady;
+    this.piiRedactor = options.piiRedactor;
+    this.performanceMonitor = options.performanceMonitor;
+    
+    // Override settings
+    if (options.maxCallDepth) this.maxCallDepth = options.maxCallDepth;
+    if (options.trackReturnValues !== undefined) this.trackReturnValues = options.trackReturnValues;
+    if (options.trackExecutionTime !== undefined) this.trackExecutionTime = options.trackExecutionTime;
+    if (options.bufferFlushDelay) this.bufferFlushDelay = options.bufferFlushDelay;
+    
+    // Update target categories
+    if (options.targetCategories) {
+      this.targetCategories = { ...this.targetCategories, ...options.targetCategories };
+    }
+    
+    // console.log('[FunctionTracker] Initialized with options:', {
+    //   recordingId: this.recordingId,
+    //   maxCallDepth: this.maxCallDepth,
+    //   trackReturnValues: this.trackReturnValues,
+    //   targetCategories: this.targetCategories
+    // });
+  }
+
+  startTracking() {
+    if (this.isTracking) {
+      console.warn('[FunctionTracker] Already tracking function calls');
+      return;
+    }
+
+    try {
+      // Wrap different categories of functions
+      if (this.targetCategories.eventHandlers) {
+        this.wrapEventHandlers();
+      }
+      
+      if (this.targetCategories.asyncFunctions) {
+        this.wrapAsyncFunctions();
+      }
+      
+      if (this.targetCategories.domMethods) {
+        this.wrapDOMMethods();
+      }
+      
+      if (this.targetCategories.userDefined) {
+        this.discoverAndWrapUserFunctions();
+      }
+      
+      this.isTracking = true;
+      this.startBufferFlusher();
+      
+      // Set up periodic flushing
+      this.flushInterval = setInterval(() => {
+        if (this.executionBuffer.length > 0) {
+          this.flush();
+        }
+      }, FLUSH_INTERVAL_MS);
+      
+      // Set up pagehide listener for final flush
+      window.addEventListener('pagehide', this.boundFlush);
+      
+      // console.log('[FunctionTracker] Started function execution tracking');
+      
+      // Record performance event
+      if (this.performanceMonitor) {
+        this.performanceMonitor.recordEvent('function_tracking_started', {
+          timestamp: Date.now(),
+          categories: this.targetCategories
+        });
+      }
+      
+    } catch (error) {
+      console.error('[FunctionTracker] Failed to start tracking:', error);
+    }
+  }
+
+  stopTracking() {
+    if (!this.isTracking) return;
+
+    this.restoreAllFunctions();
+    this.stopBufferFlusher();
+    
+    // Clear periodic flush interval
+    if (this.flushInterval) {
+      clearInterval(this.flushInterval);
+      this.flushInterval = null;
+    }
+    
+    // Remove pagehide listener
+    window.removeEventListener('pagehide', this.boundFlush);
+    
+    this.flushBuffer(); // Flush any remaining data
+    
+    this.isTracking = false;
+    // console.log('[FunctionTracker] Stopped function execution tracking');
+    
+    // Record performance event
+    if (this.performanceMonitor) {
+      this.performanceMonitor.recordEvent('function_tracking_stopped', {
+        timestamp: Date.now(),
+        totalCalls: this.executionBuffer.length
+      });
+    }
+  }
+
+  wrapEventHandlers() {
+    // Wrap addEventListener to track event handlers
+    if (window.EventTarget && EventTarget.prototype.addEventListener) {
+      const originalAddEventListener = EventTarget.prototype.addEventListener;
+      const self = this; // Capture FunctionTracker instance
+      
+      EventTarget.prototype.addEventListener = function(type, listener, options) {
+        if (typeof listener === 'function') {
+          const wrappedListener = self.wrapFunction(
+            listener, 
+            `EventHandler:${type}`,
+            { isEventHandler: true, eventType: type }
+          );
+          
+          // Store reference for cleanup
+          if (!listener._chromePilotWrapped) {
+            listener._chromePilotWrapped = wrappedListener;
+          }
+          
+          return originalAddEventListener.call(this, type, wrappedListener, options);
+        }
+        
+        return originalAddEventListener.call(this, type, listener, options);
+      };
+      
+      this.trackedFunctions.set('addEventListener', originalAddEventListener);
+    }
+  }
+
+  wrapAsyncFunctions() {
+    // Wrap fetch API
+    if (window.fetch) {
+      const originalFetch = window.fetch;
+      
+      window.fetch = async (...args) => {
+        const callId = this.generateCallId();
+        const startTime = Date.now();
+        
+        this.recordFunctionCall({
+          callId,
+          functionName: 'fetch',
+          arguments: this.serializeArguments(args),
+          startTime,
+          category: 'async'
+        });
+        
+        try {
+          const result = await originalFetch.apply(window, args);
+          
+          this.recordFunctionReturn({
+            callId,
+            returnValue: this.serializeReturnValue({
+              status: result.status,
+              url: result.url,
+              headers: Object.fromEntries(result.headers.entries())
+            }),
+            executionTime: Date.now() - startTime,
+            success: true
+          });
+          
+          return result;
+        } catch (error) {
+          this.recordFunctionReturn({
+            callId,
+            error: error.message,
+            executionTime: Date.now() - startTime,
+            success: false
+          });
+          throw error;
+        }
+      };
+      
+      this.trackedFunctions.set('fetch', originalFetch);
+    }
+
+    // Wrap setTimeout
+    if (window.setTimeout) {
+      const originalSetTimeout = window.setTimeout;
+      
+      window.setTimeout = (callback, delay, ...args) => {
+        if (typeof callback === 'function') {
+          const wrappedCallback = this.wrapFunction(
+            callback,
+            'setTimeout_callback',
+            { isAsync: true, delay }
+          );
+          return originalSetTimeout(wrappedCallback, delay, ...args);
+        }
+        return originalSetTimeout(callback, delay, ...args);
+      };
+      
+      this.trackedFunctions.set('setTimeout', originalSetTimeout);
+    }
+
+    // Wrap setInterval
+    if (window.setInterval) {
+      const originalSetInterval = window.setInterval;
+      
+      window.setInterval = (callback, delay, ...args) => {
+        if (typeof callback === 'function') {
+          const wrappedCallback = this.wrapFunction(
+            callback,
+            'setInterval_callback',
+            { isAsync: true, delay, repeating: true }
+          );
+          return originalSetInterval(wrappedCallback, delay, ...args);
+        }
+        return originalSetInterval(callback, delay, ...args);
+      };
+      
+      this.trackedFunctions.set('setInterval', originalSetInterval);
+    }
+  }
+
+  wrapDOMMethods() {
+    // Wrap commonly used DOM methods
+    const domMethods = ['querySelector', 'getElementById', 'createElement'];
+    
+    domMethods.forEach(methodName => {
+      if (document[methodName]) {
+        const original = document[methodName];
+        
+        document[methodName] = (...args) => {
+          const callId = this.generateCallId();
+          const startTime = Date.now();
+          
+          this.recordFunctionCall({
+            callId,
+            functionName: `document.${methodName}`,
+            arguments: this.serializeArguments(args),
+            startTime,
+            category: 'dom'
+          });
+          
+          try {
+            const result = original.apply(document, args);
+            
+            this.recordFunctionReturn({
+              callId,
+              returnValue: this.serializeDOMElement(result),
+              executionTime: Date.now() - startTime,
+              success: true
+            });
+            
+            return result;
+          } catch (error) {
+            this.recordFunctionReturn({
+              callId,
+              error: error.message,
+              executionTime: Date.now() - startTime,
+              success: false
+            });
+            throw error;
+          }
+        };
+        
+        this.trackedFunctions.set(methodName, original);
+      }
+    });
+  }
+
+  discoverAndWrapUserFunctions() {
+    // Discover user-defined functions in global scope
+    const globalObj = window;
+    
+    for (const prop in globalObj) {
+      try {
+        if (typeof globalObj[prop] === 'function' && 
+            !prop.startsWith('_') && 
+            !this.isNativeFunction(globalObj[prop]) &&
+            !this.trackedFunctions.has(prop)) {
+          
+          const original = globalObj[prop];
+          const wrapped = this.wrapFunction(original, prop, { isUserDefined: true });
+          
+          globalObj[prop] = wrapped;
+          this.trackedFunctions.set(prop, original);
+        }
+      } catch (error) {
+        // Skip properties that can't be accessed
+        continue;
+      }
+    }
+  }
+
+  wrapFunction(originalFunction, functionName, metadata = {}) {
+    const tracker = this;
+    
+    return function wrappedFunction(...args) {
+      // Prevent deep recursion tracking
+      if (tracker.callStack.length >= tracker.maxCallDepth) {
+        return originalFunction.apply(this, args);
+      }
+      
+      const callId = tracker.generateCallId();
+      const startTime = Date.now();
+      
+      // Add to call stack
+      tracker.callStack.push({
+        callId,
+        functionName,
+        startTime
+      });
+      
+      // Record function call
+      tracker.recordFunctionCall({
+        callId,
+        functionName,
+        arguments: tracker.serializeArguments(args),
+        startTime,
+        category: metadata.category || 'user',
+        metadata,
+        callDepth: tracker.callStack.length,
+        parentCallId: tracker.callStack.length > 1 ? 
+          tracker.callStack[tracker.callStack.length - 2].callId : null
+      });
+      
+      try {
+        const result = originalFunction.apply(this, args);
+        
+        // Handle promises
+        if (result && typeof result.then === 'function') {
+          return result
+            .then(value => {
+              tracker.recordFunctionReturn({
+                callId,
+                returnValue: tracker.serializeReturnValue(value),
+                executionTime: Date.now() - startTime,
+                success: true,
+                isAsync: true
+              });
+              
+              tracker.callStack.pop();
+              return value;
+            })
+            .catch(error => {
+              tracker.recordFunctionReturn({
+                callId,
+                error: error.message,
+                executionTime: Date.now() - startTime,
+                success: false,
+                isAsync: true
+              });
+              
+              tracker.callStack.pop();
+              throw error;
+            });
+        }
+        
+        // Handle synchronous return
+        tracker.recordFunctionReturn({
+          callId,
+          returnValue: tracker.serializeReturnValue(result),
+          executionTime: Date.now() - startTime,
+          success: true
+        });
+        
+        tracker.callStack.pop();
+        return result;
+        
+      } catch (error) {
+        tracker.recordFunctionReturn({
+          callId,
+          error: error.message,
+          executionTime: Date.now() - startTime,
+          success: false
+        });
+        
+        tracker.callStack.pop();
+        throw error;
+      }
+    };
+  }
+
+  recordFunctionCall(callData) {
+    // LIGHTWEIGHT MODE: Only essential info
+    let executionEvent;
+    
+    if (this.lightweightMode) {
+      executionEvent = {
+        type: 'execution_trace',
+        timestamp: callData.startTime,
+        recording_id: this.recordingId,
+        function_name: callData.functionName,
+        // Just argument summary, not full values
+        arg_summary: callData.arguments ? `${callData.arguments.length} args` : '0 args'
+      };
+    } else {
+      // Original full tracking
+      executionEvent = {
+        type: 'execution_trace',
+        timestamp: callData.startTime,
+        recording_id: this.recordingId,
+        call_id: callData.callId,
+        function_name: callData.functionName,
+        arguments: callData.arguments,
+        call_depth: callData.callDepth || 0,
+        parent_call_id: callData.parentCallId,
+        category: callData.category,
+        metadata: callData.metadata
+      };
+    }
+
+    // Apply PII redaction (only if not in lightweight mode)
+    if (this.piiRedactor && !this.lightweightMode) {
+      executionEvent = this.piiRedactor.redactData(executionEvent, 'execution_trace');
+    }
+
+    this.executionBuffer.push(executionEvent);
+    
+    // Check if we should flush based on batch size
+    if (this.executionBuffer.length >= this.batchSize) {
+      this.flush();
+    }
+  }
+
+  recordFunctionReturn(returnData) {
+    // In lightweight mode, don't track returns at all unless there's an error
+    if (this.lightweightMode && !returnData.error) {
+      return;
+    }
+    
+    if (!this.trackReturnValues && !returnData.error) {
+      return; // Skip return value tracking if disabled
+    }
+
+    let returnEvent = {
+      type: 'execution_trace',
+      timestamp: Date.now(),
+      recording_id: this.recordingId,
+      call_id: returnData.callId,
+      return_value: returnData.returnValue,
+      execution_time_ms: returnData.executionTime,
+      success: returnData.success,
+      error: returnData.error,
+      is_async: returnData.isAsync || false
+    };
+
+    // Apply PII redaction
+    if (this.piiRedactor) {
+      returnEvent = this.piiRedactor.redactData(returnEvent, 'execution_trace');
+    }
+
+    this.executionBuffer.push(returnEvent);
+    
+    // Check if we should flush based on batch size
+    if (this.executionBuffer.length >= this.batchSize) {
+      this.flush();
+    }
+  }
+
+  serializeArguments(args) {
+    if (!args || args.length === 0) return [];
+    
+    // LIGHTWEIGHT MODE: Just capture argument count and types
+    if (this.lightweightMode) {
+      try {
+        return Array.from(args).map(arg => {
+          if (arg === null) return 'null';
+          if (arg === undefined) return 'undefined';
+          if (typeof arg === 'function') return '[Function]';
+          if (arg instanceof Element) return `[DOM:${arg.tagName}]`;
+          if (typeof arg === 'object') return `[Object:${arg.constructor?.name || 'Object'}]`;
+          if (typeof arg === 'string') return arg.length > 20 ? `"${arg.substring(0, 20)}..."` : `"${arg}"`;
+          return String(arg).substring(0, 50);
+        });
+      } catch (error) {
+        return ['[Error]'];
+      }
+    }
+    
+    // Original deep serialization (only if not in lightweight mode)
+    try {
+      return Array.from(args).map(arg => {
+        const serialized = this.serializeValue(arg);
+        return this.truncateValue(serialized, this.maxArgumentSize);
+      });
+    } catch (error) {
+      return ['[Serialization Error]'];
+    }
+  }
+
+  serializeReturnValue(value) {
+    if (!this.trackReturnValues) return null;
+    
+    try {
+      const serialized = this.serializeValue(value);
+      return this.truncateValue(serialized, this.maxArgumentSize);
+    } catch (error) {
+      return '[Serialization Error]';
+    }
+  }
+
+  serializeValue(value) {
+    if (value === null || value === undefined) {
+      return value;
+    }
+    
+    if (typeof value === 'function') {
+      return '[Function]';
+    }
+    
+    if (value instanceof Error) {
+      return {
+        name: value.name,
+        message: value.message,
+        stack: value.stack?.substring(0, 500)
+      };
+    }
+    
+    if (value instanceof Element) {
+      return this.serializeDOMElement(value);
+    }
+    
+    if (value && typeof value === 'object') {
+      // Handle circular references and sanitize
+      try {
+        const sanitized = this.sanitizeObject(value);
+        return JSON.parse(JSON.stringify(sanitized));
+      } catch (error) {
+        return '[Circular Reference]';
+      }
+    }
+    
+    // Sanitize string values
+    if (typeof value === 'string') {
+      return this.sanitizeString(value);
+    }
+    
+    return value;
+  }
+  
+  sanitizeObject(obj, depth = 0) {
+    if (depth > 5) {
+      return '[Max Depth Exceeded]';
+    }
+    
+    if (Array.isArray(obj)) {
+      return obj.map(item => this.sanitizeValue(item, depth + 1));
+    }
+    
+    const sanitized = {};
+    for (const [key, value] of Object.entries(obj)) {
+      // Check if key contains sensitive pattern
+      const lowerKey = key.toLowerCase();
+      const isSensitive = this.sensitivePatterns.some(pattern => 
+        lowerKey.includes(pattern.toLowerCase())
+      );
+      
+      if (isSensitive) {
+        sanitized[key] = '[REDACTED]';
+      } else {
+        sanitized[key] = this.sanitizeValue(value, depth + 1);
+      }
+    }
+    
+    return sanitized;
+  }
+  
+  sanitizeValue(value, depth = 0) {
+    if (value === null || value === undefined) {
+      return value;
+    }
+    
+    if (typeof value === 'string') {
+      return this.sanitizeString(value);
+    }
+    
+    if (typeof value === 'object') {
+      return this.sanitizeObject(value, depth);
+    }
+    
+    return value;
+  }
+  
+  sanitizeString(str) {
+    // Check for common sensitive patterns in strings
+    if (str.length > 100) {
+      // Check if it looks like a token or key
+      if (/^[A-Za-z0-9+/=_-]{40,}$/.test(str)) {
+        return '[POSSIBLE TOKEN REDACTED]';
+      }
+      
+      // Check for JWT pattern
+      if (/^eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/.test(str)) {
+        return '[JWT TOKEN REDACTED]';
+      }
+    }
+    
+    // Check for credit card pattern
+    if (/\b(?:\d{4}[-\s]?){3}\d{4}\b/.test(str)) {
+      return str.replace(/\b(?:\d{4}[-\s]?){3}\d{4}\b/g, '[CREDIT CARD REDACTED]');
+    }
+    
+    // Check for SSN pattern
+    if (/\b\d{3}-\d{2}-\d{4}\b/.test(str)) {
+      return str.replace(/\b\d{3}-\d{2}-\d{4}\b/g, '[SSN REDACTED]');
+    }
+    
+    return str;
+  }
+
+  serializeDOMElement(element) {
+    if (!element || !element.tagName) return element;
+    
+    return {
+      tagName: element.tagName.toLowerCase(),
+      id: element.id,
+      className: element.className,
+      textContent: element.textContent?.substring(0, 100)
+    };
+  }
+
+  truncateValue(value, maxSize) {
+    if (typeof value === 'string' && value.length > maxSize) {
+      return value.substring(0, maxSize) + '... [truncated]';
+    }
+    
+    if (typeof value === 'object' && value !== null) {
+      const stringified = JSON.stringify(value);
+      if (stringified.length > maxSize) {
+        return JSON.stringify(value, null, 0).substring(0, maxSize) + '... [truncated]';
+      }
+    }
+    
+    return value;
+  }
+
+  isNativeFunction(func) {
+    const funcStr = func.toString();
+    return funcStr.includes('[native code]') || 
+           funcStr.includes('[object ') ||
+           func.name.startsWith('bound ');
+  }
+
+  generateCallId() {
+    return `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  restoreAllFunctions() {
+    // Restore all wrapped functions
+    for (const [name, original] of this.trackedFunctions) {
+      try {
+        if (name === 'addEventListener' && EventTarget.prototype.addEventListener) {
+          EventTarget.prototype.addEventListener = original;
+        } else if (name === 'fetch' && window.fetch) {
+          window.fetch = original;
+        } else if (name === 'setTimeout' && window.setTimeout) {
+          window.setTimeout = original;
+        } else if (name === 'setInterval' && window.setInterval) {
+          window.setInterval = original;
+        } else if (document[name]) {
+          document[name] = original;
+        } else if (window[name]) {
+          window[name] = original;
+        }
+      } catch (error) {
+        console.error(`[FunctionTracker] Failed to restore ${name}:`, error);
+      }
+    }
+    
+    this.trackedFunctions.clear();
+  }
+
+  startBufferFlusher() {
+    if (this.flushTimer) return;
+    
+    this.flushTimer = setInterval(() => {
+      if (this.executionBuffer.length > 0) {
+        this.flushBuffer();
+      }
+    }, this.bufferFlushDelay);
+  }
+
+  stopBufferFlusher() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+
+  flushBuffer() {
+    if (this.executionBuffer.length === 0) return;
+    
+    const events = [...this.executionBuffer];
+    this.executionBuffer = [];
+    
+    // console.log(`[FunctionTracker] Flushing ${events.length} execution traces`);
+    
+    // Send data via callback
+    if (this.onDataReady) {
+      this.onDataReady(events);
+    }
+    
+    // Record performance metrics
+    if (this.performanceMonitor) {
+      this.performanceMonitor.recordEvent('function_calls_flushed', {
+        count: events.length,
+        timestamp: Date.now()
+      });
+    }
+  }
+
+  getStats() {
+    return {
+      isTracking: this.isTracking,
+      bufferSize: this.executionBuffer.length,
+      trackedFunctionCount: this.trackedFunctions.size,
+      currentCallDepth: this.callStack.length,
+      recordingId: this.recordingId,
+      targetCategories: this.targetCategories
+    };
+  }
+
+  flush() {
+    if (this.executionBuffer.length === 0 || !this.onDataReady) {
+      return;
+    }
+
+    // Pass a copy of the buffer to the callback and reset the original
+    const eventsToFlush = [...this.executionBuffer];
+    this.executionBuffer = [];
+
+    try {
+      this.onDataReady(eventsToFlush);
+      // console.log(`[FunctionTracker] Flushed ${eventsToFlush.length} execution traces`);
+    } catch (error) {
+      console.error('[FunctionTracker] Error in onDataReady callback for function traces:', error);
+      // Optionally add events back for retry, but be careful of infinite loops
+      // this.executionBuffer.unshift(...eventsToFlush);
+    }
+  }
+
+  destroy() {
+    this.stopTracking();
+    this.executionBuffer = [];
+    this.callStack = [];
+    this.onDataReady = null;
+    this.piiRedactor = null;
+    this.performanceMonitor = null;
+  }
+}
+
+// Export for use in content script
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = FunctionTracker;
+}