behavior_analytics 0.1.0 → 2.0.0

data/lib/behavior_analytics/integrations/rails/middleware.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module BehaviorAnalytics
+  module Integrations
+    module Rails
+      class Middleware
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          start_time = Time.now
+          status, headers, response = @app.call(env)
+          
+          # Track request if enabled
+          if should_track_request?(env)
+            track_request(env, status, start_time)
+          end
+          
+          [status, headers, response]
+        end
+
+        private
+
+        def should_track_request?(env)
+          return false unless BehaviorAnalytics.configuration.storage_adapter
+          return false unless BehaviorAnalytics.configuration.track_middleware_requests
+
+          path = env["PATH_INFO"]
+          return false if path_blacklisted?(path)
+          return false if path_not_whitelisted?(path)
+
+          true
+        end
+
+        def path_blacklisted?(path)
+          blacklist = BehaviorAnalytics.configuration.tracking_blacklist || []
+          return false if blacklist.empty?
+
+          blacklist.any? { |pattern| matches_pattern?(path, pattern) }
+        end
+
+        def path_not_whitelisted?(path)
+          whitelist = BehaviorAnalytics.configuration.tracking_whitelist
+          return false unless whitelist && !whitelist.empty?
+
+          !whitelist.any? { |pattern| matches_pattern?(path, pattern) }
+        end
+
+        def matches_pattern?(path, pattern)
+          case pattern
+          when Regexp
+            pattern.match?(path)
+          when String
+            path.include?(pattern) || File.fnmatch?(pattern, path)
+          else
+            false
+          end
+        end
+
+        def track_request(env, status, start_time)
+          duration_ms = ((Time.now - start_time) * 1000).to_i
+          
+          # Try to extract context from env
+          context = extract_context_from_env(env)
+          return unless context&.valid?
+
+          tracker = BehaviorAnalytics.create_tracker
+          tracker.track_api_call(
+            context: context,
+            method: env["REQUEST_METHOD"],
+            path: env["PATH_INFO"],
+            status_code: status,
+            duration_ms: duration_ms,
+            ip: env["REMOTE_ADDR"],
+            user_agent: env["HTTP_USER_AGENT"]
+          )
+        rescue StandardError => e
+          # Don't let tracking errors break the request
+          if defined?(Rails) && Rails.logger
+            Rails.logger.error("BehaviorAnalytics: Middleware tracking error: #{e.message}")
+          end
+        end
+
+        def extract_context_from_env(env)
+          # Try to get context from request store or session
+          if defined?(ActionDispatch::Request)
+            request = ActionDispatch::Request.new(env)
+            # This would need to be customized based on your app's context resolution
+            nil
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/behavior_analytics/integrations/rails.rb

@@ -79,12 +79,118 @@ module BehaviorAnalytics
         context = resolve_tracking_context
         return false unless context&.valid?
 
+        # Check path whitelist/blacklist
+        return false if path_blacklisted?
+        return false if path_not_whitelisted?
+
+        # Check user agent filtering
+        return false if bot_user_agent?
+
+        # Check controller/action filtering
+        return false if controller_action_filtered?
+
         true
       end
 
+      def path_blacklisted?
+        blacklist = BehaviorAnalytics.configuration.tracking_blacklist || []
+        return false if blacklist.empty?
+
+        blacklist.any? { |pattern| matches_pattern?(request.path, pattern) }
+      end
+
+      def path_not_whitelisted?
+        whitelist = BehaviorAnalytics.configuration.tracking_whitelist
+        return false unless whitelist && !whitelist.empty?
+
+        !whitelist.any? { |pattern| matches_pattern?(request.path, pattern) }
+      end
+
+      def bot_user_agent?
+        return false unless BehaviorAnalytics.configuration.skip_bots
+
+        user_agent = request.user_agent.to_s.downcase
+        bot_patterns = %w[bot crawler spider crawlerbot googlebot bingbot yandex]
+        bot_patterns.any? { |pattern| user_agent.include?(pattern) }
+      end
+
+      def controller_action_filtered?
+        filters = BehaviorAnalytics.configuration.controller_action_filters || {}
+        return false if filters.empty?
+
+        controller_filter = filters[:controllers] || []
+        action_filter = filters[:actions] || []
+
+        return true if controller_filter.include?(controller_name)
+        return true if action_filter.include?("#{controller_name}##{action_name}")
+
+        false
+      end
+
+      def matches_pattern?(path, pattern)
+        case pattern
+        when Regexp
+          pattern.match?(path)
+        when String
+          path.include?(pattern) || File.fnmatch?(pattern, path)
+        else
+          false
+        end
+      end
+
       def behavior_analytics_enabled?
         BehaviorAnalytics.configuration.storage_adapter.present?
       end
