behavior_analytics 0.1.0 → 2.1.0

data/lib/behavior_analytics/storage/in_memory_adapter.rb

@@ -21,8 +21,70 @@ module BehaviorAnalytics
         events = filter_by_date_range(events, options[:since], options[:until]) if options[:since] || options[:until]
         events = filter_by_event_name(events, options[:event_name]) if options[:event_name]
         events = filter_by_event_type(events, options[:event_type]) if options[:event_type]
+        
+        # Apply metadata filters
+        if options[:metadata_filters]
+          events = filter_by_metadata(events, options[:metadata_filters])
+        end
+
+        # Apply path filtering
+        if options[:path]
+          events = events.select { |e| get_metadata_value(e, "path") == options[:path] }
+        end
+
+        if options[:path_pattern]
+          pattern = Regexp.new(options[:path_pattern].gsub('%', '.*'))
+          events = events.select { |e| path = get_metadata_value(e, "path"); path && pattern.match?(path) }
+        end
+
+        # Apply method filtering
+        if options[:method]
+          events = events.select { |e| get_metadata_value(e, "method")&.upcase == options[:method].upcase }
+        end
+
+        # Apply status code filtering
+        if options[:status_code]
+          events = events.select { |e| get_metadata_value(e, "status_code")&.to_s == options[:status_code].to_s }
+        end
+
+        # Apply where conditions
+        if options[:where_conditions]
+          events = apply_where_conditions(events, options[:where_conditions])
+        end
+
+        # Apply aggregations and group by
+        if options[:group_by] && !options[:group_by].empty?
+          return apply_group_by(events, options[:group_by], options[:aggregations])
+        elsif options[:aggregations] && !options[:aggregations].empty?
+          return apply_aggregations(events, options[:aggregations])
+        end
+
+        # Apply having conditions (after aggregation - handled in group_by/aggregations)
+        # Note: In-memory adapter applies having before returning grouped results
+
+        # Apply distinct
+        if options[:distinct]
+          seen = {}
+          events = events.select do |e|
+            value = get_field_value(e, options[:distinct])
+            key = value.to_s
+            if seen[key]
+              false
+            else
+              seen[key] = true
+              true
+            end
+          end
+        end
 
-        events = events.sort_by { |e| e[:created_at] }.reverse
+        # Apply order by
+        if options[:order_by]
+          events = apply_order_by(events, options[:order_by])
+        else
+          events = events.sort_by { |e| e[:created_at] || Time.at(0) }.reverse
+        end
+
+        # Apply limit
         events = events.first(options[:limit]) if options[:limit]
 
         events
@@ -35,7 +97,35 @@ module BehaviorAnalytics
       end
 
       def event_count(context, options = {})
-        events_for_context(context, options).count
+        # For count, we don't need aggregations/group_by, so use simplified version
+        context.validate!
+        events = filter_by_context(@events, context)
+
+        events = filter_by_date_range(events, options[:since], options[:until]) if options[:since] || options[:until]
+        events = filter_by_event_name(events, options[:event_name]) if options[:event_name]
+        events = filter_by_event_type(events, options[:event_type]) if options[:event_type]
+        
+        if options[:metadata_filters]
+          events = filter_by_metadata(events, options[:metadata_filters])
+        end
+
+        if options[:path]
+          events = events.select { |e| get_metadata_value(e, "path") == options[:path] }
+        end
+
+        if options[:method]
+          events = events.select { |e| get_metadata_value(e, "method")&.upcase == options[:method].upcase }
+        end
+
+        if options[:status_code]
+          events = events.select { |e| get_metadata_value(e, "status_code")&.to_s == options[:status_code].to_s }
+        end
+
+        if options[:where_conditions]
+          events = apply_where_conditions(events, options[:where_conditions])
+        end
+
+        events.count
       end
 
       def unique_users(context, options = {})
@@ -53,9 +143,26 @@ module BehaviorAnalytics
 
       def filter_by_context(events, context)
         events.select do |event|
