lapsoss 0.1.0 → 0.3.0

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/sampling.rb

@@ -1,332 +1,6 @@
 # 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.now
-        @mutex = Mutex.new
-      end
-
-      def sample?(event, hint = {})
-        @mutex.synchronize do
-          now = Time.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.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}".to_sym
-        return @schedule[hour_key] if @schedule.key?(hour_key)
-
-        # Check day of week
-        day_names = [: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
-        if @schedule.key?(:weekends) && [0, 6].include?(day_of_week)
-          return @schedule[:weekends]
-        end
-
-        @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.now
-        @mutex = Mutex.new
-      end
-
-      def sample?(event, hint = {})
-        @mutex.synchronize do
-          @events_count += 1
-
-          # Adjust rate periodically
-          now = Time.now
-          if now - @last_adjustment > @adjustment_period
-            adjust_rate
-            @last_adjustment = now
-            @events_count = 0
-          end
-        end
-
-        @current_rate > rand
-      end
-
-      def current_rate
-        @current_rate
-      end
-
-      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

data/lib/lapsoss/scope.rb

@@ -29,13 +29,11 @@ module Lapsoss
       @extra.merge!(context[:extra] || {})
 
       # Handle breadcrumbs if provided
-      if context[:breadcrumbs]
-        @breadcrumbs.concat(context[:breadcrumbs])
-        # Keep breadcrumbs to a reasonable limit
-        while @breadcrumbs.length > 20
-          @breadcrumbs.shift
-        end
-      end
+      return unless context[:breadcrumbs]
+
+      @breadcrumbs.concat(context[:breadcrumbs])
+      # Keep breadcrumbs to a reasonable limit
+      @breadcrumbs.shift while @breadcrumbs.length > 20
     end
 
     def clear
@@ -44,67 +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|
-        if context[:breadcrumbs]
-          result.concat(context[:breadcrumbs])
-        end
-      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