lapsoss 0.4.0 → 0.4.2

data/lib/lapsoss/scrubber.rb

@@ -4,169 +4,32 @@ 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
+    # Match Rails conventions - these are only used when Rails is not available
+    # Rails uses partial matching, so 'passw' matches 'password'
+    DEFAULT_SCRUB_FIELDS = %i[
+      passw email secret token _key crypt salt certificate otp ssn cvv cvc
     ].freeze
 
     def initialize(config = {})
-      @rails_parameter_filter = rails_parameter_filter
-
-      # Only use custom scrubbing if Rails parameter filter is not available
-      return if @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
-
-    def scrub(data)
-      return data if data.nil?
-
-      # If Rails parameter filter is available, use it exclusively
-      return @rails_parameter_filter.filter(data) if @rails_parameter_filter
-
-      # 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
-      in Hash => hash
-        scrub_hash(hash)
-      in Array => array
-        scrub_array(array)
+      # Combine: Rails filter parameters + custom fields (if provided)
+      base_params = if defined?(Rails) && Rails.respond_to?(:application) && Rails.application
+                      Rails.application.config.filter_parameters.presence || DEFAULT_SCRUB_FIELDS
       else
-        scrub_value(data)
+                      DEFAULT_SCRUB_FIELDS
       end
-    end
 
-    def scrub_hash(hash)
-      hash.each_with_object({}) do |(key, value), result|
-        key_string = key.to_s.downcase
-
-        result[key] = if should_scrub_field?(key_string)
-                        generate_scrub_value(value)
-        else
-                        case value
-                        in Hash => h
-                          scrub_recursive(h)
-                        in Array => a
-                          scrub_array(a)
-                        else
-                          scrub_value(value)
-                        end
-        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)
+      filter_params = if config[:scrub_fields]
+                        Array(base_params) + Array(config[:scrub_fields])
       else
-        value
+                        base_params
       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) }
+      @filter = ActiveSupport::ParameterFilter.new(filter_params)
     end
 
-    def field_matches_pattern?(field_name, pattern)
-      case pattern
-      in Regexp => regex
-        regex.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 StandardError => 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
+    def scrub(data)
+      return data if data.nil?
+      @filter.filter(data)
     end
   end
 end

data/lib/lapsoss/validators.rb

@@ -1,164 +1,100 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/object/blank"
+
 module Lapsoss
   module Validators
-    class ValidationError < StandardError; end
+    extend ActiveSupport::Concern
 
     module_function
 
-    # Simple presence check - just ensure it's not blank
-    def validate_presence!(value, name)
-      return unless value.blank?
+    def logger
+      Lapsoss.configuration.logger
+    end
 
-      Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} is missing or blank"
+    # Simple presence check using AS blank?
+    def validate_presence!(value, name)
+      return true if value.present?
+      logger.warn "#{name} is missing or blank"
       false
     end
 
-    # Check if callable, log warning if not
+    # Check if callable
     def validate_callable!(value, name)
       return true if value.nil? || value.respond_to?(:call)
-
-      Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} should be callable but got #{value.class}"
+      logger.warn "#{name} should be callable but got #{value.class}"
       false
     end
 
-    # Just log DSN issues, don't fail
+    # DSN validation - just log issues
     def validate_dsn!(dsn_string, name = "DSN")
       return true if dsn_string.blank?
 
-      begin
-        uri = URI.parse(dsn_string)
-
-        if uri.user.blank?
-          Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} appears to be missing public key"
-        end
-
-        if uri.host.blank?
-          Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} appears to be missing host"
-        end
-
-        true
-      rescue URI::InvalidURIError => e
-        Lapsoss.configuration.logger&.error "[Lapsoss] #{name} couldn't be parsed: #{e.message}"
-        false
-      end
+      uri = URI.parse(dsn_string)
+      logger.warn "#{name} appears to be missing public key" if uri.user.blank?
+      logger.warn "#{name} appears to be missing host" if uri.host.blank?
+      true
+    rescue URI::InvalidURIError => e
+      logger.error "#{name} couldn't be parsed: #{e.message}"
+      false
     end
 
