behavior_analytics 0.1.0 → 2.1.0

data/lib/behavior_analytics/hooks/webhook.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module BehaviorAnalytics
+  module Hooks
+    class Webhook
+      attr_reader :url, :secret, :filter, :retry_count, :timeout
+
+      def initialize(url:, secret: nil, filter: nil, retry_count: 3, timeout: 5)
+        @url = URI(url)
+        @secret = secret
+        @filter = filter
+        @retry_count = retry_count
+        @timeout = timeout
+        @mutex = Mutex.new
+      end
+
+      def deliver(event, context = nil)
+        return unless should_deliver?(event)
+
+        payload = build_payload(event, context)
+        signature = generate_signature(payload) if @secret
+
+        headers = {
+          "Content-Type" => "application/json",
+          "User-Agent" => "BehaviorAnalytics/2.0"
+        }
+        headers["X-Webhook-Signature"] = signature if signature
+
+        deliver_with_retry(payload, headers)
+      end
+
+      private
+
+      def should_deliver?(event)
+        return true unless @filter
+
+        case @filter
+        when Proc
+          @filter.call(event)
+        when Hash
+          @filter.all? { |key, value| matches?(event, key, value) }
+        when Symbol, String
+          event[:event_type] == @filter || event[:event_type].to_s == @filter.to_s
+        else
+          true
+        end
+      end
+
+      def matches?(event, key, value)
+        event_value = event[key.to_sym] || event[key.to_s] || get_metadata_value(event, key.to_s)
+        event_value == value || event_value.to_s == value.to_s
+      end
+
+      def get_metadata_value(event, key)
+        metadata = event[:metadata] || event["metadata"] || {}
+        metadata[key.to_sym] || metadata[key.to_s] || metadata[key]
+      end
+
+      def build_payload(event, context)
+        {
+          event: event.is_a?(Hash) ? event : event.to_h,
+          context: context ? (context.is_a?(Hash) ? context : context.to_h) : nil,
+          timestamp: Time.now.iso8601
+        }
+      end
+
+      def generate_signature(payload)
+        require "openssl" unless defined?(OpenSSL)
+        payload_json = JSON.generate(payload)
+        OpenSSL::HMAC.hexdigest("SHA256", @secret, payload_json)
+      end
+
+      def deliver_with_retry(payload, headers)
+        last_error = nil
+        
+        (@retry_count + 1).times do |attempt|
+          begin
+            http = Net::HTTP.new(@url.host, @url.port)
+            http.use_ssl = @url.scheme == "https"
+            http.read_timeout = @timeout
+            http.open_timeout = @timeout
+
+            request = Net::HTTP::Post.new(@url.path)
+            headers.each { |key, value| request[key] = value }
+            request.body = JSON.generate(payload)
+
+            response = http.request(request)
+
+            if response.code.to_i >= 200 && response.code.to_i < 300
+              return { success: true, response_code: response.code.to_i }
+            else
+              last_error = "HTTP #{response.code}: #{response.message}"
+            end
+          rescue StandardError => e
+            last_error = e.message
+            sleep(calculate_backoff(attempt)) if attempt < @retry_count
+          end
+        end
+
+        { success: false, error: last_error }
+      end
+
+      def calculate_backoff(attempt)
+        # Exponential backoff: 1s, 2s, 4s, etc.
+        2 ** attempt
+      end
+    end
+  end
+end
+

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

@@ -70,21 +70,142 @@ module BehaviorAnalytics
             user_id: current_user&.id,
             user_type: current_user&.account_type || current_user&.user_type
           )
+        elsif respond_to?(:current_user, true)
+          # Single-tenant system - use default tenant
+          Context.new(
+            tenant_id: BehaviorAnalytics.configuration.default_tenant_id,
+            user_id: current_user&.id,
+            user_type: current_user&.account_type || current_user&.user_type
+          )
         else
-          nil
+          # No user context - use default tenant
+          Context.new(
+            tenant_id: BehaviorAnalytics.configuration.default_tenant_id
+          )
         end
       end
 
       def should_track?
         context = resolve_tracking_context
-        return false unless context&.valid?
+        # Allow tracking even without context for API-only tracking
+        # Context validation will handle required fields
+        return false if context && !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
+          # Create context if it doesn't exist (for API-only tracking)
+          context ||= Context.new(tenant_id: BehaviorAnalytics.configuration.default_tenant_id)
+          
+          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
+