behavior_analytics 0.1.0 → 2.0.0

data/lib/behavior_analytics/query.rb

@@ -6,6 +6,11 @@ module BehaviorAnalytics
       @storage_adapter = storage_adapter
       @context = nil
       @options = {}
+      @metadata_filters = {}
+      @aggregations = []
+      @group_by_fields = []
+      @where_conditions = []
+      @having_conditions = []
     end
 
     def for_tenant(tenant_id)
@@ -60,14 +65,94 @@ module BehaviorAnalytics
       self
     end
 
+    # Metadata querying methods
+    def with_metadata(key, value)
+      @metadata_filters[key.to_s] = value
+      self
+    end
+
+    def with_path(path)
+      @options[:path] = path
+      self
+    end
+
+    def with_path_pattern(pattern)
+      @options[:path_pattern] = pattern
+      self
+    end
+
+    def with_method(method)
+      @options[:method] = method.to_s.upcase
+      self
+    end
+
+    def with_status_code(code)
+      @options[:status_code] = code
+      self
+    end
+
+    # Aggregation methods
+    def group_by(field)
+      @group_by_fields << field.to_s
+      self
+    end
+
+    def aggregate(function, field)
+      @aggregations << { function: function.to_s.downcase, field: field.to_s }
+      self
+    end
+
+    def distinct(field)
+      @options[:distinct] = field.to_s
+      self
+    end
+
+    # Advanced filtering
+    def where(conditions)
+      if conditions.is_a?(Hash)
+        @where_conditions << conditions
+      else
+        @where_conditions << { raw: conditions }
+      end
+      self
+    end
+
+    def having(conditions)
+      if conditions.is_a?(Hash)
+        @having_conditions << conditions
+      else
+        @having_conditions << { raw: conditions }
+      end
+      self
+    end
+
+    def join(relation)
+      @options[:join] = relation
+      self
+    end
+
     def execute
       raise Error, "Context must have tenant_id" unless @context&.valid?
-      @storage_adapter.events_for_context(@context, @options)
+      
+      # Merge metadata filters and other options
+      final_options = @options.dup
+      final_options[:metadata_filters] = @metadata_filters unless @metadata_filters.empty?
+      final_options[:aggregations] = @aggregations unless @aggregations.empty?
+      final_options[:group_by] = @group_by_fields unless @group_by_fields.empty?
+      final_options[:where_conditions] = @where_conditions unless @where_conditions.empty?
+      final_options[:having_conditions] = @having_conditions unless @having_conditions.empty?
+      
+      @storage_adapter.events_for_context(@context, final_options)
     end
 
     def count
       raise Error, "Context must have tenant_id" unless @context&.valid?
-      @storage_adapter.event_count(@context, @options)
+      
+      final_options = @options.dup
+      final_options[:metadata_filters] = @metadata_filters unless @metadata_filters.empty?
+      final_options[:where_conditions] = @where_conditions unless @where_conditions.empty?
+      
+      @storage_adapter.event_count(@context, final_options)
     end
 
     private

data/lib/behavior_analytics/replay/engine.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module BehaviorAnalytics
+  module Replay
+    class Engine
+      def initialize(source_adapter, target_adapter = nil)
+        @source_adapter = source_adapter
+        @target_adapter = target_adapter || source_adapter
+      end
+
+      def replay(context, options = {})
+        context.validate!
+
+        since = options[:since]
+        until_date = options[:until]
+        event_types = options[:event_types]
+        event_names = options[:event_names]
+        transformation = options[:transformation]
+
+        # Get events from source
+        events = @source_adapter.events_for_context(context, {
+          since: since,
+          until: until_date,
+          event_type: event_types&.first,
+          event_name: event_names&.first
+        })
+
+        # Apply additional filters
+        events = filter_events(events, event_types, event_names)
+
+        # Apply transformation if provided
+        if transformation
+          events = events.map { |event| apply_transformation(event, transformation) }
+        end
+
+        # Save to target adapter
+        if @target_adapter != @source_adapter
+          events_to_save = events.map { |e| Event.new(e) }
+          @target_adapter.save_events(events_to_save)
+        end
+
+        {
+          replayed_count: events.size,
+          source_adapter: @source_adapter.class.name,
+          target_adapter: @target_adapter.class.name
+        }
+      end
+
+      def replay_with_batch(context, options = {})
+        context.validate!
+
+        batch_size = options[:batch_size] || 1000
+        results = []
+
+        # Process in batches
+        offset = 0
+        loop do
+          batch_options = options.merge(limit: batch_size, offset: offset)
+          batch = @source_adapter.events_for_context(context, batch_options)
+
+          break if batch.empty?
+
+          result = replay(context, options.merge(events: batch))
+          results << result
+
+          offset += batch_size
+          break if batch.size < batch_size
+        end
+
+        {
+          total_batches: results.size,
+          total_replayed: results.sum { |r| r[:replayed_count] },
+          batches: results
+        }
+      end
+
+      private
+
+      def filter_events(events, event_types, event_names)
+        events.select do |event|
+          matches = true
+          matches &&= event_types.include?(event[:event_type]) if event_types && !event_types.empty?
+          matches &&= event_names.include?(event[:event_name]) if event_names && !event_names.empty?
+          matches
+        end
+      end
+
+      def apply_transformation(event, transformation)
+        case transformation
+        when Proc
+          transformation.call(event)
+        when Hash
+          event.merge(transformation)
+        when Symbol, String
+          # Assume it's a method name
+          if event.respond_to?(transformation)
+            event.send(transformation)
+          else
+            event
+          end
+        else
+          event
+        end
+      end
+    end
+  end
+end
+

