lapsoss 0.1.0 → 0.3.0

data/lib/lapsoss/client.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require "concurrent"
-require_relative "scope"
-require_relative "current"
 
 module Lapsoss
   class Client
@@ -47,7 +45,7 @@ module Lapsoss
       original_scope = current_scope
 
       # Create a merged scope with the new context
-      merged_scope = MergedScope.new([context], original_scope)
+      merged_scope = MergedScope.new([ context ], original_scope)
       Current.scope = merged_scope
 
       yield(merged_scope)
@@ -70,8 +68,6 @@ module Lapsoss
 
     private
 
-
-
     def capture_event(event)
       # Apply pipeline processing if enabled
       if @configuration.enable_pipeline && @configuration.pipeline
@@ -87,7 +83,7 @@ module Lapsoss
       else
         Router.process_event(event)
       end
-    rescue => e
+    rescue StandardError => e
       handle_capture_error(e)
     end
 

data/lib/lapsoss/configuration.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "validators"
 require "active_support/configurable"
 
 module Lapsoss
@@ -8,19 +7,16 @@ module Lapsoss
     include Validators
     include ActiveSupport::Configurable
 
-    attr_accessor :async, :logger, :enabled, :release,
+    attr_accessor :async, :logger, :enabled, :release, :debug,
                   :scrub_fields, :scrub_all, :whitelist_fields, :randomize_scrub_length,
                   :transport_jitter, :fingerprint_patterns,
                   :normalize_fingerprint_paths, :normalize_fingerprint_ids, :fingerprint_include_environment,
                   :backtrace_context_lines, :backtrace_in_app_patterns, :backtrace_exclude_patterns,
                   :backtrace_strip_load_path, :backtrace_max_frames, :backtrace_enable_code_context,
                   :enable_pipeline, :pipeline_builder, :sampling_strategy,
-                  :skip_rails_cache_errors
-    attr_reader :fingerprint_callback
-    attr_reader :environment, :before_send, :sample_rate, :error_handler,
-                :transport_timeout, :transport_max_retries, :transport_initial_backoff,
-                :transport_max_backoff, :transport_backoff_multiplier, :transport_ssl_verify
-    attr_reader :default_context, :adapter_configs
+                  :skip_rails_cache_errors, :force_sync_http, :capture_request_context
+    attr_reader :fingerprint_callback, :environment, :before_send, :sample_rate, :error_handler, :transport_timeout,
+                :transport_max_retries, :transport_initial_backoff, :transport_max_backoff, :transport_backoff_multiplier, :transport_ssl_verify, :default_context, :adapter_configs
 
     def initialize
       @adapter_configs = {}
@@ -29,11 +25,12 @@ module Lapsoss
       @environment = nil
       @enabled = true
       @release = nil
+      @debug = false
       @before_send = nil
       @sample_rate = 1.0
       @default_context = {}
       @error_handler = nil
-      @scrub_fields = nil  # Will use defaults from Scrubber
+      @scrub_fields = nil # Will use defaults from Scrubber
       @scrub_all = false
       @whitelist_fields = []
       @randomize_scrub_length = false
@@ -47,7 +44,7 @@ module Lapsoss
       @transport_ssl_verify = true
       # Fingerprinting settings
       @fingerprint_callback = nil
-      @fingerprint_patterns = nil  # Will use defaults from Fingerprinter
+      @fingerprint_patterns = nil # Will use defaults from Fingerprinter
       @normalize_fingerprint_paths = true
       @normalize_fingerprint_ids = true
       @fingerprint_include_environment = false
@@ -64,9 +61,12 @@ module Lapsoss
       @sampling_strategy = nil
       # Rails error filtering
       @skip_rails_cache_errors = true
+      # HTTP client settings
+      @force_sync_http = false
+      # Capture request context in middleware
+      @capture_request_context = true
     end
 
-
     # Register a named adapter configuration
     #
     # @param name [Symbol] Unique name for this adapter instance
