behavior_analytics 0.1.0 → 2.1.0

data/lib/behavior_analytics/throttling/limiter.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module BehaviorAnalytics
+  module Throttling
+    class Limiter
+      def initialize(options = {})
+        @per_tenant_limits = options[:per_tenant] || {}
+        @per_user_limits = options[:per_user] || {}
+        @global_limit = options[:global]
+        @window_size = options[:window_size] || 60 # seconds
+        @counters = {}
+        @mutex = Mutex.new
+      end
+
+      def check_limit(context, event = nil)
+        return { allowed: true } unless should_check_limits?
+
+        @mutex.synchronize do
+          # Check global limit
+          if @global_limit && !check_global_limit
+            return { allowed: false, reason: "global_limit_exceeded" }
+          end
+
+          # Check per-tenant limit
+          if context.tenant_id && @per_tenant_limits[context.tenant_id]
+            limit = @per_tenant_limits[context.tenant_id]
+            if !check_limit_for_key("tenant:#{context.tenant_id}", limit)
+              return { allowed: false, reason: "tenant_limit_exceeded", tenant_id: context.tenant_id }
+            end
+          end
+
+          # Check per-user limit
+          if context.user_id && @per_user_limits[context.user_id]
+            limit = @per_user_limits[context.user_id]
+            if !check_limit_for_key("user:#{context.user_id}", limit)
+              return { allowed: false, reason: "user_limit_exceeded", user_id: context.user_id }
+            end
+          end
+
+          { allowed: true }
+        end
+      end
+
+      def record_event(context)
+        return unless should_check_limits?
+
+        @mutex.synchronize do
+          increment_counter("global") if @global_limit
+          increment_counter("tenant:#{context.tenant_id}") if context.tenant_id && @per_tenant_limits[context.tenant_id]
+          increment_counter("user:#{context.user_id}") if context.user_id && @per_user_limits[context.user_id]
+        end
+      end
+
+      def reset_counters
+        @mutex.synchronize do
+          @counters.clear
+        end
+      end
+
+      private
+
+      def should_check_limits?
+        @global_limit || !@per_tenant_limits.empty? || !@per_user_limits.empty?
+      end
+
+      def check_global_limit
+        check_limit_for_key("global", @global_limit)
+      end
+
+      def check_limit_for_key(key, limit)
+        counter = get_counter(key)
+        counter < limit
+      end
+
+      def get_counter(key)
+        counter = @counters[key]
+        
+        # Reset counter if window expired
+        if counter && counter[:expires_at] < Time.now
+          @counters.delete(key)
+          counter = nil
+        end
+
+        counter ||= { count: 0, expires_at: Time.now + @window_size }
+        @counters[key] = counter
+        
+        counter[:count]
+      end
+
+      def increment_counter(key)
+        counter = get_counter(key)
+        @counters[key][:count] += 1
+      end
+    end
+  end
+end
+

data/lib/behavior_analytics/tracker.rb

@@ -5,13 +5,22 @@ require "thread"
 
 module BehaviorAnalytics
   class Tracker
-    attr_reader :storage_adapter, :batch_size, :flush_interval, :context_resolver
+    attr_reader :storage_adapter, :batch_size, :flush_interval, :context_resolver, :async_processor, :event_stream
 
     def initialize(options = {})
       @storage_adapter = options[:storage_adapter] || BehaviorAnalytics.configuration.storage_adapter || Storage::InMemoryAdapter.new
       @batch_size = options[:batch_size] || BehaviorAnalytics.configuration.batch_size
       @flush_interval = options[:flush_interval] || BehaviorAnalytics.configuration.flush_interval
       @context_resolver = options[:context_resolver] || BehaviorAnalytics.configuration.context_resolver
+      @async_processor = options[:async_processor] || BehaviorAnalytics.configuration.async_processor
+      @use_async = options.fetch(:use_async, BehaviorAnalytics.configuration.use_async || false)
+      @event_stream = options[:event_stream] || BehaviorAnalytics.configuration.event_stream || Streaming::EventStream.new
+      @hooks_manager = options[:hooks_manager] || BehaviorAnalytics.configuration.hooks_manager || Hooks::Manager.new
+      @sampling_strategy = options[:sampling_strategy] || BehaviorAnalytics.configuration.sampling_strategy
+      @rate_limiter = options[:rate_limiter] || BehaviorAnalytics.configuration.rate_limiter
+      @schema_validator = options[:schema_validator] || BehaviorAnalytics.configuration.schema_validator
+      @metrics = options[:metrics] || BehaviorAnalytics.configuration.metrics || Observability::Metrics.new
+      @tracer = options[:tracer] || BehaviorAnalytics.configuration.tracer
 
       @buffer = []
       @mutex = Mutex.new