data/lib/behavior_analytics/replay/processor.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module BehaviorAnalytics
+  module Replay
+    class Processor
+      def initialize(storage_adapter)
+        @storage_adapter = storage_adapter
+      end
+
+      def reprocess(context, options = {})
+        context.validate!
+
+        pipeline = options[:pipeline] || []
+        since = options[:since]
+        until_date = options[:until]
+
+        # Get events
+        events = @storage_adapter.events_for_context(context, {
+          since: since,
+          until: until_date
+        })
+
+        # Apply pipeline transformations
+        processed_events = events
+        pipeline.each do |step|
+          processed_events = apply_pipeline_step(processed_events, step)
+        end
+
+        # Save processed events back
+        if options[:save_results]
+          events_to_save = processed_events.map { |e| Event.new(e) }
+          @storage_adapter.save_events(events_to_save)
+        end
+
+        {
+          original_count: events.size,
+          processed_count: processed_events.size,
+          pipeline_steps: pipeline.size
+        }
+      end
+
+      def enrich_events(context, enrichment_data, options = {})
+        context.validate!
+
+        since = options[:since]
+        until_date = options[:until]
+
+        events = @storage_adapter.events_for_context(context, {
+          since: since,
+          until: until_date
+        })
+
+        enriched_events = events.map do |event|
+          enriched = event.dup
+          
+          enrichment_data.each do |key, value|
+            if value.is_a?(Proc)
+              enriched[key] = value.call(event)
+            elsif value.is_a?(Hash)
+              # Merge nested hash
+              enriched[key] = (enriched[key] || {}).merge(value)
+            else
+              enriched[key] = value
+            end
+          end
+
+          enriched
+        end
+
+        if options[:save_results]
+          events_to_save = enriched_events.map { |e| Event.new(e) }
+          @storage_adapter.save_events(events_to_save)
+        end
+
+        {
+          enriched_count: enriched_events.size
+        }
+      end
+
+      private
+
+      def apply_pipeline_step(events, step)
+        case step
+        when Proc
+          events.map { |e| step.call(e) }.compact
+        when Hash
+          # Apply multiple transformations
+          step.reduce(events) do |result, (key, value)|
+            result.map do |event|
+              if value.is_a?(Proc)
+                event.merge(key => value.call(event))
+              else
+                event.merge(key => value)
+              end
+            end
+          end
+        when Symbol, String
+          # Assume it's a filter or transformation method
+          events.select { |e| e.respond_to?(step) ? e.send(step) : true }
+        else
+          events
+        end
+      end
+    end
+  end
+end
+

