lapsoss 0.3.1 → 0.4.2

data/lib/lapsoss/railtie.rb

@@ -2,7 +2,13 @@
 
 module Lapsoss
   class Railtie < Rails::Railtie
-    Rails.logger.debug "[Lapsoss] Railtie loaded" if ENV["DEBUG_LAPSOSS"]
+    if ENV["DEBUG_LAPSOSS"]
+      if Rails.logger.respond_to?(:tagged)
+        Rails.logger.tagged("Lapsoss") { Rails.logger.debug "Railtie loaded" }
+      else
+        Rails.logger.debug "[Lapsoss] Railtie loaded"
+      end
+    end
     config.lapsoss = ActiveSupport::OrderedOptions.new
 
     initializer "lapsoss.configure" do |_app|
@@ -14,7 +20,12 @@ module Lapsoss
                                  Rails.env
         end
 
-        config.logger ||= Rails.logger
+        # Use tagged logger for all Lapsoss logs
+        config.logger ||= if Rails.logger.respond_to?(:tagged)
+                            Rails.logger.tagged("Lapsoss")
+        else
+                            ActiveSupport::TaggedLogging.new(Rails.logger).tagged("Lapsoss")
+        end
 
         config.release ||= if Rails.application.respond_to?(:version)
                              Rails.application.version.to_s

data/lib/lapsoss/registry.rb

@@ -2,6 +2,7 @@
 
 require "singleton"
 require "concurrent"
+require "active_support/core_ext/string/inflections"
 
 module Lapsoss
   class Registry
@@ -42,7 +43,7 @@ module Lapsoss
       name = if adapter.respond_to?(:name) && adapter.name
                adapter.name.to_sym
       elsif adapter.class.name
-               adapter.class.name.split("::").last.to_sym
+               adapter.class.name.demodulize.underscore.to_sym
       else
                # Generate a unique name if class name is nil (anonymous class)
                :"adapter_#{adapter.object_id}"
@@ -116,13 +117,12 @@ module Lapsoss
     # Resolve adapter type to class
     def resolve_adapter_class(type)
       # Try to get the class by convention: Adapters::{Type}Adapter
-      class_name = "#{type.to_s.split('_').map(&:capitalize).join}Adapter"
+      class_name = "#{type.to_s.camelize}Adapter"
+      full_class_name = "Lapsoss::Adapters::#{class_name}"
 
-      begin
-        Adapters.const_get(class_name)
-      rescue NameError
-        raise AdapterNotFoundError, "Unknown adapter type: #{type}. Expected class: Lapsoss::Adapters::#{class_name}"
-      end
+      full_class_name.constantize
+    rescue NameError
+      raise AdapterNotFoundError, "Unknown adapter type: #{type}. Expected class: #{full_class_name}"
     end
   end
 end

data/lib/lapsoss/router.rb

@@ -19,10 +19,8 @@ module Lapsoss
 
       # Handle adapter errors gracefully
       def handle_adapter_error(adapter, event, error)
-        return unless Lapsoss.configuration.logger
-
         Lapsoss.configuration.logger.error(
-          "[Lapsoss] Adapter '#{adapter.name}' failed to capture event (type: #{event.type}): #{error.message}"
+          "Adapter '#{adapter.name}' failed to capture event (type: #{event.type}): #{error.message}"
         )
 
         # Call error handler if configured

data/lib/lapsoss/scope.rb

@@ -12,12 +12,7 @@ module Lapsoss
     end
 
     def add_breadcrumb(message, type: :default, **metadata)
-      breadcrumb = {
-        message: message,
-        type: type,
-        metadata: metadata,
-        timestamp: Time.now.utc
-      }
+      breadcrumb = Breadcrumb.build(message, type: type, metadata: metadata)
       @breadcrumbs << breadcrumb
       # Keep breadcrumbs to a reasonable limit
       @breadcrumbs.shift if @breadcrumbs.length > 20

data/lib/lapsoss/scrubber.rb