@@ -23,7 +32,50 @@ module BehaviorAnalytics
       context = normalize_context(context)
       context.validate!
 
-      event = Event.new(
+      # Check rate limiting
+      if @rate_limiter
+        limit_check = @rate_limiter.check_limit(context)
+        unless limit_check[:allowed]
+          raise Error, "Rate limit exceeded: #{limit_check[:reason]}"
+        end
+      end
+
+      # Check sampling
+      if @sampling_strategy
+        event_data = {
+          tenant_id: context.tenant_id,
+          user_id: context.user_id,
+          event_name: event_name,
+          event_type: event_type
+        }
+        unless @sampling_strategy.should_sample?(event_data, context)
+          return # Skip this event
+        end
+      end
+
+      # Build event data
+      event_data = {
+        tenant_id: context.tenant_id,
+        user_id: context.user_id,
+        user_type: context.user_type,
+        event_name: event_name,
+        event_type: event_type,
+        metadata: metadata.merge(context.filters),
+        session_id: options[:session_id],
+        ip: options[:ip],
+        user_agent: options[:user_agent],
+        duration_ms: options[:duration_ms]
+      }
+
+      # Validate schema if validator is configured
+      if @schema_validator
+        validation_result = @schema_validator.validate(event_data)
+        unless validation_result[:valid]
+          raise Error, "Event validation failed: #{validation_result[:errors].join(', ')}"
+        end
+      end
+
+      event = Event.new(event_data)
         tenant_id: context.tenant_id,
         user_id: context.user_id,
         user_type: context.user_type,
@@ -36,7 +88,56 @@ module BehaviorAnalytics
         duration_ms: options[:duration_ms]
       )
 
-      add_to_buffer(event)
+      # Execute before_track hooks
+      begin
+        @hooks_manager.execute_before_track(event.to_h, context.to_h)
+      rescue StandardError => e
+        @hooks_manager.execute_on_error(e, event.to_h, context.to_h)
+        raise if BehaviorAnalytics.configuration.raise_on_hook_error
+      end
+
+      begin
+        # Start tracing if enabled
+        span = @tracer&.start_span("track_event", tags: {
+          event_name: event_name,
+          event_type: event_type.to_s,
+          tenant_id: context.tenant_id
+        })
+
+        add_to_buffer(event)
+        
+        # Record metrics
+        @metrics.increment_counter("events.tracked", tags: {
+          event_type: event_type.to_s,
+          tenant_id: context.tenant_id.to_s
+        })
+        
+        # Debug logging
+        if BehaviorAnalytics.configuration.debug_mode
+          BehaviorAnalytics.configuration.debug("Event tracked: #{event_name}", context: context.to_h)
+        end
+        
+        # Publish to event stream
+        @event_stream.publish(event.to_h) if @event_stream
+        
+        # Execute after_track hooks
+        @hooks_manager.execute_after_track(event.to_h, context.to_h)
+        
+        # Record event for rate limiting
+        @rate_limiter.record_event(context) if @rate_limiter
+
+        # Finish tracing
+        @tracer&.finish_span(span[:id]) if span
+      rescue StandardError => e
+        # Record error metrics
+        @metrics.increment_counter("events.errors", tags: {
+          event_type: event_type.to_s,
+          tenant_id: context.tenant_id.to_s
+        })
+        
+        @hooks_manager.execute_on_error(e, event.to_h, context.to_h)
+        raise
+      end
     end
 
     def track_api_call(context:, method:, path:, status_code:, duration_ms: nil, **options)
@@ -76,7 +177,24 @@ module BehaviorAnalytics
 
       return if events_to_flush.empty?
 
-      @storage_adapter.save_events(events_to_flush)
+      start_time = Time.now
+      
+      begin
+        if @use_async && @async_processor
+          @async_processor.process_async(events_to_flush)
+        else
+          @storage_adapter.save_events(events_to_flush)
+        end
+        
+        # Record flush metrics
+        duration_ms = ((Time.now - start_time) * 1000).to_i
+        @metrics.record_histogram("flush.duration_ms", duration_ms)
+        @metrics.increment_counter("flush.count", value: events_to_flush.size)
+      rescue StandardError => e
+        @metrics.increment_counter("flush.errors")
+        raise
+      end
+      
       restart_flush_timer
     end
 
@@ -88,6 +206,14 @@ module BehaviorAnalytics
       Query.new(@storage_adapter)
     end
 
