behavior_analytics 0.1.0 → 2.1.0

data/lib/behavior_analytics/schema/validator.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module BehaviorAnalytics
+  module Schema
+    class Validator
+      def initialize(schema_definition)
+        @schema = schema_definition
+      end
+
+      def validate(event)
+        errors = []
+
+        # Validate required fields
+        if @schema.required_fields
+          @schema.required_fields.each do |field|
+            unless event.key?(field.to_sym) || event.key?(field.to_s)
+              errors << "Missing required field: #{field}"
+            end
+          end
+        end
+
+        # Validate field types
+        if @schema.field_types
+          @schema.field_types.each do |field, expected_type|
+            value = event[field.to_sym] || event[field.to_s]
+            next if value.nil? # Optional fields can be nil
+
+            unless matches_type?(value, expected_type)
+              errors << "Field #{field} has wrong type. Expected #{expected_type}, got #{value.class}"
+            end
+          end
+        end
+
+        # Validate custom rules
+        if @schema.custom_rules
+          @schema.custom_rules.each do |rule|
+            result = evaluate_rule(rule, event)
+            unless result[:valid]
+              errors << result[:error] || "Validation failed for rule: #{rule}"
+            end
+          end
+        end
+
+        {
+          valid: errors.empty?,
+          errors: errors
+        }
+      end
+
+      private
+
+      def matches_type?(value, expected_type)
+        case expected_type
+        when :string
+          value.is_a?(String)
+        when :integer
+          value.is_a?(Integer)
+        when :float, :number
+          value.is_a?(Numeric)
+        when :boolean
+          value.is_a?(TrueClass) || value.is_a?(FalseClass)
+        when :hash, :object
+          value.is_a?(Hash)
+        when :array
+          value.is_a?(Array)
+        when Class
+          value.is_a?(expected_type)
+        else
+          true
+        end
+      end
+
+      def evaluate_rule(rule, event)
+        case rule
+        when Proc
+          begin
+            result = rule.call(event)
+            if result.is_a?(Hash)
+              result
+            elsif result
+              { valid: true }
+            else
+              { valid: false, error: "Rule validation failed" }
+            end
+          rescue StandardError => e
+            { valid: false, error: e.message }
+          end
+        when Hash
+          # Rule format: { field: { condition: value } }
+          rule.all? do |field, condition|
+            value = event[field.to_sym] || event[field.to_s]
+            evaluate_condition(value, condition)
+          end
+          { valid: true }
+        else
+          { valid: true }
+        end
+      end
+
+      def evaluate_condition(value, condition)
+        case condition
+        when Hash
+          condition.all? { |key, expected| evaluate_condition(value, { key => expected }) }
+        when Proc
+          condition.call(value)
+        else
+          value == condition
+        end
+      end
+    end
+  end
+end
+

data/lib/behavior_analytics/storage/active_record_adapter.rb

@@ -39,19 +39,103 @@ 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)
+        
+        # If no tenant_id, query all events (for non-multi-tenant systems)
+        # This allows tracking without tenant isolation
+        
+        # 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)
@@ -59,7 +143,55 @@ module BehaviorAnalytics
       end
 
       def event_count(context, options = {})
+        context.validate!
         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
 
@@ -83,8 +215,17 @@ module BehaviorAnalytics
       def build_base_query(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
+        # Support different business cases:
+        # - Multi-tenant: filter by tenant_id
+        # - Single-tenant: filter by user_id (tenant_id may be nil)
+        # - API-only: no filters required
+        query = @model_class.all
+        
+        if context.has_tenant?
+          query = query.where(tenant_id: context.tenant_id)
+        end
+        
+        query = query.where(user_id: context.user_id) if context.has_user?
         query = query.where(user_type: context.user_type) if context.user_type
 
         query = query.where("created_at >= ?", options[:since]) if options[:since]
@@ -105,6 +246,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,185 @@
+# 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 = []
+        
+        # Support different business cases:
+        # - Multi-tenant: filter by tenant_id
+        # - Single-tenant: filter by user_id (tenant_id may be nil)
+        # - API-only: no strict filters required
+        
+        if context.has_tenant?
+          must_clauses << { term: { tenant_id: context.tenant_id } }
+        end
+        
+        if context.has_user?
+          must_clauses << { term: { user_id: context.user_id } }
+        end
+        
+        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
+