behavior_analytics 0.1.0 → 2.0.0

data/lib/behavior_analytics/storage/active_record_adapter.rb

@@ -39,19 +39,100 @@ module BehaviorAnalytics
       def events_for_context(context, options = {})
         context.validate!
 
-        query = @model_class.where(tenant_id: context.tenant_id)
-        query = query.where(user_id: context.user_id) if context.user_id
-        query = query.where(user_type: context.user_type) if context.user_type
+        query = build_base_query(context, options)
+        
+        # Apply metadata filters
+        if options[:metadata_filters]
+          options[:metadata_filters].each do |key, value|
+            query = query.where("metadata->>? = ?", key, value.to_s)
+          end
+        end
 
-        query = query.where("created_at >= ?", options[:since]) if options[:since]
-        query = query.where("created_at <= ?", options[:until]) if options[:until]
-        query = query.where(event_name: options[:event_name]) if options[:event_name]
-        query = query.where(event_type: options[:event_type].to_s) if options[:event_type]
+        # Apply path filtering
+        if options[:path]
+          if column_exists?(:path)
+            query = query.where(path: options[:path])
+          else
+            query = query.where("metadata->>'path' = ?", options[:path])
+          end
+        end
+
+        if options[:path_pattern]
+          if column_exists?(:path)
+            query = query.where("path LIKE ?", options[:path_pattern])
+          else
+            query = query.where("metadata->>'path' LIKE ?", options[:path_pattern])
+          end
+        end
+
+        # Apply method filtering
+        if options[:method]
+          if column_exists?(:method)
+            query = query.where(method: options[:method])
+          else
+            query = query.where("metadata->>'method' = ?", options[:method])
+          end
+        end
+
+        # Apply status code filtering
+        if options[:status_code]
+          if column_exists?(:status_code)
+            query = query.where(status_code: options[:status_code])
+          else
+            query = query.where("metadata->>'status_code' = ?", options[:status_code].to_s)
+          end
+        end
+
+        # Apply where conditions
+        if options[:where_conditions]
+          options[:where_conditions].each do |condition|
+            if condition[:raw]
+              query = query.where(condition[:raw])
+            else
+              condition.each do |key, value|
+                next if key == :raw
+                query = query.where(key => value)
+              end
+            end
+          end
+        end
+
+        # Apply aggregations and group by
+        if options[:group_by] && !options[:group_by].empty?
+          query = apply_group_by(query, options[:group_by], options[:aggregations])
+        elsif options[:aggregations] && !options[:aggregations].empty?
+          query = apply_aggregations(query, options[:aggregations])
+        end
+
+        # Apply having conditions (after aggregation)
+        if options[:having_conditions] && (options[:group_by] || options[:aggregations])
+          options[:having_conditions].each do |condition|
+            if condition[:raw]
+              query = query.having(condition[:raw])
+            else
+              condition.each do |key, value|
+                next if key == :raw
+                query = query.having(key => value)
+              end
+            end
+          end
+        end
+
+        # Apply distinct
+        if options[:distinct]
+          query = query.distinct(options[:distinct])
+        end
 
         query = apply_order_by(query, options[:order_by]) if options[:order_by]
         query = query.limit(options[:limit]) if options[:limit]
 
-        query.map(&:to_h)
+        # Handle aggregations - return hash instead of array
+        if options[:aggregations] && !options[:aggregations].empty? && options[:group_by].nil?
+          result = query.first
+          result ? result.attributes.symbolize_keys : {}
+        else
+          query.map(&:to_h)
+        end
       end
 
       def delete_old_events(before_date)
@@ -60,6 +141,53 @@ module BehaviorAnalytics
 
       def event_count(context, options = {})
         query = build_base_query(context, options)
+        
+        # Apply metadata filters
+        if options[:metadata_filters]
+          options[:metadata_filters].each do |key, value|
+            query = query.where("metadata->>? = ?", key, value.to_s)
+          end
+        end
+
+        # Apply path/method/status_code filters
+        if options[:path]
+          if column_exists?(:path)
+            query = query.where(path: options[:path])
+          else
+            query = query.where("metadata->>'path' = ?", options[:path])
+          end
+        end
+
+        if options[:method]
+          if column_exists?(:method)
+            query = query.where(method: options[:method])
+          else
+            query = query.where("metadata->>'method' = ?", options[:method])
+          end
+        end
+
+        if options[:status_code]
+          if column_exists?(:status_code)
+            query = query.where(status_code: options[:status_code])
+          else
+            query = query.where("metadata->>'status_code' = ?", options[:status_code].to_s)
+          end
+        end
+
+        # Apply where conditions
+        if options[:where_conditions]
+          options[:where_conditions].each do |condition|
+            if condition[:raw]
+              query = query.where(condition[:raw])
+            else
+              condition.each do |key, value|
+                next if key == :raw
+                query = query.where(key => value)
+              end
+            end
+          end
+        end
+
         query.count
       end
 
@@ -105,6 +233,38 @@ module BehaviorAnalytics
           query.order(created_at: direction)
         end
       end