-          matches_tenant = event[:tenant_id] == context.tenant_id
-          matches_user = context.user_id.nil? || event[:user_id] == context.user_id || event[:user_id].nil?
-          matches_user_type = context.user_type.nil? || event[:user_type] == context.user_type || event[:user_type].nil?
+          # Support different business cases:
+          # - Multi-tenant: must match tenant_id
+          # - Single-tenant: match user_id (tenant_id may be nil)
+          # - API-only: no strict matching required
+          
+          matches_tenant = if context.has_tenant?
+            event[:tenant_id] == context.tenant_id
+          else
+            true # No tenant filter if context doesn't have tenant
+          end
+          
+          matches_user = if context.has_user?
+            event[:user_id] == context.user_id
+          else
+            true # No user filter if context doesn't have user
+          end
+          
+          matches_user_type = context.user_type.nil? || 
+                              event[:user_type] == context.user_type || 
+                              event[:user_type].nil?
           
           matches_tenant && matches_user && matches_user_type
         end
@@ -76,6 +183,128 @@ module BehaviorAnalytics
         event_type_sym = event_type.is_a?(Symbol) ? event_type : event_type.to_sym
         events.select { |e| e[:event_type] == event_type_sym || e[:event_type].to_sym == event_type_sym }
       end
+
+      def filter_by_metadata(events, metadata_filters)
+        events.select do |event|
+          metadata_filters.all? do |key, value|
+            get_metadata_value(event, key) == value || get_metadata_value(event, key).to_s == value.to_s
+          end
+        end
+      end
+
+      def get_metadata_value(event, key)
+        metadata = event[:metadata] || event["metadata"] || {}
+        metadata[key.to_sym] || metadata[key.to_s] || metadata[key]
+      end
+
+      def get_field_value(event, field)
+        event[field.to_sym] || event[field.to_s] || event[field]
+      end
+
+      def apply_where_conditions(events, where_conditions)
+        where_conditions.reduce(events) do |filtered, condition|
+          if condition[:raw]
+            # For raw conditions, we'd need to evaluate them - simplified version
+            # In production, you might want to use a proper expression evaluator
+            filtered
+          else
+            condition.reduce(filtered) do |result, (key, value)|
+              next result if key == :raw
+              result.select { |e| get_field_value(e, key) == value }
+            end
+          end
+        end
+      end
+
+      def apply_group_by(events, group_by_fields, aggregations = [])
+        grouped = events.group_by do |event|
+          group_by_fields.map { |field| get_field_value(event, field) }
+        end
+
+        if aggregations && !aggregations.empty?
+          grouped.map do |keys, group_events|
+            result = {}
+            group_by_fields.each_with_index do |field, idx|
+              result[field.to_sym] = keys[idx]
+            end
+            aggregations.each do |agg|
+              field = agg[:field]
+              func = agg[:function]
+              values = group_events.map { |e| get_field_value(e, field) }.compact
+              result["#{func}_#{field}".to_sym] = case func
+              when "sum"
+                values.sum { |v| v.is_a?(Numeric) ? v : 0 }
+              when "avg", "average"
+                values.empty? ? 0 : values.sum { |v| v.is_a?(Numeric) ? v : 0 }.to_f / values.size
+              when "min"
+                values.min
+              when "max"
+                values.max
+              when "count"
+                values.size
+              else
+                values.size
+              end
+            end
+            result
+          end
+        else
+          grouped.map do |keys, group_events|
+            result = {}
+            group_by_fields.each_with_index do |field, idx|
+              result[field.to_sym] = keys[idx]
+            end
+            result[:count] = group_events.size
+            result
+          end
+        end
+      end
+
+      def apply_aggregations(events, aggregations)
+        result = {}
+        aggregations.each do |agg|
+          field = agg[:field]
+          func = agg[:function]
+          values = events.map { |e| get_field_value(e, field) }.compact
+          result["#{func}_#{field}".to_sym] = case func
+          when "sum"
+            values.sum { |v| v.is_a?(Numeric) ? v : 0 }
+          when "avg", "average"
+            values.empty? ? 0 : values.sum { |v| v.is_a?(Numeric) ? v : 0 }.to_f / values.size
+          when "min"
+            values.min
+          when "max"
+            values.max
+          when "count"
+            values.size
+          else
+            values.size
+          end
+        end
+        [result]
+      end
+
+      def apply_order_by(events, order_by)
+        field = order_by[:field]
+        direction = order_by[:direction] || :desc
+        
+        events.sort do |a, b|
+          a_val = get_field_value(a, field)
+          b_val = get_field_value(b, field)
+          
+          comparison = if a_val.nil? && b_val.nil?
+            0
+          elsif a_val.nil?
+            1
+          elsif b_val.nil?
+            -1
+          else
+            a_val <=> b_val
+          end
+          
+          direction == :desc ? -comparison : comparison
+        end
+      end
     end
   end
 end

