@flisk/analyze-tracking 0.5.2 → 0.7.0

package/src/analyze/analyzePythonFile.js

@@ -0,0 +1,41 @@
+const fs = require('fs');
+const path = require('path');
+
+let pyodide = null;
+
+async function initPyodide() {
+  if (!pyodide) {
+    const { loadPyodide } = await import('pyodide');
+    pyodide = await loadPyodide();
+    await pyodide.loadPackagesFromImports('import ast, json');
+  }
+  return pyodide;
+}
+
+async function analyzePythonFile(filePath, customFunction) {
+  try {
+    const code = fs.readFileSync(filePath, 'utf8');
+    const py = await initPyodide();
+    
+    // Read the Python analyzer code
+    const analyzerPath = path.join(__dirname, 'pythonTrackingAnalyzer.py');
+    const analyzerCode = fs.readFileSync(analyzerPath, 'utf8');
+    
+    // Add file content and analyzer code to Python environment
+    py.globals.set('code', code);
+    py.globals.set('filepath', filePath);
+    py.globals.set('custom_function', customFunction || null);
+    
+    // Run the Python analyzer
+    py.runPython(analyzerCode);
+    const result = py.runPython('analyze_python_code(code, filepath, custom_function)');
+    const events = JSON.parse(result);
+    
+    return events;
+  } catch (error) {
+    console.error(`Error analyzing Python file ${filePath}:`, error);
+    return [];
+  }
+}
+
+module.exports = { analyzePythonFile };

package/src/analyze/analyzeRubyFile.js

