lapsoss 0.2.0 → 0.3.1

data/lib/lapsoss/sampling/consistent_hash_sampler.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Lapsoss
+  module Sampling
+    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
+  end
+end

data/lib/lapsoss/sampling/exception_type_sampler.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Sampling
+    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
+  end
+end

data/lib/lapsoss/sampling/health_based_sampler.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Sampling
+    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
+  end
+end

data/lib/lapsoss/sampling/rate_limiter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Sampling
+    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
+  end
+end

data/lib/lapsoss/sampling/sampling_factory.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Sampling
+    # 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

data/lib/lapsoss/sampling/time_based_sampler.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Sampling
+    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
+  end
+end

data/lib/lapsoss/sampling/uniform_sampler.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Sampling
+    class UniformSampler < Base
+      def initialize(rate)
+        @rate = rate
+      end
+
+      def sample?(_event, _hint = {})
+        rand < @rate
+      end
+    end
+  end
+end

data/lib/lapsoss/sampling/user_based_sampler.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Sampling
+    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
+  end
+end

data/lib/lapsoss/scope.rb

@@ -42,65 +42,29 @@ module Lapsoss
       @user.clear
       @extra.clear
     end
-  end
 
-  # Performance-optimized scope that provides a merged view without cloning
-  class MergedScope
-    def initialize(scope_stack, base_scope)
-      @scope_stack = scope_stack
-      @base_scope = base_scope || Scope.new
-      @own_breadcrumbs = []
+    def set_context(key, value)
+      @extra[key] = value
     end
 
-    def tags
-      @tags ||= merge_hash_contexts(:tags)
+    def set_user(user_info)
+      @user.merge!(user_info)
     end
 
-    def user
-      @user ||= merge_hash_contexts(:user)
+    def set_tag(key, value)
+      @tags[key] = value
     end
 
-    def extra
-      @extra ||= merge_hash_contexts(:extra)
+    def set_tags(tags)
+      @tags.merge!(tags)
     end
 
-    def breadcrumbs
-      @breadcrumbs ||= merge_breadcrumbs
+    def set_extra(key, value)
+      @extra[key] = value
     end
 
-    def add_breadcrumb(message, type: :default, **metadata)
-      breadcrumb = {
-        message: message,
-        type: type,
-        metadata: metadata,
-        timestamp: Time.now.utc
-      }
-      @own_breadcrumbs << breadcrumb
-      # Keep breadcrumbs to a reasonable limit
-      @own_breadcrumbs.shift if @own_breadcrumbs.length > 20
-      # Clear cached breadcrumbs to force recomputation
-      @breadcrumbs = nil
-    end
-
-    private
-
-    def merge_hash_contexts(key)
-      result = @base_scope.send(key).dup
-      @scope_stack.each do |context|
-        result.merge!(context[key] || {})
-      end
-      result
-    end
-
-    def merge_breadcrumbs
-      result = @base_scope.breadcrumbs.dup
-      @scope_stack.each do |context|
-        result.concat(context[:breadcrumbs]) if context[:breadcrumbs]
-      end
-      # Add our own breadcrumbs
-      result.concat(@own_breadcrumbs)
-      # Keep breadcrumbs to a reasonable limit
-      result.last(20)
+    def set_extras(extras)
+      @extra.merge!(extras)
     end
   end
 end

data/lib/lapsoss/scrubber.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'active_support/parameter_filter'
+require "active_support/parameter_filter"
 
 module Lapsoss
   class Scrubber
@@ -31,7 +31,7 @@ module Lapsoss
       @scrub_all = config[:scrub_all] || false
       @whitelist_fields = Array(config[:whitelist_fields] || [])
       @randomize_scrub_length = config[:randomize_scrub_length] || false
-      @scrub_value = config[:scrub_value] || '**SCRUBBED**'
+      @scrub_value = config[:scrub_value] || "**SCRUBBED**"
     end
 
     def scrub(data)
@@ -68,13 +68,13 @@ module Lapsoss
 
         result[key] = if should_scrub_field?(key_string)
                         generate_scrub_value(value)
-                      elsif value.is_a?(Hash)
+        elsif value.is_a?(Hash)
                         scrub_recursive(value)
-                      elsif value.is_a?(Array)
+        elsif value.is_a?(Array)
                         scrub_array(value)
-                      else
+        else
                         scrub_value(value)
-                      end
+        end
       end
     end
 
@@ -146,7 +146,7 @@ module Lapsoss
 
     def generate_scrub_value(_original_value)
       if @randomize_scrub_length
-        '*' * rand(6..12)
+        "*" * rand(6..12)
       else
         @scrub_value
       end