-    # Validate sample rate is between 0 and 1
+    # Validate numeric ranges using AS Range#cover?
     def validate_sample_rate!(value, name)
       return true if value.nil?
-
-      if value < 0 || value > 1
-        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} should be between 0 and 1, got #{value}"
-      end
-      true
+      return true if (0..1).cover?(value)
+      logger.warn "#{name} should be between 0 and 1, got #{value}"
+      false
     end
 
-    # Validate timeout values
     def validate_timeout!(value, name)
       return true if value.nil?
-
-      if value <= 0
-        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} should be positive, got #{value}"
-      end
-      true
+      return true if value.positive?
+      logger.warn "#{name} should be positive, got #{value}"
+      false
     end
 
-    # Validate retry count
     def validate_retries!(value, name)
       return true if value.nil?
-
-      if value < 0
-        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} should be non-negative, got #{value}"
-      end
-      true
-    end
-
-    # Validate environment string
-    def validate_environment!(value, name)
-      return true if value.nil?
-
-      if value.to_s.strip.empty?
-        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} should not be empty"
-      end
-      true
-    end
-
-    # Validate type
-    def validate_type!(value, expected_types, name)
-      return true if value.nil?
-
-      unless expected_types.any? { |type| value.is_a?(type) }
-        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} should be one of #{expected_types.join(', ')}, got #{value.class}"
-      end
-      true
+      return true if value >= 0
+      logger.warn "#{name} should be non-negative, got #{value}"
+      false
     end
 
-    # Validate numeric range
-    def validate_numeric_range!(value, range, name)
-      return true if value.nil?
-
-      unless range.include?(value)
-        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} should be within #{range}, got #{value}"
-      end
-      true
-    end
+    # Environment validation using AS presence
+    def validate_environment!(value, name = "environment")
+      return true if value.blank?
 
-    # Validate boolean
-    def validate_boolean!(value, name)
-      return true if value.nil?
+      value_str = value.to_s.strip
+      return true if value_str.present?
 
-      unless [ true, false ].include?(value)
-        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} should be true or false, got #{value}"
-      end
-      true
+      logger.warn "#{name} should not be empty"
+      false
     end
 
-    # Just check presence, don't validate format
+    # API key validation using AS blank?
     def validate_api_key!(value, name, format: nil)
-      if value.blank?
-        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} is missing"
-        return false
-      end
+      return false if value.blank? && logger.warn("#{name} is missing")
 
-      # Optional format hint for logging only
+      # Optional format hints
       case format
       when :uuid
-        unless value.match?(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i)
-          Lapsoss.configuration.logger&.info "[Lapsoss] #{name} doesn't look like a UUID, but continuing anyway"
-        end
+        logger.info "#{name} doesn't look like a UUID, but continuing anyway" unless value.match?(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i)
       when :alphanumeric
-        unless value.match?(/\A[a-z0-9]+\z/i)
-          Lapsoss.configuration.logger&.info "[Lapsoss] #{name} contains special characters, but continuing anyway"
-        end
-      end
-
-      true
-    end
-
-    # Environment validation - just log if unusual
-    def validate_environment!(value, name = "environment")
-      return true if value.blank?
-
-      common_envs = %w[development test staging production]
-      unless common_envs.include?(value.to_s.downcase)
-        Lapsoss.configuration.logger&.info "[Lapsoss] #{name} '#{value}' is non-standard (expected one of: #{common_envs.join(', ')})"
+        logger.info "#{name} contains special characters, but continuing anyway" unless value.match?(/\A[a-z0-9]+\z/i)
       end
 
       true
     end
 
-    # URL validation - just check parsability
+    # URL validation
     def validate_url!(value, name)
       return true if value.nil?