+
+      def track_behavior_analytics
+        start_time = Time.current
+        error_occurred = false
+        error_message = nil
+        
+        yield
+      rescue StandardError => e
+        error_occurred = true
+        error_message = e.message
+        raise
+      ensure
+        if should_track?
+          context = resolve_tracking_context
+          if context&.valid?
+            duration_ms = ((Time.current - start_time) * 1000).to_i
+
+            # Check for slow queries
+            if BehaviorAnalytics.configuration.slow_query_threshold
+              if duration_ms > BehaviorAnalytics.configuration.slow_query_threshold
+                log_slow_query(duration_ms, request.path)
+              end
+            end
+
+            behavior_tracker.track_api_call(
+              context: context,
+              method: request.method,
+              path: request.path,
+              status_code: response.status,
+              duration_ms: duration_ms,
+              ip: request.remote_ip,
+              user_agent: request.user_agent,
+              session_id: session.id,
+              metadata: {
+                controller: controller_name,
+                action: action_name,
+                format: request.format.to_s,
+                error: error_occurred,
+                error_message: error_message
+              }.compact
+            )
+          end
+        end
+      end
+
+      def log_slow_query(duration_ms, path)
+        if defined?(Rails) && Rails.logger
+          Rails.logger.warn("BehaviorAnalytics: Slow query detected: #{path} took #{duration_ms}ms")
+        end
+      end
     end
   end
 end

data/lib/behavior_analytics/jobs/active_event_job.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+begin
+  require "active_job"
+rescue LoadError
+  raise LoadError, "ActiveJob is required for ActiveEventJob. Please add 'activejob' to your Gemfile."
+end
+
+module BehaviorAnalytics
+  module Jobs
+    class ActiveEventJob < ActiveJob::Base
+      queue_as :default
+
+      retry_on StandardError, wait: :exponentially_longer, attempts: 3
+
+      def perform(events_data, storage_adapter_class = nil)
+        storage_adapter = resolve_storage_adapter(storage_adapter_class)
+        events = events_data.map { |data| Event.new(data) }
+        storage_adapter.save_events(events)
+      rescue StandardError => e
+        Rails.logger.error("BehaviorAnalytics: Failed to process events: #{e.message}") if defined?(Rails)
+        raise
+      end
+
+      private
+
+      def resolve_storage_adapter(storage_adapter_class)
+        if storage_adapter_class
+          storage_adapter_class.constantize.new
+        else
+          BehaviorAnalytics.configuration.storage_adapter
+        end
+      end
+    end
+  end
+end
+

data/lib/behavior_analytics/jobs/delayed_event_job.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+begin
+  require "delayed_job"
+rescue LoadError
+  raise LoadError, "DelayedJob is required for DelayedEventJob. Please add 'delayed_job' to your Gemfile."
+end
+
+module BehaviorAnalytics
+  module Jobs
+    class DelayedEventJob
+      attr_reader :events_data, :storage_adapter
+
+      def initialize(events_data, storage_adapter = nil)
+        @events_data = events_data
+        @storage_adapter = storage_adapter || BehaviorAnalytics.configuration.storage_adapter
+      end
+
+      def perform
+        events = @events_data.map { |data| Event.new(data) }
+        @storage_adapter.save_events(events)
+      rescue StandardError => e
+        Delayed::Worker.logger.error("BehaviorAnalytics: Failed to process events: #{e.message}") if defined?(Delayed::Worker)
+        raise
+      end
+    end
+  end
+end
+