+    def subscribe_to_stream(filter: nil, &block)
+      @event_stream.subscribe(filter: filter, &block)
+    end
+
+    def inspector
+      @inspector ||= Debug::Inspector.new(self)
+    end
+
     private
 
     def normalize_context(context)

data/lib/behavior_analytics/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BehaviorAnalytics
-  VERSION = "0.1.0"
+  VERSION = "2.1.0"
 end

data/lib/behavior_analytics.rb

@@ -8,28 +8,165 @@ require_relative "behavior_analytics/query"
 require_relative "behavior_analytics/storage/adapter"
 require_relative "behavior_analytics/storage/in_memory_adapter"
 require_relative "behavior_analytics/storage/active_record_adapter"
+
+begin
+  require_relative "behavior_analytics/storage/redis_adapter"
+rescue LoadError
+end
+
+begin
+  require_relative "behavior_analytics/storage/elasticsearch_adapter"
+rescue LoadError
+end
+
+begin
+  require_relative "behavior_analytics/storage/kafka_adapter"
+rescue LoadError
+end
 require_relative "behavior_analytics/analytics/engine"
+require_relative "behavior_analytics/analytics/funnels"
+require_relative "behavior_analytics/analytics/cohorts"
+require_relative "behavior_analytics/analytics/retention"
+require_relative "behavior_analytics/hooks/manager"
+require_relative "behavior_analytics/hooks/webhook"
+require_relative "behavior_analytics/hooks/callback"
+require_relative "behavior_analytics/replay/engine"
+require_relative "behavior_analytics/replay/processor"
+require_relative "behavior_analytics/sampling/strategy"
+require_relative "behavior_analytics/throttling/limiter"
+require_relative "behavior_analytics/schema/validator"
+require_relative "behavior_analytics/schema/definition"
+require_relative "behavior_analytics/export/csv_exporter"
+require_relative "behavior_analytics/export/json_exporter"
+require_relative "behavior_analytics/reporting/generator"
+require_relative "behavior_analytics/observability/metrics"
+require_relative "behavior_analytics/observability/tracer"
+require_relative "behavior_analytics/debug/inspector"
+require_relative "behavior_analytics/processors/async_processor"
+require_relative "behavior_analytics/processors/background_job_processor"
+require_relative "behavior_analytics/streaming/event_stream"
 
 begin
   require_relative "behavior_analytics/integrations/rails"
 rescue LoadError
 end
 
+begin
+  require_relative "behavior_analytics/jobs/active_event_job"
+rescue LoadError
+end
+
+begin
+  require_relative "behavior_analytics/jobs/sidekiq_event_job"
+rescue LoadError
+end
+
+begin
+  require_relative "behavior_analytics/jobs/delayed_event_job"
+rescue LoadError
+end
+
 module BehaviorAnalytics
-  class Error < StandardError; end
+  class Error < StandardError
+    attr_reader :context
+
+    def initialize(message, context: nil)
+      super(message)
+      @context = context
+    end
+
+    def to_s
+      base_message = super
+      if @context && BehaviorAnalytics.configuration.debug_mode
+        "#{base_message} (Context: #{@context.inspect})"
+      else
+        base_message
+      end
+    end
+  end
+
+  class ValidationError < Error; end
+  class ConfigurationError < Error; end
+  class StorageError < Error; end
 
   class Configuration
-    attr_accessor :storage_adapter, :batch_size, :flush_interval, :context_resolver, :scoring_weights
+    attr_accessor :storage_adapter, :batch_size, :flush_interval, :context_resolver, :scoring_weights,
+                  :async_processor, :use_async, :event_stream, :environment, :feature_flags,
+                  :hooks_manager, :raise_on_hook_error, :sampling_strategy, :rate_limiter,
+                  :schema_validator, :schema_registry, :tracking_whitelist, :tracking_blacklist,
+                  :skip_bots, :controller_action_filters, :slow_query_threshold, :track_middleware_requests,
+                  :metrics, :tracer, :debug_mode, :logger, :default_tenant_id
 
     def initialize
       @batch_size = 100
       @flush_interval = 300
+      @use_async = false
       @scoring_weights = {
         activity: 0.4,
         unique_users: 0.3,
         feature_diversity: 0.2,
         time_in_trial: 0.1
       }