@@ -4,165 +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
-      when Hash
-        scrub_hash(data)
-      when Array
-        scrub_array(data)
+      # 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)
-        elsif value.is_a?(Hash)
-                        scrub_recursive(value)
-        elsif value.is_a?(Array)
-                        scrub_array(value)
-        else
-                        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)
+      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)
-      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 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,129 +1,100 @@
 # frozen_string_literal: true
 
-require "uri"
+require "active_support/core_ext/object/blank"
 
 module Lapsoss
   module Validators
-    class ValidationError < StandardError; end
+    extend ActiveSupport::Concern
 
     module_function
 
-    def validate_presence!(value, name)
-      if value.nil? || (value.respond_to?(:empty?) && value.empty?)
-        raise ValidationError, "#{name} is required and cannot be nil or empty"
-      end
+    def logger
+      Lapsoss.configuration.logger
     end
 
-    def validate_type!(value, types, name)
-      types = Array(types)
-      unless types.any? { |type| value.is_a?(type) }
-        type_names = types.map(&:name).join(" or ")
-        raise ValidationError, "#{name} must be a #{type_names}, got #{value.class} (#{value.inspect})"
-      end
+    # 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
     def validate_callable!(value, name)
-      unless value.nil? || value.respond_to?(:call)
-        raise ValidationError, "#{name} must be callable (respond_to? :call) or nil, got #{value.class}"
-      end
+      return true if value.nil? || value.respond_to?(:call)
+      logger.warn "#{name} should be callable but got #{value.class}"
+      false
     end
 
-    def validate_numeric_range!(value, range, name)
-      validate_type!(value, [ Numeric ], name)
-      unless range.cover?(value)
-        raise ValidationError, "#{name} must be between #{range.min} and #{range.max}, got #{value}"
-      end
+    # DSN validation - just log issues
+    def validate_dsn!(dsn_string, name = "DSN")
+      return true if dsn_string.blank?
+
+      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
 
-    def validate_url!(value, name)
-      return if value.nil?
-
-      validate_type!(value, [ String ], name)
-
-      begin
-        uri = URI.parse(value)
-        raise ValidationError, "#{name} must be a valid URL with scheme and host" unless uri.scheme && uri.host
-        raise ValidationError, "#{name} must use http or https scheme" unless %w[http https].include?(uri.scheme)
-      rescue URI::InvalidURIError => e
-        raise ValidationError, "#{name} is not a valid URL: #{e.message}"
-      end
+    # Validate numeric ranges using AS Range#cover?
+    def validate_sample_rate!(value, name)
+      return true if value.nil?
+      return true if (0..1).cover?(value)
+      logger.warn "#{name} should be between 0 and 1, got #{value}"
+      false
     end
 
-    def validate_dsn!(dsn_string, name = "DSN")
-      return if dsn_string.nil?
-
-      validate_type!(dsn_string, [ String ], name)
-
-      begin
-        uri = URI.parse(dsn_string)
+    def validate_timeout!(value, name)
+      return true if value.nil?
+      return true if value.positive?
+      logger.warn "#{name} should be positive, got #{value}"
+      false
+    end
 
-        # Check required components
-        validate_presence!(uri.scheme, "#{name} scheme")
-        validate_presence!(uri.host, "#{name} host")
-        validate_presence!(uri.user, "#{name} public key")
+    def validate_retries!(value, name)
+      return true if value.nil?
+      return true if value >= 0
+      logger.warn "#{name} should be non-negative, got #{value}"
+      false
+    end
 
-        # Validate scheme
-        raise ValidationError, "#{name} must use http or https scheme" unless %w[http https].include?(uri.scheme)
+    # Environment validation using AS presence
+    def validate_environment!(value, name = "environment")
+      return true if value.blank?
 
-        # Extract project ID from path
-        path_parts = uri.path&.split("/") || []
-        project_id = path_parts.last
-        validate_presence!(project_id, "#{name} project ID")
+      value_str = value.to_s.strip
+      return true if value_str.present?
 
