behavior_analytics 2.2.0 → 2.2.2

data/lib/behavior_analytics/javascript/client.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module BehaviorAnalytics
+  module Javascript
+    class Client
+      def self.generate_script(tracker_url: "/behavior_analytics/track", auto_track: true)
+        <<~JAVASCRIPT
+          (function() {
+            var BehaviorAnalytics = {
+              trackerUrl: '#{tracker_url}',
+              visitorToken: null,
+              visitToken: null,
+              
+              init: function() {
+                this.loadVisitorToken();
+                #{'this.autoTrack();' if auto_track}
+              },
+              
+              loadVisitorToken: function() {
+                var token = this.getCookie('behavior_visitor_token');
+                if (!token) {
+                  token = this.generateToken();
+                  this.setCookie('behavior_visitor_token', token, 730); // 2 years
+                }
+                this.visitorToken = token;
+              },
+              
+              generateToken: function() {
+                return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+                  var r = Math.random() * 16 | 0;
+                  var v = c == 'x' ? r : (r & 0x3 | 0x8);
+                  return v.toString(16);
+                });
+              },
+              
+              setCookie: function(name, value, days) {
+                var expires = '';
+                if (days) {
+                  var date = new Date();
+                  date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
+                  expires = '; expires=' + date.toUTCString();
+                }
+                document.cookie = name + '=' + (value || '') + expires + '; path=/; SameSite=Lax';
+              },
+              
+              getCookie: function(name) {
+                var nameEQ = name + '=';
+                var ca = document.cookie.split(';');
+                for (var i = 0; i < ca.length; i++) {
+                  var c = ca[i];
+                  while (c.charAt(0) == ' ') c = c.substring(1, c.length);
+                  if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length, c.length);
+                }
+                return null;
+              },
+              
+              track: function(eventName, properties) {
+                var payload = {
+                  event_name: eventName,
+                  properties: properties || {},
+                  visitor_token: this.visitorToken,
+                  visit_token: this.visitToken,
+                  page: window.location.pathname,
+                  referrer: document.referrer,
+                  user_agent: navigator.userAgent,
+                  timestamp: new Date().toISOString()
+                };
+                
+                this.sendRequest(payload);
+              },
+              
+              trackPageView: function() {
+                this.track('page_view', {
+                  path: window.location.pathname,
+                  title: document.title,
+                  referrer: document.referrer
+                });
+              },
+              
+              trackClick: function(element, properties) {
+                var props = {
+                  element: element.tagName.toLowerCase(),
+                  id: element.id || null,
+                  class: element.className || null,
+                  text: element.textContent ? element.textContent.substring(0, 100) : null
+                };
+                
+                if (properties) {
+                  Object.assign(props, properties);
+                }
+                
+                this.track('click', props);
+              },
+              
+              autoTrack: function() {
+                var self = this;
+                
+                // Track page view on load
+                if (document.readyState === 'loading') {
+                  document.addEventListener('DOMContentLoaded', function() {
+                    self.trackPageView();
+                  });
+                } else {
+                  this.trackPageView();
+                }
+                
+                // Track clicks on elements with data-track attribute
+                document.addEventListener('click', function(e) {
+                  var element = e.target;
+                  if (element.hasAttribute('data-track')) {
+                    var trackValue = element.getAttribute('data-track');
+                    var properties = {};
+                    
+                    if (element.hasAttribute('data-track-properties')) {
+                      try {
+                        properties = JSON.parse(element.getAttribute('data-track-properties'));
+                      } catch (e) {}
+                    }
+                    
+                    self.track(trackValue || 'click', properties);
+                  }
+                });
+                
+                // Track form submissions
+                document.addEventListener('submit', function(e) {
+                  var form = e.target;
+                  if (form.tagName === 'FORM' && form.hasAttribute('data-track')) {
+                    var trackValue = form.getAttribute('data-track');
+                    self.track(trackValue || 'form_submit', {
+                      form_id: form.id || null,
+                      form_action: form.action || null
+                    });
+                  }
+                });
+              },
+              
+              sendRequest: function(payload) {
+                if (navigator.sendBeacon) {
+                  var blob = new Blob([JSON.stringify(payload)], { type: 'application/json' });
+                  navigator.sendBeacon(this.trackerUrl, blob);
+                } else {
+                  var xhr = new XMLHttpRequest();
+                  xhr.open('POST', this.trackerUrl, true);
+                  xhr.setRequestHeader('Content-Type', 'application/json');
+                  xhr.send(JSON.stringify(payload));
+                }
+              }
+            };
+            
+            // Initialize on load
+            if (document.readyState === 'loading') {
+              document.addEventListener('DOMContentLoaded', function() {
+                BehaviorAnalytics.init();
+              });
+            } else {
+              BehaviorAnalytics.init();
+            }
+            
+            // Expose globally
+            window.BehaviorAnalytics = BehaviorAnalytics;
+          })();
+        JAVASCRIPT
+      end
+    end
+  end
+end
+

