lapsoss 0.1.0

data/lib/lapsoss/sampling.rb

@@ -0,0 +1,332 @@
+# 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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  class Scope
+    attr_reader :breadcrumbs, :tags, :user, :extra
+
+    def initialize
+      @breadcrumbs = []
+      @tags = {}
+      @user = {}
+      @extra = {}
+    end
+
+    def add_breadcrumb(message, type: :default, **metadata)
+      breadcrumb = {
+        message: message,
+        type: type,
+        metadata: metadata,
+        timestamp: Time.now.utc
+      }
+      @breadcrumbs << breadcrumb
+      # Keep breadcrumbs to a reasonable limit
+      @breadcrumbs.shift if @breadcrumbs.length > 20
+    end
+
+    def apply_context(context)
+      @tags.merge!(context[:tags] || {})
+      @user.merge!(context[:user] || {})
+      @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
+    end
+
+    def clear
+      @breadcrumbs.clear
+      @tags.clear
+      @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 = []
+    end
+
+    def tags
+      @tags ||= merge_hash_contexts(:tags)
+    end
+
+    def user
+      @user ||= merge_hash_contexts(:user)
+    end
+
+    def extra
+      @extra ||= merge_hash_contexts(:extra)
+    end
+
+    def breadcrumbs
+      @breadcrumbs ||= merge_breadcrumbs
+    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)
+    end
+  end
+end

data/lib/lapsoss/scrubber.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "active_support/parameter_filter"
+
+module Lapsoss
+  class Scrubber
+    DEFAULT_SCRUB_FIELDS = %w[
+      password passwd pwd secret token key api_key access_token
+      authorization auth_token session_token csrf_token
+      credit_card cc_number card_number ssn social_security_number
+      phone mobile email_address
+    ].freeze
+
+    PROTECTED_EVENT_FIELDS = %w[
+      type timestamp level message exception environment context
+    ].freeze
+
+    ATTACHMENT_CLASSES = %w[
+      ActionDispatch::Http::UploadedFile
+      Rack::Multipart::UploadedFile
+      Tempfile
+    ].freeze
+
+    def initialize(config = {})
+      @rails_parameter_filter = rails_parameter_filter
+
+      # Only use custom scrubbing if Rails parameter filter is not available
+      unless @rails_parameter_filter
+        @scrub_fields = Array(config[:scrub_fields] || DEFAULT_SCRUB_FIELDS)
+        @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**"
+      end
+    end
+
+    def scrub(data)
+      return data if data.nil?
+
+      # If Rails parameter filter is available, use it exclusively
+      if @rails_parameter_filter
+        return @rails_parameter_filter.filter(data)
+      end
+
+      # Fallback to custom scrubbing logic only if Rails filter is not available
+      @scrubbed_objects = {}.compare_by_identity
+      scrub_recursive(data)
+    end
+
+    private
+
+    def scrub_recursive(data)
+      return data if @scrubbed_objects.key?(data)
+
+      @scrubbed_objects[data] = true
+
+      case data
+      when Hash
+        scrub_hash(data)
+      when Array
+        scrub_array(data)
+      else
+        scrub_value(data)
+      end
+    end
+
+    def scrub_hash(hash)
+      hash.each_with_object({}) do |(key, value), result|
+        key_string = key.to_s.downcase
+
+        if should_scrub_field?(key_string)
+          result[key] = generate_scrub_value(value)
+        elsif value.is_a?(Hash)
+          result[key] = scrub_recursive(value)
+        elsif value.is_a?(Array)
+          result[key] = scrub_array(value)
+        else
+          result[key] = scrub_value(value)
+        end
+      end
+    end
+
+    def scrub_array(array)
+      array.map do |item|
+        scrub_recursive(item)
+      end
+    end
+
+    def scrub_value(value)
+      if attachment_value?(value)
+        scrub_attachment(value)
+      else
+        value
+      end
+    end
+
+    def should_scrub_field?(field_name)
+      return false if whitelisted_field?(field_name)
+      return false if protected_event_field?(field_name)
+      return true if @scrub_all
+
+      @scrub_fields.any? { |pattern| field_matches_pattern?(field_name, pattern) }
+    end
+
+    def field_matches_pattern?(field_name, pattern)
+      if pattern.is_a?(Regexp)
+        pattern.match?(field_name)
+      else
+        field_name.include?(pattern.to_s.downcase)
+      end
+    end
+
+    def whitelisted_field?(field_name)
+      @whitelist_fields.any? { |pattern| field_matches_pattern?(field_name, pattern) }
+    end
+
+    def protected_event_field?(field_name)
+      PROTECTED_EVENT_FIELDS.include?(field_name.to_s)
+    end
+
+    def whitelisted_value?(value)
+      # Basic implementation - could be extended
+      false
+    end
+
+    def attachment_value?(value)
+      return false unless value.respond_to?(:class)
+
+      ATTACHMENT_CLASSES.include?(value.class.name)
+    end
+
+    def scrub_attachment(attachment)
+      {
+        __attachment__: true,
+        content_type: safe_call(attachment, :content_type),
+        original_filename: safe_call(attachment, :original_filename),
+        size: safe_call(attachment, :size) || safe_call(attachment, :tempfile, :size)
+      }
+    rescue => e
+      { __attachment__: true, error: "Failed to extract attachment info: #{e.message}" }
+    end
+
+    def safe_call(object, *methods)
+      methods.reduce(object) do |obj, method|
+        obj.respond_to?(method) ? obj.public_send(method) : nil
+      end
+    end
+
+    def generate_scrub_value(original_value)
+      if @randomize_scrub_length
+        "*" * rand(6..12)
+      else
+        @scrub_value
+      end
+    end
+
+    def rails_parameter_filter
+      return nil unless defined?(Rails) && Rails.respond_to?(:application) && Rails.application
+      return nil unless defined?(ActiveSupport::ParameterFilter)
+
+      filter_params = Rails.application.config.filter_parameters
+      return nil if filter_params.empty?
+
+      ActiveSupport::ParameterFilter.new(filter_params)
+    rescue StandardError
+      # Fallback silently if Rails config is not available
+      nil
+    end
+  end
+end