@@ -99,7 +99,6 @@ module Lapsoss
       register_adapter(name, :bugsnag, **settings)
     end
 
-
     # Convenience method for Rollbar
     def use_rollbar(name: :rollbar, **settings)
       register_adapter(name, :rollbar, **settings)
@@ -164,9 +163,16 @@ module Lapsoss
       initialize
     end
 
+    def debug?
+      @debug
+    end
+
+    def async?
+      @async
+    end
+
     # Pipeline configuration
-    def configure_pipeline(&block)
-      require_relative "pipeline"
+    def configure_pipeline
       @pipeline_builder = PipelineBuilder.new
       yield(@pipeline_builder) if block_given?
       @pipeline_builder
@@ -178,8 +184,6 @@ module Lapsoss
 
     # Sampling configuration
     def configure_sampling(strategy = nil, &block)
-      require_relative "sampling"
-
       if strategy
         @sampling_strategy = strategy
       elsif block_given?
@@ -188,8 +192,6 @@ module Lapsoss
     end
 
     def create_sampling_strategy
-      require_relative "sampling"
-
       case @sampling_strategy
       when Symbol
         case @sampling_strategy
@@ -254,7 +256,7 @@ module Lapsoss
 
     def transport_backoff_multiplier=(value)
       if value
-        validate_type!(value, [Numeric], "transport_backoff_multiplier")
+        validate_type!(value, [ Numeric ], "transport_backoff_multiplier")
         validate_numeric_range!(value, 1.0..10.0, "transport_backoff_multiplier")
       end
       @transport_backoff_multiplier = value
@@ -285,13 +287,14 @@ module Lapsoss
       validate_timeout!(@transport_max_backoff, "transport_max_backoff")
 
       if @transport_backoff_multiplier
-        validate_type!(@transport_backoff_multiplier, [Numeric], "transport_backoff_multiplier")
+        validate_type!(@transport_backoff_multiplier, [ Numeric ], "transport_backoff_multiplier")
         validate_numeric_range!(@transport_backoff_multiplier, 1.0..10.0, "transport_backoff_multiplier")
       end
 
       # Validate that initial backoff is less than max backoff
       if @transport_initial_backoff && @transport_max_backoff && @transport_initial_backoff > @transport_max_backoff
-        raise ValidationError, "transport_initial_backoff (#{@transport_initial_backoff}) must be less than transport_max_backoff (#{@transport_max_backoff})"
+        raise ValidationError,
+              "transport_initial_backoff (#{@transport_initial_backoff}) must be less than transport_max_backoff (#{@transport_max_backoff})"
       end
 
       # Validate adapter configurations
@@ -304,7 +307,7 @@ module Lapsoss
 
     def validate_adapter_config!(name, config)
       validate_presence!(config[:type], "adapter type for '#{name}'")
-      validate_type!(config[:settings], [Hash], "adapter settings for '#{name}'")
+      validate_type!(config[:settings], [ Hash ], "adapter settings for '#{name}'")
     end
   end
 end

data/lib/lapsoss/current.rb

@@ -4,6 +4,14 @@ require "active_support/all"
 
 module Lapsoss
   class Current < ActiveSupport::CurrentAttributes
-    attribute :scope
+    attribute :scope, default: -> { Scope.new }
+
+    def self.with_clean_scope
+      previous_scope = scope
+      self.scope = Scope.new
+      yield
+    ensure
+      self.scope = previous_scope
+    end
   end
 end

data/lib/lapsoss/event.rb

@@ -1,17 +1,14 @@
 # frozen_string_literal: true
 
-require_relative "scrubber"
-require_relative "fingerprinter"
-require_relative "backtrace_processor"
-
 module Lapsoss
   class Event