data/lib/behavior_analytics/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BehaviorAnalytics
-  VERSION = "2.2.0"
+  VERSION = "2.2.2"
 end

data/lib/behavior_analytics/visits/auto_creator.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module BehaviorAnalytics
+  module Visits
+    class AutoCreator
+      attr_reader :manager, :cookie_name
+
+      def initialize(manager:, cookie_name: "behavior_visitor_token")
+        @manager = manager
+        @cookie_name = cookie_name
+      end
+
+      def get_or_create_visit(request:, tenant_id: nil, user_id: nil)
+        visitor_token = get_or_create_visitor_token(request)
+        
+        utm_params = extract_utm_params(request)
+        
+        manager.find_or_create_visit(
+          visitor_token: visitor_token,
+          tenant_id: tenant_id,
+          user_id: user_id,
+          ip: request.ip,
+          user_agent: request.user_agent,
+          referrer: request.referer,
+          landing_page: request.path,
+          utm_params: utm_params
+        )
+      end
+
+      def get_or_create_visitor_token(request)
+        # Try to get from cookie
+        if request.respond_to?(:cookies)
+          token = request.cookies[cookie_name]
+          return token if token && !token.empty?
+        end
+
+        # Try to get from headers (for API requests)
+        if request.respond_to?(:headers)
+          token = request.headers["X-Visitor-Token"]
+          return token if token && !token.empty?
+        end
+
+        # Generate new token
+        SecureRandom.hex(16)
+      end
+
+      def set_visitor_token_cookie(response, visitor_token)
+        return unless response.respond_to?(:set_cookie)
+        
+        # Set cookie for 2 years
+        secure = if defined?(Rails)
+          Rails.env.production?
+        else
+          ENV["RAILS_ENV"] == "production" || ENV["RACK_ENV"] == "production"
+        end
+        
+        response.set_cookie(
+          cookie_name,
+          value: visitor_token,
+          expires: 2.years.from_now,
+          httponly: true,
+          secure: secure,
+          same_site: :lax
+        )
+      end
+
+      private
+
+      def extract_utm_params(request)
+        params = {}
+        
+        if request.respond_to?(:params)
+          params[:utm_source] = request.params["utm_source"]
+          params[:utm_medium] = request.params["utm_medium"]
+          params[:utm_campaign] = request.params["utm_campaign"]
+          params[:utm_term] = request.params["utm_term"]
+          params[:utm_content] = request.params["utm_content"]
+        end
+
+        params.compact
+      end
+    end
+  end
+end
+