+
+      def apply_group_by(query, group_by_fields, aggregations = [])
+        query = query.group(group_by_fields.map(&:to_sym))
+        
+        if aggregations && !aggregations.empty?
+          select_clause = group_by_fields.map { |f| "#{f} as #{f}" }
+          aggregations.each do |agg|
+            field = agg[:field]
+            func = agg[:function]
+            select_clause << "#{func.upcase}(#{field}) as #{func}_#{field}"
+          end
+          query = query.select(select_clause.join(", "))
+        else
+          query = query.select(group_by_fields.map { |f| "#{f} as #{f}" }.join(", "))
+        end
+        
+        query
+      end
+
+      def apply_aggregations(query, aggregations)
+        select_clause = []
+        aggregations.each do |agg|
+          field = agg[:field]
+          func = agg[:function]
+          select_clause << "#{func.upcase}(#{field}) as #{func}_#{field}"
+        end
+        query.select(select_clause.join(", "))
+      end
+
+      def column_exists?(column_name)
+        @model_class.column_names.include?(column_name.to_s)
+      end
     end
   end
 end

data/lib/behavior_analytics/storage/elasticsearch_adapter.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+begin
+  require "elasticsearch"
+rescue LoadError
+  raise LoadError, "Elasticsearch gem is required for ElasticsearchAdapter. Please add 'elasticsearch' to your Gemfile."
+end
+
+module BehaviorAnalytics
+  module Storage
+    class ElasticsearchAdapter < Adapter
+      def initialize(client: nil, index_name: "behavior_events")
+        @client = client || Elasticsearch::Client.new
+        @index_name = index_name
+        ensure_index_exists
+      end
+
+      def save_events(events)
+        return if events.empty?
+
+        body = events.map do |event|
+          event_hash = event.is_a?(Hash) ? event : event.to_h
+          {
+            index: {
+              _index: @index_name,
+              _id: event_hash[:id] || SecureRandom.uuid,
+              _type: "_doc",
+              data: event_hash
+            }
+          }
+        end
+
+        @client.bulk(body: body)
+      rescue StandardError => e
+        raise Error, "Failed to save events to Elasticsearch: #{e.message}"
+      end
+
+      def events_for_context(context, options = {})
+        context.validate!
+
+        query = build_query(context, options)
+        
+        response = @client.search(
+          index: @index_name,
+          body: {
+            query: query,
+            sort: build_sort(options[:order_by]),
+            size: options[:limit] || 100
+          }
+        )
+
+        response["hits"]["hits"].map { |hit| hit["_source"].symbolize_keys }
+      end
+
+      def delete_old_events(before_date)
+        @client.delete_by_query(
+          index: @index_name,
+          body: {
+            query: {
+              range: {
+                created_at: {
+                  lt: before_date.iso8601
+                }
+              }
+            }
+          }
+        )
+      end
+
+      def event_count(context, options = {})
+        context.validate!
+        query = build_query(context, options)
+        
+        response = @client.count(
+          index: @index_name,
+          body: { query: query }
+        )
+        
+        response["count"]
+      end
+
+      def unique_users(context, options = {})
+        context.validate!
+        query = build_query(context, options)
+        
+        response = @client.search(
+          index: @index_name,
+          body: {
+            query: query,
+            aggs: {
+              unique_users: {
+                cardinality: {
+                  field: "user_id"
+                }
+              }
+            },
+            size: 0
+          }
+        )
+        
+        response["aggregations"]["unique_users"]["value"]
+      end
+
+      private
+
+      def ensure_index_exists
+        return if @client.indices.exists?(index: @index_name)
+        
+        @client.indices.create(
+          index: @index_name,
+          body: {
+            mappings: {
+              properties: {
+                tenant_id: { type: "keyword" },
+                user_id: { type: "keyword" },
+                user_type: { type: "keyword" },
+                event_name: { type: "keyword" },
+                event_type: { type: "keyword" },
+                metadata: { type: "object" },
+                created_at: { type: "date" }
+              }
+            }
+          }
+        )
+      end
+
+      def build_query(context, options)
+        must_clauses = [
+          { term: { tenant_id: context.tenant_id } }
+        ]
+        
+        must_clauses << { term: { user_id: context.user_id } } if context.user_id
+        must_clauses << { term: { user_type: context.user_type } } if context.user_type
+        must_clauses << { term: { event_name: options[:event_name] } } if options[:event_name]
+        must_clauses << { term: { event_type: options[:event_type].to_s } } if options[:event_type]
+        
+        if options[:since] || options[:until]
+          range_clause = {}
+          range_clause[:gte] = options[:since].iso8601 if options[:since]
+          range_clause[:lte] = options[:until].iso8601 if options[:until]
+          must_clauses << { range: { created_at: range_clause } }
+        end
+        
+        if options[:metadata_filters]
+          options[:metadata_filters].each do |key, value|
+            must_clauses << { term: { "metadata.#{key}" => value } }
+          end
+        end
+        
+        if options[:path]
+          must_clauses << { term: { "metadata.path" => options[:path] } }
+        end
+        
+        if options[:method]
+          must_clauses << { term: { "metadata.method" => options[:method] } }
+        end
+        
+        if options[:status_code]
+          must_clauses << { term: { "metadata.status_code" => options[:status_code] } }
+        end
+        
+        { bool: { must: must_clauses } }
+      end
+
+      def build_sort(order_by)
+        return [{ created_at: { order: "desc" } }] unless order_by
+        
+        field = order_by[:field]
+        direction = order_by[:direction] || :desc
+        [{ field => { order: direction.to_s } }]
+      end
+    end
+  end
+end
+

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
 
-        events = events.sort_by { |e| e[:created_at] }.reverse
+        # 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
+
+        # 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 = {})
@@ -76,6 +166,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