-    attr_accessor :type, :timestamp, :level, :message, :exception, :context, :environment, :fingerprint, :backtrace_frames
+    attr_accessor :type, :timestamp, :level, :message, :exception, :context, :environment, :fingerprint,
+                  :backtrace_frames
 
     def initialize(type:, level: :info, **attributes)
       @type = type
       @level = level
-      @timestamp = Time.now
+      @timestamp = Utils.current_time
       @context = {}
       @environment = Lapsoss.configuration.environment
 
@@ -22,6 +19,9 @@ module Lapsoss
       # Process backtrace if we have an exception
       @backtrace_frames = process_backtrace if @exception
 
+      # Set message from exception if not provided
+      @message ||= @exception.message if @exception
+
       # Generate fingerprint after all attributes are set (unless explicitly set to nil or a value)
       @fingerprint = generate_fingerprint if @fingerprint.nil? && !attributes.key?(:fingerprint)
     end
@@ -103,5 +103,29 @@ module Lapsoss
 
       @backtrace_frames.map(&:to_h)
     end
+
+    public
+
+    def exception_type
+      exception&.class&.name
+    end
+
+    def backtrace
+      if @backtrace_frames
+        @backtrace_frames.map(&:raw_line)
+      elsif exception
+        exception.backtrace
+      else
+        []
+      end
+    end
+
+    def request_context
+      # Request context is stored in extra by the middleware
+      # Check both string and symbol keys for compatibility
+      return nil unless context[:extra]
+
+      context[:extra]["request"] || context[:extra][:request]
+    end
   end
 end

data/lib/lapsoss/exception_backtrace_frame.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  # Wrapper for BacktraceFrame that adds exception-specific metadata
+  class ExceptionBacktraceFrame
+    attr_reader :frame, :exception_class, :is_crash_frame
+
+    def initialize(frame, exception_class: nil, is_crash_frame: false)
+      @frame = frame
+      @exception_class = exception_class
+      @is_crash_frame = is_crash_frame
+    end
+
+    def crash_frame?
+      @is_crash_frame
+    end
+
+    # Delegate all other methods to the wrapped frame
+    def method_missing(method, *, &)
+      if @frame.respond_to?(method)
+        @frame.send(method, *, &)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      @frame.respond_to?(method, include_private) || super
+    end
+
+    # Override to_h to include exception metadata
+    def to_h
+      @frame.to_h.merge(
+        exception_class: @exception_class,
+        crash_frame: @is_crash_frame
+      ).compact
+    end
+  end
+end

data/lib/lapsoss/exclusion_configuration.rb

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