data/lib/behavior_analytics/visits/manager.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "uri"
+
+module BehaviorAnalytics
+  module Visits
+    class Manager
+      attr_reader :storage_adapter, :visit_duration
+
+      def initialize(storage_adapter:, visit_duration: 30.minutes, device_detector: nil, geolocation: nil)
+        @storage_adapter = storage_adapter
+        @visit_duration = visit_duration
+        @device_detector = device_detector
+        @geolocation = geolocation
+      end
+
+      def find_or_create_visit(visitor_token:, tenant_id: nil, user_id: nil, ip: nil, user_agent: nil, 
+                               referrer: nil, landing_page: nil, utm_params: {})
+        # Try to find active visit for this visitor
+        active_visit = find_active_visit(visitor_token, user_id)
+        
+        if active_visit && !active_visit.expired?(visit_duration)
+          # Update visit if user logged in
+          if user_id && active_visit.user_id.nil?
+            active_visit.user_id = user_id
+            save_visit(active_visit)
+          end
+          return active_visit
+        end
+
+        # Detect device and geolocation if enabled
+        device_info = {}
+        geo_info = {}
+        
+        if BehaviorAnalytics.configuration.track_device_info && @device_detector && user_agent
+          device_info = @device_detector.detect(user_agent)
+        end
+        
+        if BehaviorAnalytics.configuration.track_geolocation && @geolocation && ip
+          geo_info = @geolocation.detect(ip)
+        end
+
+        # Create new visit
+        visit = Visit.new(
+          visitor_token: visitor_token,
+          tenant_id: tenant_id || BehaviorAnalytics.configuration.default_tenant_id,
+          user_id: user_id,
+          ip: ip,
+          user_agent: user_agent,
+          referrer: referrer,
+          landing_page: landing_page || referrer,
+          browser: device_info[:browser],
+          os: device_info[:os],
+          device_type: device_info[:device_type],
+          country: geo_info[:country],
+          city: geo_info[:city],
+          utm_source: utm_params[:utm_source],
+          utm_medium: utm_params[:utm_medium],
+          utm_campaign: utm_params[:utm_campaign],
+          utm_term: utm_params[:utm_term],
+          utm_content: utm_params[:utm_content],
+          referring_domain: extract_domain(referrer),
+          search_keyword: extract_search_keyword(referrer)
+        )
+
+        save_visit(visit)
+        visit
+      end
+
+      def find_active_visit(visitor_token, user_id = nil)
+        return nil unless storage_adapter.respond_to?(:find_active_visit)
+        
+        visit_data = storage_adapter.find_active_visit(visitor_token, user_id, visit_duration)
+        return nil unless visit_data
+
+        Visit.new(visit_data)
+      end
+
+      def save_visit(visit)
+        if storage_adapter.respond_to?(:save_visit)
+          storage_adapter.save_visit(visit.to_h)
+        end
+      end
+
+      def end_visit(visit_token)
+        visit = find_visit_by_token(visit_token)
+        return unless visit
+
+        visit.end!
+        save_visit(visit)
+      end
+
+      def find_visit_by_token(visit_token)
+        return nil unless storage_adapter.respond_to?(:find_visit_by_token)
+        
+        visit_data = storage_adapter.find_visit_by_token(visit_token)
+        return nil unless visit_data
+
+        Visit.new(visit_data)
+      end
+
+      def link_user_to_visits(visitor_token, user_id)
+        return unless storage_adapter.respond_to?(:link_user_to_visits)
+        
+        storage_adapter.link_user_to_visits(visitor_token, user_id)
+      end
+
+      def find_visits_by_user(user_id, limit: 100)
+        return [] unless storage_adapter.respond_to?(:find_visits_by_user)
+        
+        visits_data = storage_adapter.find_visits_by_user(user_id, limit: limit)
+        visits_data.map { |data| Visit.new(data) }
+      end
+
+      def find_visits_by_visitor(visitor_token, limit: 100)
+        return [] unless storage_adapter.respond_to?(:find_visits_by_visitor)
+        
+        visits_data = storage_adapter.find_visits_by_visitor(visitor_token, limit: limit)
+        visits_data.map { |data| Visit.new(data) }
+      end
+
+      private
+
+      def extract_domain(url)
+        return nil unless url
+        URI.parse(url).host rescue nil
+      end
+
+      def extract_search_keyword(referrer)
+        return nil unless referrer
+        
+        uri = URI.parse(referrer) rescue nil
+        return nil unless uri
+        
+        # Extract from Google, Bing, etc.
+        if uri.host&.include?("google")
+          params = URI.decode_www_form(uri.query || "").to_h
+          params["q"] || params["query"]
+        elsif uri.host&.include?("bing")
+          params = URI.decode_www_form(uri.query || "").to_h
+          params["q"]
+        else
+          nil
+        end
+      end
+    end
+  end
+end
+