data/lib/behavior_analytics/storage/kafka_adapter.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+begin
+  require "ruby-kafka"
+rescue LoadError
+  raise LoadError, "ruby-kafka gem is required for KafkaAdapter. Please add 'ruby-kafka' to your Gemfile."
+end
+
+module BehaviorAnalytics
+  module Storage
+    class KafkaAdapter < Adapter
+      def initialize(kafka: nil, topic: "behavior_events", producer: nil)
+        @kafka = kafka || Kafka.new(seed_brokers: ["localhost:9092"])
+        @topic = topic
+        @producer = producer || @kafka.producer
+      end
+
+      def save_events(events)
+        return if events.empty?
+
+        events.each do |event|
+          event_hash = event.is_a?(Hash) ? event : event.to_h
+          key = event_hash[:tenant_id] || "default"
+          value = serialize_event(event_hash)
+          
+          @producer.produce(value, topic: @topic, key: key)
+        end
+        
+        @producer.deliver_messages
+      rescue StandardError => e
+        raise Error, "Failed to save events to Kafka: #{e.message}"
+      end
+
+      def events_for_context(context, options = {})
+        context.validate!
+        
+        # Kafka is primarily for streaming, so we need a consumer
+        # This is a simplified version - in production you'd use a proper consumer group
+        group_id = if context.has_tenant?
+          "behavior_analytics_#{context.tenant_id}"
+        elsif context.has_user?
+          "behavior_analytics_user_#{context.user_id}"
+        else
+          "behavior_analytics_global"
+        end
+        
+        consumer = @kafka.consumer(group_id: group_id)
+        consumer.subscribe(@topic)
+        
+        events = []
+        timeout = options[:timeout] || 5
+        
+        begin
+          consumer.each_message(max_wait_time: timeout) do |message|
+            event = deserialize_event(message.value)
+            
+            if matches_context?(event, context, options)
+              events << event
+              break if options[:limit] && events.size >= options[:limit]
+            end
+          end
+        rescue Kafka::Error
+          # Timeout or other Kafka errors
+        ensure
+          consumer.stop
+        end
+        
+        events
+      end
+
+      def delete_old_events(before_date)
+        # Kafka doesn't support deletion of old messages directly
+        # Messages are retained based on retention policy
+        # This is a no-op for Kafka
+      end
+
+      def event_count(context, options = {})
+        events_for_context(context, options).count
+      end
+
+      def unique_users(context, options = {})
+        events = events_for_context(context, options)
+        events.map { |e| e[:user_id] }.compact.uniq.count
+      end
+
+      private
+
+      def serialize_event(event_hash)
+        require "json"
+        JSON.generate(event_hash)
+      end
+
+      def deserialize_event(data)
+        require "json"
+        JSON.parse(data, symbolize_names: true)
+      end
+
+      def matches_context?(event, context, options)
+        # Support different business cases
+        if context.has_tenant?
+          return false unless event[:tenant_id] == context.tenant_id
+        end
+        
+        if context.has_user?
+          return false unless event[:user_id] == context.user_id
+        end
+        
+        return false if context.user_type && event[:user_type] != context.user_type
+        return false if options[:event_name] && event[:event_name] != options[:event_name]
+        return false if options[:event_type] && event[:event_type] != options[:event_type]
+        
+        if options[:since]
+          event_time = Time.parse(event[:created_at].to_s)
+          return false if event_time < options[:since]
+        end
+        
+        if options[:until]
+          event_time = Time.parse(event[:created_at].to_s)
+          return false if event_time > options[:until]
+        end
+        
+        true
+      end
+    end
+  end
+end
+