-        # Validate project ID is numeric
-        unless project_id.match?(/^\d+$/)
-          raise ValidationError, "#{name} project ID must be numeric, got '#{project_id}'"
-        end
-      rescue URI::InvalidURIError => e
-        raise ValidationError, "#{name} is not a valid URI: #{e.message}"
-      end
+      logger.warn "#{name} should not be empty"
+      false
     end
 
+    # API key validation using AS blank?
     def validate_api_key!(value, name, format: nil)
-      validate_presence!(value, name)
-      validate_type!(value, [ String ], name)
+      return false if value.blank? && logger.warn("#{name} is missing")
 
+      # 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)
-          raise ValidationError, "#{name} must be a valid UUID format"
-        end
-      when :hex
-        raise ValidationError, "#{name} must be a valid hexadecimal string" unless value.match?(/\A[0-9a-f]+\z/i)
+        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
-        raise ValidationError, "#{name} must be alphanumeric" unless value.match?(/\A[a-z0-9]+\z/i)
+        logger.info "#{name} contains special characters, but continuing anyway" unless value.match?(/\A[a-z0-9]+\z/i)
       end
-    end
-
-    def validate_environment!(value, name = "environment")
-      return if value.nil?
-
-      validate_type!(value, [ String, Symbol ], name)
 
-      env_string = value.to_s
-      unless env_string.match?(/\A[a-z0-9_-]+\z/i)
-        raise ValidationError, "#{name} must contain only alphanumeric characters, underscores, and hyphens"
-      end
+      true
     end
 
-    def validate_sample_rate!(value, name = "sample_rate")
-      return if value.nil?
-
-      validate_numeric_range!(value, 0.0..1.0, name)
-    end
-
-    def validate_timeout!(value, name = "timeout")
-      return if value.nil?
-
-      validate_type!(value, [ Numeric ], name)
-      raise ValidationError, "#{name} must be positive, got #{value}" if value <= 0
-    end
-
-    def validate_retries!(value, name = "max_retries")
-      return if value.nil?
-
-      validate_type!(value, [ Integer ], name)
-      validate_numeric_range!(value, 0..10, name)
+    # URL validation
+    def validate_url!(value, name)
+      return true if value.nil?
+      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.3.1"
+  VERSION = "0.4.2"
 end

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: lapsoss
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Abdelkader Boudih
-bindir: exe
+bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
@@ -212,13 +212,15 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- CHANGELOG.md
 - LICENSE.txt
 - README.md
 - lib/lapsoss.rb
 - lib/lapsoss/adapters/appsignal_adapter.rb
 - lib/lapsoss/adapters/base.rb
 - lib/lapsoss/adapters/bugsnag_adapter.rb
+- lib/lapsoss/adapters/concerns/envelope_builder.rb
+- lib/lapsoss/adapters/concerns/http_delivery.rb
+- lib/lapsoss/adapters/concerns/level_mapping.rb
 - lib/lapsoss/adapters/insight_hub_adapter.rb
 - lib/lapsoss/adapters/logger_adapter.rb
 - lib/lapsoss/adapters/rollbar_adapter.rb
@@ -226,14 +228,13 @@ files:
 - lib/lapsoss/backtrace_frame.rb
 - lib/lapsoss/backtrace_frame_factory.rb
 - lib/lapsoss/backtrace_processor.rb
+- lib/lapsoss/breadcrumb.rb
 - lib/lapsoss/client.rb
 - lib/lapsoss/configuration.rb
 - 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
@@ -245,36 +246,19 @@ 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
 homepage: https://github.com/seuros/lapsoss
@@ -284,7 +268,7 @@ metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/seuros/lapsoss
   source_code_uri: https://github.com/seuros/lapsoss
-  changelog_uri: https://github.com/seuros/lapsoss/blob/main/CHANGELOG.md
+  changelog_uri: https://github.com/seuros/lapsoss/blob/master/CHANGELOG.md
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -293,7 +277,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/CHANGELOG.md

@@ -1,5 +0,0 @@
-## [Unreleased]
-
-## [0.1.0] - 2025-07-06
-
-- Initial release

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