data/lib/behavior_analytics/visits/visit.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module BehaviorAnalytics
+  module Visits
+    class Visit
+      attr_accessor :visit_token, :visitor_token, :tenant_id, :user_id, :ip, :user_agent,
+                    :referrer, :landing_page, :browser, :os, :device_type, :country, :city,
+                    :utm_source, :utm_medium, :utm_campaign, :utm_term, :utm_content,
+                    :referring_domain, :search_keyword, :started_at, :ended_at, :created_at, :updated_at
+
+      def initialize(attributes = {})
+        @visit_token = attributes[:visit_token] || SecureRandom.hex(16)
+        @visitor_token = attributes[:visitor_token] || SecureRandom.hex(16)
+        @tenant_id = attributes[:tenant_id]
+        @user_id = attributes[:user_id]
+        @ip = attributes[:ip]
+        @user_agent = attributes[:user_agent]
+        @referrer = attributes[:referrer]
+        @landing_page = attributes[:landing_page]
+        @browser = attributes[:browser]
+        @os = attributes[:os]
+        @device_type = attributes[:device_type]
+        @country = attributes[:country]
+        @city = attributes[:city]
+        @utm_source = attributes[:utm_source]
+        @utm_medium = attributes[:utm_medium]
+        @utm_campaign = attributes[:utm_campaign]
+        @utm_term = attributes[:utm_term]
+        @utm_content = attributes[:utm_content]
+        @referring_domain = attributes[:referring_domain]
+        @search_keyword = attributes[:search_keyword]
+        @started_at = attributes[:started_at] || Time.now
+        @ended_at = attributes[:ended_at]
+        @created_at = attributes[:created_at] || Time.now
+        @updated_at = attributes[:updated_at] || Time.now
+      end
+
+      def to_h
+        {
+          visit_token: visit_token,
+          visitor_token: visitor_token,
+          tenant_id: tenant_id,
+          user_id: user_id,
+          ip: ip,
+          user_agent: user_agent,
+          referrer: referrer,
+          landing_page: landing_page,
+          browser: browser,
+          os: os,
+          device_type: device_type,
+          country: country,
+          city: city,
+          utm_source: utm_source,
+          utm_medium: utm_medium,
+          utm_campaign: utm_campaign,
+          utm_term: utm_term,
+          utm_content: utm_content,
+          referring_domain: referring_domain,
+          search_keyword: search_keyword,
+          started_at: started_at,
+          ended_at: ended_at,
+          created_at: created_at,
+          updated_at: updated_at
+        }.compact
+      end
+
+      def duration_seconds
+        return nil unless ended_at
+        (ended_at - started_at).to_i
+      end
+
+      def active?
+        ended_at.nil?
+      end
+
+      def expired?(inactivity_duration = 30.minutes)
+        return false unless active?
+        (Time.now - started_at) > inactivity_duration
+      end
+
+      def end!
+        @ended_at = Time.now
+        @updated_at = Time.now
+      end
+    end
+  end
+end
+

data/lib/behavior_analytics.rb

@@ -205,7 +205,7 @@ module BehaviorAnalytics
       Tracker.new(options)
     end
 
-    # Simplified API methods (Ahoy-inspired)
+    # Simplified API methods
     def track(event_name, properties: {}, event_type: :custom, context: nil, **options)
       # Resolve context automatically if not provided
       context ||= resolve_default_context

data/vendor/assets/javascripts/behavior_analytics.js