data/lib/lapsoss/exclusion_filter.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  # Error exclusion system for filtering exception types
+  class ExclusionFilter
+    def initialize(configuration = {})
+      @excluded_exceptions = configuration[:excluded_exceptions] || []
+      @excluded_patterns = configuration[:excluded_patterns] || []
+      @excluded_messages = configuration[:excluded_messages] || []
+      @excluded_environments = configuration[:excluded_environments] || []
+      @custom_filters = configuration[:custom_filters] || []
+      @inclusion_overrides = configuration[:inclusion_overrides] || []
+    end
+
+    def should_exclude?(event)
+      # Check inclusion overrides first - these take precedence
+      return false if should_include_override?(event)
+
+      # Apply exclusion filters
+      return true if excluded_by_exception_type?(event)
+      return true if excluded_by_pattern?(event)
+      return true if excluded_by_message?(event)
+      return true if excluded_by_environment?(event)
+      return true if excluded_by_custom_filter?(event)
+
+      false
+    end
+
+    def add_exclusion(type, value)
+      case type
+      when :exception
+        @excluded_exceptions << value
+      when :pattern
+        @excluded_patterns << value
+      when :message
+        @excluded_messages << value
+      when :environment
+        @excluded_environments << value
+      when :custom
+        @custom_filters << value
+      else
+        raise ArgumentError, "Unknown exclusion type: #{type}"
+      end
+    end
+
+    def add_inclusion_override(filter)
+      @inclusion_overrides << filter
+    end
+
+    def clear_exclusions(type = nil)
+      if type
+        case type
+        when :exception then @excluded_exceptions.clear
+        when :pattern then @excluded_patterns.clear
+        when :message then @excluded_messages.clear
+        when :environment then @excluded_environments.clear
+        when :custom then @custom_filters.clear
+        else raise ArgumentError, "Unknown exclusion type: #{type}"
+        end
+      else
+        @excluded_exceptions.clear
+        @excluded_patterns.clear
+        @excluded_messages.clear
+        @excluded_environments.clear
+        @custom_filters.clear
+      end
+    end
+
+    def exclusion_stats
+      {
+        excluded_exceptions: @excluded_exceptions.length,
+        excluded_patterns: @excluded_patterns.length,
+        excluded_messages: @excluded_messages.length,
+        excluded_environments: @excluded_environments.length,
+        custom_filters: @custom_filters.length,
+        inclusion_overrides: @inclusion_overrides.length
+      }
+    end
+
+    private
+
+    def should_include_override?(event)
+      @inclusion_overrides.any? { |filter| filter.call(event) }
+    end
+
+    def excluded_by_exception_type?(event)
+      return false unless event.exception
+
+      exception_class = event.exception.class
+
+      @excluded_exceptions.any? do |excluded|
+        case excluded
+        when Class
+          exception_class <= excluded
+        when String
+          exception_class.name == excluded || exception_class.name.include?(excluded)
+        when Regexp
+          exception_class.name.match?(excluded)
+        else
+          false
+        end
+      end
+    end
+
+    def excluded_by_pattern?(event)
+      return false unless event.exception
+
+      exception_class = event.exception.class
+      exception_message = event.exception.message
+
+      @excluded_patterns.any? do |pattern|
+        case pattern
+        when Regexp
+          exception_class.name.match?(pattern) || exception_message.match?(pattern)
+        when String
+          exception_class.name.include?(pattern) || exception_message.include?(pattern)
+        else
+          false
+        end
+      end
+    end
+
+    def excluded_by_message?(event)
+      return false unless event.exception
+
+      exception_message = event.exception.message
+
+      @excluded_messages.any? do |excluded_message|
+        case excluded_message
+        when Regexp
+          exception_message.match?(excluded_message)
+        when String
+          exception_message.include?(excluded_message)
+        else
+          false
+        end
+      end
+    end
+
+    def excluded_by_environment?(event)
+      return false if @excluded_environments.empty?
+
+      environment = event.context[:environment] ||
+                    event.context.dig(:tags, :environment) ||
+                    Lapsoss.configuration.environment
+
+      return false unless environment
+
+      @excluded_environments.include?(environment.to_s)
+    end
+
+    def excluded_by_custom_filter?(event)
+      @custom_filters.any? { |filter| filter.call(event) }
+    end
+  end
+end

data/lib/lapsoss/{exclusions.rb → exclusion_presets.rb}

@@ -1,159 +1,6 @@
 # frozen_string_literal: true
 
 module Lapsoss