data/lib/behavior_analytics/jobs/sidekiq_event_job.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+begin
+  require "sidekiq"
+rescue LoadError
+  raise LoadError, "Sidekiq is required for SidekiqEventJob. Please add 'sidekiq' to your Gemfile."
+end
+
+module BehaviorAnalytics
+  module Jobs
+    class SidekiqEventJob
+      include Sidekiq::Job
+
+      sidekiq_options retry: 3, backtrace: true
+
+      def perform(events_data, storage_adapter_class = nil)
+        storage_adapter = resolve_storage_adapter(storage_adapter_class)
+        events = events_data.map { |data| Event.new(data) }
+        storage_adapter.save_events(events)
+      rescue StandardError => e
+        Sidekiq.logger.error("BehaviorAnalytics: Failed to process events: #{e.message}")
+        raise
+      end
+
+      private
+
+      def resolve_storage_adapter(storage_adapter_class)
+        if storage_adapter_class
+          storage_adapter_class.constantize.new
+        else
+          BehaviorAnalytics.configuration.storage_adapter
+        end
+      end
+    end
+  end
+end
+

data/lib/behavior_analytics/observability/metrics.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module BehaviorAnalytics
+  module Observability
+    class Metrics
+      def initialize
+        @counters = {}
+        @gauges = {}
+        @histograms = {}
+        @mutex = Mutex.new
+      end
+
+      def increment_counter(name, value: 1, tags: {})
+        @mutex.synchronize do
+          key = metric_key(name, tags)
+          @counters[key] ||= 0
+          @counters[key] += value
+        end
+      end
+
+      def set_gauge(name, value, tags: {})
+        @mutex.synchronize do
+          key = metric_key(name, tags)
+          @gauges[key] = value
+        end
+      end
+
+      def record_histogram(name, value, tags: {})
+        @mutex.synchronize do
+          key = metric_key(name, tags)
+          @histograms[key] ||= []
+          @histograms[key] << value
+          # Keep only last 1000 values
+          @histograms[key] = @histograms[key].last(1000) if @histograms[key].size > 1000
+        end
+      end
+
+      def get_counter(name, tags: {})
+        key = metric_key(name, tags)
+        @counters[key] || 0
+      end
+
+      def get_gauge(name, tags: {})
+        key = metric_key(name, tags)
+        @gauges[key]
+      end
+
+      def get_histogram_stats(name, tags: {})
+        key = metric_key(name, tags)
+        values = @histograms[key] || []
+        return {} if values.empty?
+
+        sorted = values.sort
+        {
+          count: values.size,
+          min: sorted.first,
+          max: sorted.last,
+          sum: values.sum,
+          avg: values.sum.to_f / values.size,
+          p50: percentile(sorted, 50),
+          p95: percentile(sorted, 95),
+          p99: percentile(sorted, 99)
+        }
+      end
+
+      def all_metrics
+        {
+          counters: @counters.dup,
+          gauges: @gauges.dup,
+          histograms: @histograms.keys.map { |k| [k, get_histogram_stats(*parse_key(k))] }.to_h
+        }
+      end
+
+      def reset
+        @mutex.synchronize do
+          @counters.clear
+          @gauges.clear
+          @histograms.clear
+        end
+      end
+
+      private
+
+      def metric_key(name, tags)
+        if tags.empty?
+          name.to_s
+        else
+          tag_str = tags.map { |k, v| "#{k}:#{v}" }.join(",")
+          "#{name}[#{tag_str}]"
+        end
+      end
+
+      def parse_key(key)
+        if key.include?("[")
+          name, tag_str = key.split("[", 2)
+          tag_str = tag_str.chomp("]")
+          tags = tag_str.split(",").map { |t| t.split(":") }.to_h
+          [name, tags]
+        else
+          [key, {}]
+        end
+      end
+
+      def percentile(sorted_array, percentile)
+        return nil if sorted_array.empty?
+        index = (percentile / 100.0) * (sorted_array.size - 1)
+        sorted_array[index.floor]
+      end
+    end
+  end
+end
+