@@ -4,12 +4,13 @@ let parse = null;
 
 // Create a visitor to traverse the AST
 class TrackingVisitor {
-  constructor(code, filePath) {
+  constructor(code, filePath, customFunction=null) {
     this.code = code;
     this.lines = code.split('\n');
     this.ancestors = [];
     this.events = [];
     this.filePath = filePath;
+    this.customFunction = customFunction;
   }
 
   getLineNumber(location) {
@@ -40,13 +41,27 @@ class TrackingVisitor {
   detectSource(node) {
     if (!node) return null;
   
-    // Check for other analytics libraries
+    // Check for analytics libraries
     if (node.receiver) {
       const objectName = node.receiver.name;
       const methodName = node.name;
 
+      // Segment
       if (objectName === 'Analytics' && methodName === 'track') return 'segment';
+      
+      // Mixpanel (Ruby SDK uses Mixpanel::Tracker instance)
+      if (methodName === 'track' && node.receiver.type === 'CallNode' && 
+          node.receiver.name === 'tracker') return 'mixpanel';
+      
+      // PostHog
+      if (objectName === 'posthog' && methodName === 'capture') return 'posthog';
     }
+    
+    // Snowplow (typically tracker.track_struct_event)
+    if (node.name === 'track_struct_event') return 'snowplow';
+    
+    // Custom tracking function
+    if (this.customFunction && node.name === this.customFunction) return 'custom';
   
     return null;
   }
@@ -58,6 +73,38 @@ class TrackingVisitor {
       return eventProperty?.value?.unescaped?.value || null;
     }
 
+    if (source === 'mixpanel') {
+      // Mixpanel Ruby SDK format: tracker.track('distinct_id', 'event_name', {...})
+      const args = node.arguments_.arguments_;
+      if (args && args.length > 1 && args[1]?.unescaped?.value) {
+        return args[1].unescaped.value;
+      }
+    }
+
+    if (source === 'posthog') {
+      // PostHog Ruby SDK format: posthog.capture({distinct_id: '...', event: '...', properties: {...}})
+      const hashArg = node.arguments_.arguments_[0];
+      if (hashArg && hashArg.elements) {
+        const eventProperty = hashArg.elements.find(elem => elem?.key?.unescaped?.value === 'event');
+        return eventProperty?.value?.unescaped?.value || null;
+      }
+    }
+
+    if (source === 'snowplow') {
+      // Snowplow Ruby SDK: tracker.track_struct_event(category: '...', action: '...', ...)
+      const params = node.arguments_.arguments_[0].elements;
+      const actionProperty = params.find(param => param?.key?.unescaped?.value === 'action');
+      return actionProperty?.value?.unescaped?.value || null;
+    }
+    
+    if (source === 'custom') {
+      // Custom function format: customFunction('event_name', {...})
+      const args = node.arguments_.arguments_;
+      if (args && args.length > 0 && args[0]?.unescaped?.value) {
+        return args[0].unescaped.value;
+      }
+    }
+
     return null;
   }
 
@@ -106,6 +153,78 @@ class TrackingVisitor {
       return properties;
     }
 
+    if (source === 'mixpanel') {
+      // Mixpanel Ruby SDK: tracker.track('distinct_id', 'event_name', {properties})
+      const args = node.arguments_.arguments_;
+      const properties = {};
+      
+      // Add distinct_id as property
+      if (args && args.length > 0 && args[0]?.unescaped?.value) {
+        properties.distinct_id = {
+          type: 'string'
+        };
+      }
+      
+      // Extract properties from third argument if it exists
+      if (args && args.length > 2 && args[2] instanceof HashNode) {
+        const propsHash = await this.extractHashProperties(args[2]);
+        Object.assign(properties, propsHash);
+      }
+      
+      return properties;
+    }
+
+    if (source === 'posthog') {
+      // PostHog Ruby SDK: posthog.capture({distinct_id: '...', event: '...', properties: {...}})
+      const hashArg = node.arguments_.arguments_[0];
+      const properties = {};
+      
+      if (hashArg && hashArg.elements) {
+        // Extract distinct_id if present
+        const distinctIdProperty = hashArg.elements.find(elem => elem?.key?.unescaped?.value === 'distinct_id');
+        if (distinctIdProperty?.value) {
+          properties.distinct_id = {
+            type: await this.getValueType(distinctIdProperty.value)
+          };
+        }
+        
+        // Extract properties
+        const propsProperty = hashArg.elements.find(elem => elem?.key?.unescaped?.value === 'properties');
+        if (propsProperty?.value instanceof HashNode) {
+          const props = await this.extractHashProperties(propsProperty.value);
+          Object.assign(properties, props);
+        }
+      }
+      
+      return properties;
+    }
+
+    if (source === 'snowplow') {
+      // Snowplow Ruby SDK: tracker.track_struct_event(category: '...', action: '...', ...)
+      const params = node.arguments_.arguments_[0].elements;
+      const properties = {};
+      
+      // Extract all struct event parameters except 'action' (which is used as the event name)
+      for (const param of params) {
+        const key = param?.key?.unescaped?.value;
+        if (key && key !== 'action') {
+          properties[key] = {
+            type: await this.getValueType(param.value)
+          };
+        }
+      }
+      
+      return properties;
+    }
+    
+    if (source === 'custom') {
+      // Custom function format: customFunction('event_name', {properties})
+      const args = node.arguments_.arguments_;
+      if (args && args.length > 1 && args[1] instanceof HashNode) {
+        return await this.extractHashProperties(args[1]);
+      }
+    }
+
     return null;
   }
 
@@ -257,7 +376,7 @@ class TrackingVisitor {
   }
 }
 
-async function analyzeRubyFile(filePath) {
+async function analyzeRubyFile(filePath, customFunction) {
   // Lazy load the ruby prism parser
   if (!parse) {
     const { loadPrism } = await import('@ruby/prism');
@@ -275,7 +394,7 @@ async function analyzeRubyFile(filePath) {
     }
 
     // Traverse the AST starting from the program node
-    const visitor = new TrackingVisitor(code, filePath);
+    const visitor = new TrackingVisitor(code, filePath, customFunction);
     await visitor.visit(ast.value);
 
     return visitor.events;