@@ -0,0 +1,159 @@
+// Behavior Analytics JavaScript Client
+// This file can be included in your Rails application
+// Usage: <%= javascript_include_tag 'behavior_analytics' %>
+
+(function() {
+  var BehaviorAnalytics = {
+    trackerUrl: '/behavior_analytics/track',
+    visitorToken: null,
+    visitToken: null,
+    
+    init: function() {
+      this.loadVisitorToken();
+      this.autoTrack();
+    },
+    
+    loadVisitorToken: function() {
+      var token = this.getCookie('behavior_visitor_token');
+      if (!token) {
+        token = this.generateToken();
+        this.setCookie('behavior_visitor_token', token, 730); // 2 years
+      }
+      this.visitorToken = token;
+    },
+    
+    generateToken: function() {
+      return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+        var r = Math.random() * 16 | 0;
+        var v = c == 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+      });
+    },
+    
+    setCookie: function(name, value, days) {
+      var expires = '';
+      if (days) {
+        var date = new Date();
+        date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
+        expires = '; expires=' + date.toUTCString();
+      }
+      document.cookie = name + '=' + (value || '') + expires + '; path=/; SameSite=Lax';
+    },
+    
+    getCookie: function(name) {
+      var nameEQ = name + '=';
+      var ca = document.cookie.split(';');
+      for (var i = 0; i < ca.length; i++) {
+        var c = ca[i];
+        while (c.charAt(0) == ' ') c = c.substring(1, c.length);
+        if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length, c.length);
+      }
+      return null;
+    },
+    
+    track: function(eventName, properties) {
+      var payload = {
+        event_name: eventName,
+        properties: properties || {},
+        visitor_token: this.visitorToken,
+        visit_token: this.visitToken,
+        page: window.location.pathname,
+        referrer: document.referrer,
+        user_agent: navigator.userAgent,
+        timestamp: new Date().toISOString()
+      };
+      
+      this.sendRequest(payload);
+    },
+    
+    trackPageView: function() {
+      this.track('page_view', {
+        path: window.location.pathname,
+        title: document.title,
+        referrer: document.referrer
+      });
+    },
+    
+    trackClick: function(element, properties) {
+      var props = {
+        element: element.tagName.toLowerCase(),
+        id: element.id || null,
+        class: element.className || null,
+        text: element.textContent ? element.textContent.substring(0, 100) : null
+      };
+      
+      if (properties) {
+        Object.assign(props, properties);
+      }
+      
+      this.track('click', props);
+    },
+    
+    autoTrack: function() {
+      var self = this;
+      
+      // Track page view on load
+      if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', function() {
+          self.trackPageView();
+        });
+      } else {
+        this.trackPageView();
+      }
+      
+      // Track clicks on elements with data-track attribute
+      document.addEventListener('click', function(e) {
+        var element = e.target;
+        if (element.hasAttribute('data-track')) {
+          var trackValue = element.getAttribute('data-track');
+          var properties = {};
+          
+          if (element.hasAttribute('data-track-properties')) {
+            try {
+              properties = JSON.parse(element.getAttribute('data-track-properties'));
+            } catch (e) {}
+          }
+          
+          self.track(trackValue || 'click', properties);
+        }
+      });
+      
+      // Track form submissions
+      document.addEventListener('submit', function(e) {
+        var form = e.target;
+        if (form.tagName === 'FORM' && form.hasAttribute('data-track')) {
+          var trackValue = form.getAttribute('data-track');
+          self.track(trackValue || 'form_submit', {
+            form_id: form.id || null,
+            form_action: form.action || null
+          });
+        }
+      });
+    },
+    
+    sendRequest: function(payload) {
+      if (navigator.sendBeacon) {
+        var blob = new Blob([JSON.stringify(payload)], { type: 'application/json' });
+        navigator.sendBeacon(this.trackerUrl, blob);
+      } else {
+        var xhr = new XMLHttpRequest();
+        xhr.open('POST', this.trackerUrl, true);
+        xhr.setRequestHeader('Content-Type', 'application/json');
+        xhr.send(JSON.stringify(payload));
+      }
+    }
+  };
+  
+  // Initialize on load
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', function() {
+      BehaviorAnalytics.init();
+    });
+  } else {
+    BehaviorAnalytics.init();
+  }
+  
+  // Expose globally
+  window.BehaviorAnalytics = BehaviorAnalytics;
+})();
+