data/lib/behavior_analytics/storage/redis_adapter.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+begin
+  require "redis"
+rescue LoadError
+  raise LoadError, "Redis gem is required for RedisAdapter. Please add 'redis' to your Gemfile."
+end
+
+module BehaviorAnalytics
+  module Storage
+    class RedisAdapter < Adapter
+      def initialize(redis: nil, key_prefix: "behavior_analytics", ttl: nil)
+        @redis = redis || Redis.new
+        @key_prefix = key_prefix
+        @ttl = ttl
+      end
+
+      def save_events(events)
+        return if events.empty?
+
+        events.each do |event|
+          event_hash = event.is_a?(Hash) ? event : event.to_h
+          key = event_key(event_hash)
+          @redis.setex(key, @ttl || 86400, serialize_event(event_hash))
+          
+          # Add to index sets
+          index_event(event_hash)
+        end
+      rescue StandardError => e
+        raise Error, "Failed to save events to Redis: #{e.message}"
+      end
+
+      def events_for_context(context, options = {})
+        context.validate!
+
+        # Get event IDs from index
+        event_ids = find_event_ids(context, options)
+        
+        # Fetch events
+        events = event_ids.map do |id|
+          deserialize_event(@redis.get("#{@key_prefix}:event:#{id}"))
+        end.compact
+
+        # Apply filters that can't be done in Redis
+        events = filter_events(events, context, options)
+        
+        # Apply limit and ordering
+        events = sort_events(events, options[:order_by]) if options[:order_by]
+        events = events.first(options[:limit]) if options[:limit]
+
+        events
+      end
+
+      def delete_old_events(before_date)
+        # Redis TTL handles expiration, but we can also scan and delete
+        pattern = "#{@key_prefix}:event:*"
+        @redis.scan_each(match: pattern) do |key|
+          event = deserialize_event(@redis.get(key))
+          if event && event[:created_at] && Time.parse(event[:created_at].to_s) < before_date
+            @redis.del(key)
+            remove_from_indexes(event)
+          end
+        end
+      end
+
+      def event_count(context, options = {})
+        context.validate!
+        find_event_ids(context, options).count
+      end
+
+      def unique_users(context, options = {})
+        context.validate!
+        event_ids = find_event_ids(context, options)
+        events = event_ids.map { |id| deserialize_event(@redis.get("#{@key_prefix}:event:#{id}")) }.compact
+        events.map { |e| e[:user_id] }.compact.uniq.count
+      end
+
+      private
+
+      def event_key(event_hash)
+        id = event_hash[:id] || SecureRandom.uuid
+        "#{@key_prefix}:event:#{id}"
+      end
+
+      def serialize_event(event_hash)
+        require "json"
+        JSON.generate(event_hash)
+      end
+
+      def deserialize_event(data)
+        return nil unless data
+        require "json"
+        JSON.parse(data, symbolize_names: true)
+      end
+
+      def index_event(event_hash)
+        tenant_id = event_hash[:tenant_id]
+        user_id = event_hash[:user_id]
+        event_type = event_hash[:event_type]
+        
+        # Index by tenant if present (multi-tenant)
+        @redis.sadd("#{@key_prefix}:tenant:#{tenant_id}", event_hash[:id]) if tenant_id
+        
+        # Index by user if present (single-tenant or multi-tenant)
+        @redis.sadd("#{@key_prefix}:user:#{user_id}", event_hash[:id]) if user_id
+        
+        # Index by event type
+        @redis.sadd("#{@key_prefix}:type:#{event_type}", event_hash[:id]) if event_type
+      end
+
+      def remove_from_indexes(event_hash)
+        tenant_id = event_hash[:tenant_id]
+        user_id = event_hash[:user_id]
+        event_type = event_hash[:event_type]
+        
+        @redis.srem("#{@key_prefix}:tenant:#{tenant_id}", event_hash[:id])
+        @redis.srem("#{@key_prefix}:user:#{user_id}", event_hash[:id]) if user_id
+        @redis.srem("#{@key_prefix}:type:#{event_type}", event_hash[:id]) if event_type
+      end
+
+      def find_event_ids(context, options)
+        # Support different business cases:
+        # - Multi-tenant: use tenant index
+        # - Single-tenant: use user index
+        # - API-only: use event type or all events
+        
+        if context.has_tenant?
+          # Start with tenant index
+          ids = @redis.smembers("#{@key_prefix}:tenant:#{context.tenant_id}").to_a
+        elsif context.has_user?
+          # Use user index for single-tenant systems
+          ids = @redis.smembers("#{@key_prefix}:user:#{context.user_id}").to_a
+        else
+          # API-only or anonymous tracking - start with all or event type
+          if options[:event_type]
+            ids = @redis.smembers("#{@key_prefix}:type:#{options[:event_type]}").to_a
+          else
+            # Get all event IDs (scan all keys - less efficient but supports API-only tracking)
+            ids = []
+            @redis.scan_each(match: "#{@key_prefix}:event:*") do |key|
+              ids << key.split(":").last
+            end
+          end
+        end
+        
+        # Intersect with user index if specified (in addition to tenant)
+        if context.has_tenant? && context.has_user?
+          user_ids = @redis.smembers("#{@key_prefix}:user:#{context.user_id}").to_a
+          ids = ids & user_ids
+        end
+        
+        # Intersect with event type if specified
+        if options[:event_type] && context.has_tenant?
+          type_ids = @redis.smembers("#{@key_prefix}:type:#{options[:event_type]}").to_a
+          ids = ids & type_ids
+        end
+        
+        ids
+      end
+
+      def filter_events(events, context, options)
+        events.select do |event|
+          matches = true
+          
+          # Tenant matching (if context has tenant)
+          if context.has_tenant?
+            matches &&= event[:tenant_id] == context.tenant_id
+          end
+          
+          # User matching (if context has user)
+          if context.has_user?
+            matches &&= event[:user_id] == context.user_id
+          end
+          
+          matches &&= event[:user_type] == context.user_type if context.user_type
+          matches &&= event[:event_name] == options[:event_name] if options[:event_name]
+          
+          if options[:since]
+            matches &&= Time.parse(event[:created_at].to_s) >= options[:since]
+          end
+          
+          if options[:until]
+            matches &&= Time.parse(event[:created_at].to_s) <= options[:until]
+          end
+          
+          if options[:metadata_filters]
+            options[:metadata_filters].each do |key, value|
+              metadata = event[:metadata] || {}
+              matches &&= (metadata[key.to_sym] == value || metadata[key.to_s] == value)
+            end
+          end
+          
+          matches
+        end
+      end
+
+      def sort_events(events, order_by)
+        field = order_by[:field]
+        direction = order_by[:direction] || :desc
+        
+        events.sort do |a, b|
+          a_val = a[field.to_sym] || a[field.to_s]
+          b_val = b[field.to_sym] || b[field.to_s]
+          comparison = (a_val <=> b_val) || 0
+          direction == :desc ? -comparison : comparison
+        end
+      end
+    end
+  end
+end
+