data/lib/behavior_analytics/reporting/generator.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module BehaviorAnalytics
+  module Reporting
+    class Generator
+      def initialize(storage_adapter)
+        @storage_adapter = storage_adapter
+        @analytics = Analytics::Engine.new(storage_adapter)
+      end
+
+      def generate_report(context, report_type, options = {})
+        context.validate!
+
+        case report_type.to_sym
+        when :summary
+          generate_summary_report(context, options)
+        when :activity
+          generate_activity_report(context, options)
+        when :engagement
+          generate_engagement_report(context, options)
+        when :feature_usage
+          generate_feature_usage_report(context, options)
+        else
+          raise Error, "Unknown report type: #{report_type}"
+        end
+      end
+
+      def schedule_report(context, report_type, schedule, options = {})
+        # This would integrate with a job scheduler
+        # For now, return a report configuration
+        {
+          context: context.to_h,
+          report_type: report_type,
+          schedule: schedule,
+          options: options,
+          created_at: Time.now
+        }
+      end
+
+      private
+
+      def generate_summary_report(context, options)
+        date_range = options[:date_range] || (options[:since]..options[:until])
+        
+        {
+          report_type: "summary",
+          generated_at: Time.now,
+          context: context.to_h,
+          date_range: {
+            since: date_range.begin,
+            until: date_range.end
+          },
+          metrics: {
+            total_events: @analytics.event_count(context, since: date_range.begin, until: date_range.end),
+            unique_users: @analytics.unique_users(context, since: date_range.begin, until: date_range.end),
+            active_days: @analytics.active_days(context, since: date_range.begin, until: date_range.end),
+            engagement_score: @analytics.engagement_score(context, since: date_range.begin, until: date_range.end)
+          }
+        }
+      end
+
+      def generate_activity_report(context, options)
+        date_range = options[:date_range] || (options[:since]..options[:until])
+        period = options[:period] || :daily
+
+        {
+          report_type: "activity",
+          generated_at: Time.now,
+          context: context.to_h,
+          date_range: {
+            since: date_range.begin,
+            until: date_range.end
+          },
+          activity_timeline: @analytics.activity_timeline(context, {
+            since: date_range.begin,
+            until: date_range.end,
+            period: period
+          })
+        }
+      end
+
+      def generate_engagement_report(context, options)
+        date_range = options[:date_range] || (options[:since]..options[:until])
+
+        {
+          report_type: "engagement",
+          generated_at: Time.now,
+          context: context.to_h,
+          date_range: {
+            since: date_range.begin,
+            until: date_range.end
+          },
+          engagement_score: @analytics.engagement_score(context, since: date_range.begin, until: date_range.end),
+          breakdown: {
+            total_events: @analytics.event_count(context, since: date_range.begin, until: date_range.end),
+            unique_users: @analytics.unique_users(context, since: date_range.begin, until: date_range.end),
+            active_days: @analytics.active_days(context, since: date_range.begin, until: date_range.end),
+            feature_diversity: @analytics.top_features(context, since: date_range.begin, until: date_range.end).keys.size
+          }
+        }
+      end
+
+      def generate_feature_usage_report(context, options)
+        date_range = options[:date_range] || (options[:since]..options[:until])
+
+        {
+          report_type: "feature_usage",
+          generated_at: Time.now,
+          context: context.to_h,
+          date_range: {
+            since: date_range.begin,
+            until: date_range.end
+          },
+          feature_stats: @analytics.feature_usage_stats(context, since: date_range.begin, until: date_range.end),
+          top_features: @analytics.top_features(context, {
+            since: date_range.begin,
+            until: date_range.end,
+            limit: options[:limit] || 10
+          })
+        }
+      end
+    end
+  end
+end
+

data/lib/behavior_analytics/sampling/strategy.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module BehaviorAnalytics
+  module Sampling
+    class Strategy
+      def initialize(type:, rate: 1.0, options: {})
+        @type = type.to_sym
+        @rate = rate.to_f
+        @options = options
+      end
+
+      def should_sample?(event, context = nil)
+        case @type
+        when :random
+          random_sampling?
+        when :deterministic
+          deterministic_sampling?(event, context)
+        when :adaptive
+          adaptive_sampling?(event, context)
+        else
+          true
+        end
+      end
+
+      private
+
+      def random_sampling?
+        rand < @rate
+      end
+
+      def deterministic_sampling?(event, context)
+        # Use a hash of tenant_id or user_id for deterministic sampling
+        key = context&.tenant_id || event[:tenant_id] || event[:id]
+        hash_value = key.hash.abs
+        (hash_value % 100) < (@rate * 100)
+      end
+
+      def adaptive_sampling?(event, context)
+        # Adaptive sampling based on event volume
+        # This is a simplified version - in production you'd track actual volume
+        base_rate = @rate
+        volume_multiplier = @options[:volume_multiplier] || 1.0
+        
+        # Adjust rate based on current volume (simplified)
+        adjusted_rate = base_rate * volume_multiplier
+        adjusted_rate = [adjusted_rate, 1.0].min
+        adjusted_rate = [adjusted_rate, 0.0].max
+        
+        rand < adjusted_rate
+      end
+    end
+  end
+end
+

data/lib/behavior_analytics/schema/definition.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module BehaviorAnalytics
+  module Schema
+    class Definition
+      attr_reader :name, :version, :required_fields, :field_types, :custom_rules
+
+      def initialize(name, version: "1.0", &block)
+        @name = name
+        @version = version
+        @required_fields = []
+        @field_types = {}
+        @custom_rules = []
+        
+        instance_eval(&block) if block_given?
+      end
+
+      def required(*fields)
+        @required_fields.concat(fields.map(&:to_s))
+      end
+
+      def field(field_name, type:)
+        @field_types[field_name.to_s] = type
+      end
+
+      def validate(&block)
+        @custom_rules << block
+      end
+
+      def to_h
+        {
+          name: @name,
+          version: @version,
+          required_fields: @required_fields,
+          field_types: @field_types,
+          custom_rules_count: @custom_rules.size
+        }
+      end
+    end
+
+    class Registry
+      def initialize
+        @schemas = {}
+        @mutex = Mutex.new
+      end
+
+      def register(schema_definition)
+        @mutex.synchronize do
+          key = "#{schema_definition.name}@#{schema_definition.version}"
+          @schemas[key] = schema_definition
+        end
+      end
+
+      def get(name, version: "1.0")
+        key = "#{name}@#{version}"
+        @schemas[key]
+      end
+
+      def list
+        @schemas.values.map(&:to_h)
+      end
+
+      def clear
+        @mutex.synchronize do
+          @schemas.clear
+        end
+      end
+    end
+  end
+end
+

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
+