+      @environment = ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+      @feature_flags = {}
+      @event_stream = Streaming::EventStream.new
+      @hooks_manager = Hooks::Manager.new
+      @raise_on_hook_error = false
+      @schema_registry = Schema::Registry.new
+      @tracking_whitelist = nil
+      @tracking_blacklist = []
+      @skip_bots = true
+      @controller_action_filters = {}
+      @slow_query_threshold = nil
+      @track_middleware_requests = false
+      @metrics = Observability::Metrics.new
+      @tracer = nil
+      @debug_mode = @environment == "development"
+      @logger = nil
+      @default_tenant_id = "default" # Default tenant for single-tenant systems
+    end
+
+    def debug(message, context: nil)
+      return unless @debug_mode
+
+      log_message = "[BehaviorAnalytics] #{message}"
+      log_message += " (Context: #{context.inspect})" if context
+
+      if @logger
+        @logger.debug(log_message)
+      elsif defined?(Rails) && Rails.logger
+        Rails.logger.debug(log_message)
+      else
+        puts log_message
+      end
+    end
+
+    def log_error(error, context: nil)
+      error_message = error.message
+      error_message += " (Context: #{context.inspect})" if context
+
+      if @logger
+        @logger.error("[BehaviorAnalytics] #{error_message}")
+        @logger.error(error.backtrace.join("\n")) if error.backtrace
+      elsif defined?(Rails) && Rails.logger
+        Rails.logger.error("[BehaviorAnalytics] #{error_message}")
+        Rails.logger.error(error.backtrace.join("\n")) if error.backtrace
+      else
+        puts "[BehaviorAnalytics ERROR] #{error_message}"
+        puts error.backtrace.join("\n") if error.backtrace
+      end
+    end
+
+    def feature_enabled?(feature)
+      @feature_flags.fetch(feature, false)
+    end
+
+    def enable_feature(feature)
+      @feature_flags[feature] = true
+    end
+
+    def disable_feature(feature)
+      @feature_flags[feature] = false
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: behavior_analytics
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 2.1.0
 platform: ruby
 authors:
 - nerdawey
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-01-04 00:00:00.000000000 Z
+date: 2026-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -81,22 +81,52 @@ files:
 - Rakefile
 - behavior_analytics.gemspec
 - db/migrate/001_create_behavior_events.rb
+- db/migrate/002_enhance_behavior_events_v2.rb
 - lib/behavior_analytics.rb
+- lib/behavior_analytics/analytics/cohorts.rb
 - lib/behavior_analytics/analytics/engine.rb
+- lib/behavior_analytics/analytics/funnels.rb
+- lib/behavior_analytics/analytics/retention.rb
 - lib/behavior_analytics/context.rb
+- lib/behavior_analytics/debug/inspector.rb
 - lib/behavior_analytics/event.rb
+- lib/behavior_analytics/export/csv_exporter.rb
+- lib/behavior_analytics/export/json_exporter.rb
+- lib/behavior_analytics/hooks/callback.rb
+- lib/behavior_analytics/hooks/manager.rb
+- lib/behavior_analytics/hooks/webhook.rb
 - lib/behavior_analytics/integrations/rails.rb
+- lib/behavior_analytics/integrations/rails/middleware.rb
+- lib/behavior_analytics/jobs/active_event_job.rb
+- lib/behavior_analytics/jobs/delayed_event_job.rb
+- lib/behavior_analytics/jobs/sidekiq_event_job.rb
+- lib/behavior_analytics/observability/metrics.rb
+- lib/behavior_analytics/observability/tracer.rb
+- lib/behavior_analytics/processors/async_processor.rb
+- lib/behavior_analytics/processors/background_job_processor.rb
 - lib/behavior_analytics/query.rb
+- lib/behavior_analytics/replay/engine.rb
+- lib/behavior_analytics/replay/processor.rb
+- lib/behavior_analytics/reporting/generator.rb
+- lib/behavior_analytics/sampling/strategy.rb
+- lib/behavior_analytics/schema/definition.rb
+- lib/behavior_analytics/schema/validator.rb
 - lib/behavior_analytics/storage/active_record_adapter.rb
 - lib/behavior_analytics/storage/adapter.rb
+- lib/behavior_analytics/storage/elasticsearch_adapter.rb
 - lib/behavior_analytics/storage/in_memory_adapter.rb
+- lib/behavior_analytics/storage/kafka_adapter.rb
+- lib/behavior_analytics/storage/redis_adapter.rb
+- lib/behavior_analytics/streaming/event_stream.rb
+- lib/behavior_analytics/throttling/limiter.rb
 - lib/behavior_analytics/tracker.rb
 - lib/behavior_analytics/version.rb
 - lib/generators/behavior_analytics/install_generator.rb
 - lib/generators/behavior_analytics/templates/create_behavior_events.rb
 - sig/behavior_analytics.rbs
 homepage: https://github.com/nerdawey/behavior_analytics
-licenses: []
+licenses:
+- MIT
 metadata:
   homepage_uri: https://github.com/nerdawey/behavior_analytics
   source_code_uri: https://github.com/nerdawey/behavior_analytics