lapsoss 0.2.0 → 0.3.1

data/lib/lapsoss/sampling.rb

@@ -1,328 +0,0 @@
-# frozen_string_literal: true
-
-require 'digest'
-
-module Lapsoss
-  module Sampling
-    class Base
-      def sample?(_event, _hint = {})
-        true
-      end
-    end
-
-    class UniformSampler < Base
-      def initialize(rate)
-        @rate = rate
-      end
-
-      def sample?(_event, _hint = {})
-        rand < @rate
-      end
-    end
-
-    class RateLimiter < Base
-      def initialize(max_events_per_second: 10)
-        @max_events_per_second = max_events_per_second
-        @tokens = max_events_per_second
-        @last_refill = Time.zone.now
-        @mutex = Mutex.new
-      end
-
-      def sample?(_event, _hint = {})
-        @mutex.synchronize do
-          now = Time.zone.now
-          time_passed = now - @last_refill
-
-          # Refill tokens based on time passed
-          @tokens = [@tokens + (time_passed * @max_events_per_second), @max_events_per_second].min
-          @last_refill = now
-
-          if @tokens >= 1
-            @tokens -= 1
-            true
-          else
-            false
-          end
-        end
-      end
-    end
-
-    class ExceptionTypeSampler < Base
-      def initialize(rates: {})
-        @rates = rates
-        @default_rate = rates.fetch(:default, 1.0)
-      end
-
-      def sample?(event, _hint = {})
-        return @default_rate > rand unless event.exception
-
-        exception_class = event.exception.class
-        rate = find_rate_for_exception(exception_class)
-        rate > rand
-      end
-
-      private
-
-      def find_rate_for_exception(exception_class)
-        # Check exact class match first
-        return @rates[exception_class] if @rates.key?(exception_class)
-
-        # Check inheritance hierarchy
-        @rates.each do |klass, rate|
-          return rate if klass.is_a?(Class) && exception_class <= klass
-        end
-
-        # Check string/regex patterns
-        @rates.each do |pattern, rate|
-          case pattern
-          when String
-            return rate if exception_class.name.include?(pattern)
-          when Regexp
-            return rate if exception_class.name.match?(pattern)
-          end
-        end
-
-        @default_rate
-      end
-    end
-
-    class UserBasedSampler < Base
-      def initialize(rates: {})
-        @rates = rates
-        @default_rate = rates.fetch(:default, 1.0)
-      end
-
-      def sample?(event, _hint = {})
-        user = event.context[:user]
-        return @default_rate > rand unless user
-
-        rate = find_rate_for_user(user)
-        rate > rand
-      end
-
-      private
-
-      def find_rate_for_user(user)
-        # Check specific user ID
-        user_id = user[:id] || user['id']
-        return @rates[user_id] if user_id && @rates.key?(user_id)
-
-        # Check user segments
-        @rates.each do |segment, rate|
-          case segment
-          when :internal, 'internal'
-            return rate if user[:internal] || user['internal']
-          when :premium, 'premium'
-            return rate if user[:premium] || user['premium']
-          when :beta, 'beta'
-            return rate if user[:beta] || user['beta']
-          end
-        end
-
-        @default_rate
-      end
-    end
-
-    class ConsistentHashSampler < Base
-      def initialize(rate:, key_extractor: nil)
-        @rate = rate
-        @key_extractor = key_extractor || method(:default_key_extractor)
-        @threshold = (rate * 0xFFFFFFFF).to_i
-      end
-
-      def sample?(event, hint = {})
-        key = @key_extractor.call(event, hint)
-        return @rate > rand unless key
-
-        hash_value = Digest::MD5.hexdigest(key.to_s)[0, 8].to_i(16)
-        hash_value <= @threshold
-      end
-
-      private
-
-      def default_key_extractor(event, _hint)
-        # Use fingerprint for consistent sampling
-        event.fingerprint
-      end
-    end
-
-    class TimeBasedSampler < Base
-      def initialize(schedule: {})
-        @schedule = schedule
-        @default_rate = schedule.fetch(:default, 1.0)
-      end
-
-      def sample?(_event, _hint = {})
-        now = Time.zone.now
-        rate = find_rate_for_time(now)
-        rate > rand
-      end
-
-      private
-
-      def find_rate_for_time(time)
-        hour = time.hour
-        day_of_week = time.wday # 0 = Sunday
-
-        # Check specific hour
-        hour_key = :"hour_#{hour}"
-        return @schedule[hour_key] if @schedule.key?(hour_key)
-
-        # Check day of week
-        day_names = %i[sunday monday tuesday wednesday thursday friday saturday]
-        day_key = day_names[day_of_week]
-        return @schedule[day_key] if @schedule.key?(day_key)
-
-        # Check business hours
-        if @schedule.key?(:business_hours) && (9..17).cover?(hour) && (1..5).cover?(day_of_week)
-          return @schedule[:business_hours]
-        end
-
-        # Check weekends
-        return @schedule[:weekends] if @schedule.key?(:weekends) && [0, 6].include?(day_of_week)
-
-        @default_rate
-      end
-    end
-
-    class CompositeSampler < Base
-      def initialize(app = nil, samplers: [], strategy: :all)
-        @app = app
-        @samplers = samplers
-        @strategy = strategy
-      end
-
-      def sample?(event, hint = {})
-        case @strategy
-        when :all
-          @samplers.all? { |sampler| sampler.sample?(event, hint) }
-        when :any
-          @samplers.any? { |sampler| sampler.sample?(event, hint) }
-        when :first
-          @samplers.first&.sample?(event, hint) || true
-        else
-          raise ArgumentError, "Unknown strategy: #{@strategy}"
-        end
-      end
-    end
-
-    class AdaptiveSampler < Base
-      def initialize(target_rate: 1.0, adjustment_period: 60)
-        @target_rate = target_rate
-        @adjustment_period = adjustment_period
-        @current_rate = target_rate
-        @events_count = 0
-        @last_adjustment = Time.zone.now
-        @mutex = Mutex.new
-      end
-
-      def sample?(_event, _hint = {})
-        @mutex.synchronize do
-          @events_count += 1
-
-          # Adjust rate periodically
-          now = Time.zone.now
-          if now - @last_adjustment > @adjustment_period
-            adjust_rate
-            @last_adjustment = now
-            @events_count = 0
-          end
-        end
-
-        @current_rate > rand
-      end
-
-      attr_reader :current_rate
-
-      private
-
-      def adjust_rate
-        # Simple adaptive logic - can be enhanced based on system metrics
-        # For now, just ensure we don't drift too far from target
-        if @events_count > 100 # High volume
-          @current_rate = [@current_rate * 0.9, @target_rate * 0.1].max
-        elsif @events_count < 10 # Low volume
-          @current_rate = [@current_rate * 1.1, @target_rate].min
-        end
-      end
-    end
-
-    class HealthBasedSampler < Base
-      def initialize(health_check:, high_rate: 1.0, low_rate: 0.1)
-        @health_check = health_check
-        @high_rate = high_rate
-        @low_rate = low_rate
-      end
-
-      def sample?(_event, _hint = {})
-        healthy = @health_check.call
-        rate = healthy ? @high_rate : @low_rate
-        rate > rand
-      end
-    end
-
-    # Factory for creating common sampling configurations
-    class SamplingFactory
-      def self.create_production_sampling
-        CompositeSampler.new(
-          samplers: [
-            # Rate limit to prevent overwhelming
-            RateLimiter.new(max_events_per_second: 50),
-
-            # Different rates for different exception types
-            ExceptionTypeSampler.new(rates: {
-                                       # Critical errors - always sample
-                                       SecurityError => 1.0,
-                                       SystemStackError => 1.0,
-                                       NoMemoryError => 1.0,
-
-                                       # Common errors - sample less
-                                       ArgumentError => 0.1,
-                                       TypeError => 0.1,
-
-                                       # Network errors - medium sampling
-                                       /timeout/i => 0.3,
-                                       /connection/i => 0.3,
-
-                                       # Default for unknown errors
-                                       default: 0.5
-                                     }),
-
-            # Lower sampling during business hours
-            TimeBasedSampler.new(schedule: {
-                                   business_hours: 0.3,
-                                   weekends: 0.8,
-                                   default: 0.5
-                                 })
-          ],
-          strategy: :all
-        )
-      end
-
-      def self.create_development_sampling
-        UniformSampler.new(1.0) # Sample everything in development
-      end
-
-      def self.create_user_focused_sampling
-        CompositeSampler.new(
-          samplers: [
-            # Higher sampling for internal users
-            UserBasedSampler.new(rates: {
-                                   internal: 1.0,
-                                   premium: 0.8,
-                                   beta: 0.9,
-                                   default: 0.1
-                                 }),
-
-            # Consistent sampling based on user ID
-            ConsistentHashSampler.new(
-              rate: 0.1,
-              key_extractor: ->(event, _hint) { event.context.dig(:user, :id) }
-            )
-          ],
-          strategy: :any
-        )
-      end
-    end
-  end
-end