-
-      begin
-        URI.parse(value)
-        true
-      rescue URI::InvalidURIError => e
-        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} couldn't be parsed as URL: #{e.message}"
-        false
-      end
+      URI.parse(value)
+      true
+    rescue URI::InvalidURIError => e
+      logger.warn "#{name} couldn't be parsed as URL: #{e.message}"
+      false
     end
   end
 end

data/lib/lapsoss/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lapsoss
-  VERSION = "0.4.0"
+  VERSION = "0.4.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lapsoss
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -234,9 +234,7 @@ files:
 - lib/lapsoss/current.rb
 - lib/lapsoss/event.rb
 - lib/lapsoss/exception_backtrace_frame.rb
-- lib/lapsoss/exclusion_configuration.rb
 - lib/lapsoss/exclusion_filter.rb
-- lib/lapsoss/exclusion_presets.rb
 - lib/lapsoss/fingerprinter.rb
 - lib/lapsoss/http_client.rb
 - lib/lapsoss/merged_scope.rb
@@ -248,39 +246,21 @@ files:
 - lib/lapsoss/middleware/metrics_collector.rb
 - lib/lapsoss/middleware/rate_limiter.rb
 - lib/lapsoss/middleware/release_tracker.rb
-- lib/lapsoss/middleware/sample_filter.rb
-- lib/lapsoss/middleware/sampling_middleware.rb
-- lib/lapsoss/middleware/user_context_enhancer.rb
 - lib/lapsoss/pipeline.rb
 - lib/lapsoss/pipeline_builder.rb
 - lib/lapsoss/rails_error_subscriber.rb
 - lib/lapsoss/rails_middleware.rb
 - lib/lapsoss/railtie.rb
 - lib/lapsoss/registry.rb
-- lib/lapsoss/release_providers.rb
 - lib/lapsoss/release_tracker.rb
 - lib/lapsoss/router.rb
-- lib/lapsoss/sampling/adaptive_sampler.rb
 - lib/lapsoss/sampling/base.rb
-- lib/lapsoss/sampling/composite_sampler.rb
-- lib/lapsoss/sampling/consistent_hash_sampler.rb
-- lib/lapsoss/sampling/exception_type_sampler.rb
-- lib/lapsoss/sampling/health_based_sampler.rb
 - lib/lapsoss/sampling/rate_limiter.rb
-- lib/lapsoss/sampling/sampling_factory.rb
-- lib/lapsoss/sampling/time_based_sampler.rb
 - lib/lapsoss/sampling/uniform_sampler.rb
-- lib/lapsoss/sampling/user_based_sampler.rb
 - lib/lapsoss/scope.rb
 - lib/lapsoss/scrubber.rb
-- lib/lapsoss/user_context.rb
-- lib/lapsoss/user_context_integrations.rb
-- lib/lapsoss/user_context_middleware.rb
-- lib/lapsoss/user_context_provider.rb
-- lib/lapsoss/utils.rb
 - lib/lapsoss/validators.rb
 - lib/lapsoss/version.rb
-- lib/tasks/cassettes.rake
 homepage: https://github.com/seuros/lapsoss
 licenses:
 - MIT

data/lib/lapsoss/exclusion_configuration.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Lapsoss
-  # Configuration helper for exclusions
-  module ExclusionConfiguration
-    def self.configure_exclusions(config, preset: nil, **custom_config)
-      exclusion_config = if preset
-                           case preset
-                           when Array
-                             ExclusionPresets.combined(preset)
-                           else
-                             ExclusionPresets.send(preset)
-                           end
-      else
-                           {}
-      end
-
-      # Merge custom configuration
-      exclusion_config.merge!(custom_config)
-
-      # Create exclusion filter
-      exclusion_filter = ExclusionFilter.new(exclusion_config)
-
-      # Add to configuration
-      config.exclusion_filter = exclusion_filter
-
-      exclusion_filter
-    end
-  end
-end