data/lib/behavior_analytics/observability/tracer.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module BehaviorAnalytics
+  module Observability
+    class Tracer
+      attr_reader :correlation_id
+
+      def initialize(correlation_id: nil)
+        @correlation_id = correlation_id || generate_correlation_id
+        @spans = []
+        @mutex = Mutex.new
+      end
+
+      def start_span(name, tags: {})
+        span = {
+          id: SecureRandom.uuid,
+          name: name,
+          start_time: Time.now,
+          tags: tags,
+          correlation_id: @correlation_id
+        }
+        
+        @mutex.synchronize do
+          @spans << span
+        end
+        
+        span
+      end
+
+      def finish_span(span_id, tags: {})
+        @mutex.synchronize do
+          span = @spans.find { |s| s[:id] == span_id }
+          return unless span
+
+          span[:end_time] = Time.now
+          span[:duration_ms] = ((span[:end_time] - span[:start_time]) * 1000).to_i
+          span[:tags].merge!(tags)
+        end
+      end
+
+      def add_tags_to_span(span_id, tags)
+        @mutex.synchronize do
+          span = @spans.find { |s| s[:id] == span_id }
+          return unless span
+
+          span[:tags].merge!(tags)
+        end
+      end
+
+      def get_spans
+        @spans.dup
+      end
+
+      def get_trace
+        {
+          correlation_id: @correlation_id,
+          spans: @spans,
+          total_duration_ms: calculate_total_duration
+        }
+      end
+
+      private
+
+      def generate_correlation_id
+        "#{Time.now.to_i}-#{SecureRandom.hex(8)}"
+      end
+
+      def calculate_total_duration
+        return 0 if @spans.empty?
+
+        start_times = @spans.map { |s| s[:start_time] }.compact
+        end_times = @spans.map { |s| s[:end_time] || Time.now }.compact
+
+        return 0 if start_times.empty? || end_times.empty?
+
+        earliest_start = start_times.min
+        latest_end = end_times.max
+        ((latest_end - earliest_start) * 1000).to_i
+      end
+    end
+  end
+end
+

data/lib/behavior_analytics/processors/async_processor.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module BehaviorAnalytics
+  module Processors
+    class AsyncProcessor
+      attr_reader :storage_adapter, :queue_name, :priority
+
+      def initialize(storage_adapter:, queue_name: "default", priority: 0)
+        @storage_adapter = storage_adapter
+        @queue_name = queue_name
+        @priority = priority
+      end
+
+      def process_async(events)
+        raise NotImplementedError, "#{self.class} must implement #process_async"
+      end
+
+      def process_sync(events)
+        @storage_adapter.save_events(events)
+      end
+    end
+  end
+end
+

data/lib/behavior_analytics/processors/background_job_processor.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module BehaviorAnalytics
+  module Processors
+    class BackgroundJobProcessor < AsyncProcessor
+      JOB_CLASSES = {
+        sidekiq: "BehaviorAnalytics::Jobs::SidekiqEventJob",
+        delayed_job: "BehaviorAnalytics::Jobs::DelayedEventJob",
+        active_job: "BehaviorAnalytics::Jobs::ActiveEventJob"
+      }.freeze
+
+      def initialize(storage_adapter:, queue_name: "default", priority: 0, adapter: :active_job)
+        super(storage_adapter: storage_adapter, queue_name: queue_name, priority: priority)
+        @adapter = adapter.to_sym
+        @job_class = resolve_job_class
+      end
+
+      def process_async(events)
+        events.each_slice(100) do |batch|
+          enqueue_batch(batch)
+        end
+      end
+
+      private
+
+      def resolve_job_class
+        class_name = JOB_CLASSES[@adapter]
+        return class_name.constantize if defined?(class_name.constantize)
+
+        case @adapter
+        when :sidekiq
+          require_sidekiq
+          BehaviorAnalytics::Jobs::SidekiqEventJob
+        when :delayed_job
+          require_delayed_job
+          BehaviorAnalytics::Jobs::DelayedEventJob
+        when :active_job
+          require_active_job
+          BehaviorAnalytics::Jobs::ActiveEventJob
+        else
+          raise Error, "Unsupported job adapter: #{@adapter}"
+        end
+      end
+
+      def enqueue_batch(batch)
+        events_data = batch.map(&:to_h)
+        
+        case @adapter
+        when :sidekiq
+          @job_class.set(queue: @queue_name).perform_async(events_data)
+        when :delayed_job
+          @job_class.new(events_data, @storage_adapter).delay(queue: @queue_name).perform
+        when :active_job
+          @job_class.set(queue: @queue_name).perform_later(events_data, @storage_adapter)
+        end
+      end
+
+      def require_sidekiq
+        require "sidekiq" unless defined?(Sidekiq)
+      end
+
+      def require_delayed_job
+        require "delayed_job" unless defined?(Delayed::Job)
+      end
+
+      def require_active_job
+        require "active_job" unless defined?(ActiveJob)
+      end
+    end
+  end
+end
+