-  # Error exclusion system for filtering exception types
-  class ExclusionFilter
-    def initialize(configuration = {})
-      @excluded_exceptions = configuration[:excluded_exceptions] || []
-      @excluded_patterns = configuration[:excluded_patterns] || []
-      @excluded_messages = configuration[:excluded_messages] || []
-      @excluded_environments = configuration[:excluded_environments] || []
-      @custom_filters = configuration[:custom_filters] || []
-      @inclusion_overrides = configuration[:inclusion_overrides] || []
-    end
-
-    def should_exclude?(event)
-      # Check inclusion overrides first - these take precedence
-      return false if should_include_override?(event)
-
-      # Apply exclusion filters
-      return true if excluded_by_exception_type?(event)
-      return true if excluded_by_pattern?(event)
-      return true if excluded_by_message?(event)
-      return true if excluded_by_environment?(event)
-      return true if excluded_by_custom_filter?(event)
-
-      false
-    end
-
-    def add_exclusion(type, value)
-      case type
-      when :exception
-        @excluded_exceptions << value
-      when :pattern
-        @excluded_patterns << value
-      when :message
-        @excluded_messages << value
-      when :environment
-        @excluded_environments << value
-      when :custom
-        @custom_filters << value
-      else
-        raise ArgumentError, "Unknown exclusion type: #{type}"
-      end
-    end
-
-    def add_inclusion_override(filter)
-      @inclusion_overrides << filter
-    end
-
-    def clear_exclusions(type = nil)
-      if type
-        case type
-        when :exception then @excluded_exceptions.clear
-        when :pattern then @excluded_patterns.clear
-        when :message then @excluded_messages.clear
-        when :environment then @excluded_environments.clear
-        when :custom then @custom_filters.clear
-        else raise ArgumentError, "Unknown exclusion type: #{type}"
-        end
-      else
-        @excluded_exceptions.clear
-        @excluded_patterns.clear
-        @excluded_messages.clear
-        @excluded_environments.clear
-        @custom_filters.clear
-      end
-    end
-
-    def exclusion_stats
-      {
-        excluded_exceptions: @excluded_exceptions.length,
-        excluded_patterns: @excluded_patterns.length,
-        excluded_messages: @excluded_messages.length,
-        excluded_environments: @excluded_environments.length,
-        custom_filters: @custom_filters.length,
-        inclusion_overrides: @inclusion_overrides.length
-      }
-    end
-
-    private
-
-    def should_include_override?(event)
-      @inclusion_overrides.any? { |filter| filter.call(event) }
-    end
-
-    def excluded_by_exception_type?(event)
-      return false unless event.exception
-
-      exception_class = event.exception.class
-
-      @excluded_exceptions.any? do |excluded|
-        case excluded
-        when Class
-          exception_class <= excluded
-        when String
-          exception_class.name == excluded || exception_class.name.include?(excluded)
-        when Regexp
-          exception_class.name.match?(excluded)
-        else
-          false
-        end
-      end
-    end
-
-    def excluded_by_pattern?(event)
-      return false unless event.exception
-
-      exception_class = event.exception.class
-      exception_message = event.exception.message
-
-      @excluded_patterns.any? do |pattern|
-        case pattern
-        when Regexp
-          exception_class.name.match?(pattern) || exception_message.match?(pattern)
-        when String
-          exception_class.name.include?(pattern) || exception_message.include?(pattern)
-        else
-          false
-        end
-      end
-    end
-
-    def excluded_by_message?(event)
-      return false unless event.exception
-
-      exception_message = event.exception.message
-
-      @excluded_messages.any? do |excluded_message|
-        case excluded_message
-        when Regexp
-          exception_message.match?(excluded_message)
-        when String
-          exception_message.include?(excluded_message)
-        else
-          false
-        end
-      end
-    end
-
-    def excluded_by_environment?(event)
-      return false if @excluded_environments.empty?
-
-      environment = event.context[:environment] ||
-                   event.context.dig(:tags, :environment) ||
-                   Lapsoss.configuration.environment
-
-      return false unless environment
-
-      @excluded_environments.include?(environment.to_s)
-    end
-
-    def excluded_by_custom_filter?(event)
-      @custom_filters.any? { |filter| filter.call(event) }
-    end
-  end
-
   # Predefined exclusion configurations for common use cases
   class ExclusionPresets
     def self.development
@@ -315,7 +162,7 @@ module Lapsoss
         custom_filters: [
           # Exclude high-frequency errors during peak times
           lambda do |event|
-            now = Time.now
+            now = Time.zone.now
             peak_hours = (9..17).cover?(now.hour) && (1..5).cover?(now.wday)
 
             if peak_hours
@@ -399,31 +246,4 @@ module Lapsoss
       combined_config
     end
   end
-
-  # 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