data/lib/behavior_analytics/streaming/event_stream.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module BehaviorAnalytics
+  module Streaming
+    class EventStream
+      attr_reader :subscribers, :filters
+
+      def initialize
+        @subscribers = []
+        @filters = []
+        @mutex = Mutex.new
+      end
+
+      def subscribe(filter: nil, &block)
+        @mutex.synchronize do
+          @subscribers << { filter: filter, callback: block }
+        end
+        self
+      end
+
+      def publish(event)
+        @mutex.synchronize do
+          @subscribers.each do |subscriber|
+            if should_deliver?(event, subscriber[:filter])
+              begin
+                subscriber[:callback].call(event)
+              rescue StandardError => e
+                handle_subscriber_error(e, event, subscriber)
+              end
+            end
+          end
+        end
+      end
+
+      def unsubscribe_all
+        @mutex.synchronize do
+          @subscribers.clear
+        end
+      end
+
+      private
+
+      def should_deliver?(event, filter)
+        return true unless filter
+
+        case filter
+        when Proc
+          filter.call(event)
+        when Hash
+          filter.all? { |key, value| event_matches?(event, key, value) }
+        when Symbol, String
+          event[:event_type] == filter || event[:event_type].to_s == filter.to_s
+        else
+          true
+        end
+      end
+
+      def event_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 handle_subscriber_error(error, event, subscriber)
+        # Log error but don't stop other subscribers
+        if defined?(Rails) && Rails.logger
+          Rails.logger.error("BehaviorAnalytics: Subscriber error: #{error.message}")
+        end
+      end
+    end
+  end
+end
+