lapsoss 0.4.0 → 0.4.4

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lapsoss
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.4
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -225,6 +225,7 @@ files:
 - lib/lapsoss/adapters/logger_adapter.rb
 - lib/lapsoss/adapters/rollbar_adapter.rb
 - lib/lapsoss/adapters/sentry_adapter.rb
+- lib/lapsoss/adapters/telebug_adapter.rb
 - lib/lapsoss/backtrace_frame.rb
 - lib/lapsoss/backtrace_frame_factory.rb
 - lib/lapsoss/backtrace_processor.rb
@@ -234,9 +235,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 +247,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

data/lib/lapsoss/exclusion_presets.rb

@@ -1,249 +0,0 @@
-# frozen_string_literal: true
-
-module Lapsoss
-  # Predefined exclusion configurations for common use cases
-  class ExclusionPresets
-    def self.development
-      {
-        excluded_exceptions: [
-          # Test-related exceptions
-          "RSpec::Expectations::ExpectationNotMetError",
-          "Minitest::Assertion",
-
-          # Development tools
-          "Pry::CommandError",
-          "Byebug::CommandError"
-        ],
-        excluded_patterns: [
-          /test/i,
-          /spec/i,
-          /debug/i,
-          /development/i
-        ],
-        excluded_environments: %w[test]
-      }
-    end
-
-    def self.production
-      {
-        excluded_exceptions: [
-          # Common Rails exceptions that are usually not actionable
-          "ActionController::RoutingError",
-          "ActionController::UnknownFormat",
-          "ActionController::BadRequest",
-          "ActionController::ParameterMissing",
-
-          # ActiveRecord exceptions for common user errors
-          "ActiveRecord::RecordNotFound",
-          "ActiveRecord::RecordInvalid",
-
-          # Network timeouts that are expected
-          "Net::ReadTimeout",
-          "Net::OpenTimeout",
-          "Timeout::Error"
-        ],
-        excluded_patterns: [
-          # Bot and crawler patterns
-          /bot/i,
-          /crawler/i,
-          /spider/i,
-          /scraper/i,
-
-          # Security scanning patterns
-          /sql.*injection/i,
-          /xss/i,
-          /csrf/i,
-
-          # Common attack patterns
-          /\.php$/i,
-          /\.asp$/i,
-          /wp-admin/i,
-          /wp-login/i
-        ],
-        excluded_messages: [
-          # Common spam/attack messages
-          "No route matches",
-          "Invalid authenticity token",
-          "Forbidden",
-          "Unauthorized"
-        ]
-      }
-    end
-
-    def self.staging
-      {
-        excluded_exceptions: [
-          # Test data related errors
-          "ActiveRecord::RecordNotFound",
-          "ArgumentError"
-        ],
-        excluded_patterns: [
-          /test/i,
-          /staging/i,
-          /dummy/i,
-          /fake/i
-        ],
-        excluded_environments: %w[test development]
-      }
-    end
-
-    def self.security_focused
-      {
-        excluded_patterns: [
-          # Exclude common security scanning attempts
-          /\.php$/i,
-          /\.asp$/i,
-          /\.jsp$/i,
-          /wp-admin/i,
-          /wp-login/i,
-          /phpmyadmin/i,
-          /admin/i,
-          /login\.php/i,
-          /index\.php/i,
-
-          # SQL injection attempts
-          /union.*select/i,
-          /insert.*into/i,
-          /drop.*table/i,
-          /delete.*from/i,
-
-          # XSS attempts
-          /<script/i,
-          /javascript:/i,
-          /onclick=/i,
-          /onerror=/i
-        ],
-        excluded_messages: [
-          "Invalid authenticity token",
-          "Forbidden",
-          "Unauthorized",
-          "Access denied"
-        ],
-        custom_filters: [
-          # Exclude requests from known bot user agents
-          lambda do |event|
-            user_agent = event.context.dig(:request, :headers, "User-Agent")
-            return false unless user_agent
-
-            bot_patterns = [
-              /googlebot/i,
-              /bingbot/i,
-              /slurp/i,
-              /crawler/i,
-              /spider/i,
-              /bot/i
-            ]
-
-            bot_patterns.any? { |pattern| user_agent.match?(pattern) }
-          end
-        ]
-      }
-    end
-
-    def self.performance_focused
-      {
-        excluded_exceptions: [
-          # Timeout exceptions that are expected under load
-          "Net::ReadTimeout",
-          "Net::OpenTimeout",
-          "Timeout::Error",
-          "Redis::TimeoutError",
-
-          # Memory and resource limits
-          "NoMemoryError",
-          "SystemStackError"
-        ],
-        excluded_patterns: [
-          /timeout/i,
-          /memory/i,
-          /resource/i,
-          /limit/i
-        ],
-        custom_filters: [
-          # Exclude high-frequency errors during peak times
-          lambda do |event|
-            now = Time.zone.now
-            peak_hours = (9..17).cover?(now.hour) && (1..5).cover?(now.wday)
-
-            if peak_hours
-              # During peak hours, exclude common performance-related errors
-              return true if event.exception.is_a?(Timeout::Error)
-              return true if event.exception.message.match?(/timeout/i)
-            end
-
-            false
-          end
-        ]
-      }
-    end
-
-    def self.user_error_focused
-      {
-        excluded_exceptions: [
-          # User input validation errors
-          "ActiveModel::ValidationError",
-          "ActiveRecord::RecordInvalid",
-          "ActionController::ParameterMissing",
-          "ArgumentError",
-          "TypeError"
-        ],
-        excluded_patterns: [
-          /validation/i,
-          /invalid/i,
-          /missing/i,
-          /required/i,
-          /format/i
-        ],
-        custom_filters: [
-          # Exclude errors from invalid user input
-          lambda do |event|
-            return false unless event.exception
-
-            # Check if error is from user input validation
-            message = event.exception.message.downcase
-            validation_keywords = %w[invalid required missing format validation]
-
-            validation_keywords.any? { |keyword| message.include?(keyword) }
-          end
-        ]
-      }
-    end
-
-    def self.combined(presets)
-      combined_config = {
-        excluded_exceptions: [],
-        excluded_patterns: [],
-        excluded_messages: [],
-        excluded_environments: [],
-        custom_filters: []
-      }
-
-      presets.each do |preset|
-        config = case preset
-        when :development then development
-        when :production then production
-        when :staging then staging
-        when :security_focused then security_focused
-        when :performance_focused then performance_focused
-        when :user_error_focused then user_error_focused
-        when Hash then preset
-        else raise ArgumentError, "Unknown preset: #{preset}"
-        end
-
-        combined_config[:excluded_exceptions].concat(config[:excluded_exceptions] || [])
-        combined_config[:excluded_patterns].concat(config[:excluded_patterns] || [])
-        combined_config[:excluded_messages].concat(config[:excluded_messages] || [])
-        combined_config[:excluded_environments].concat(config[:excluded_environments] || [])
-        combined_config[:custom_filters].concat(config[:custom_filters] || [])
-      end
-
-      # Remove duplicates
-      combined_config[:excluded_exceptions].uniq!
-      combined_config[:excluded_patterns].uniq!
-      combined_config[:excluded_messages].uniq!
-      combined_config[:excluded_environments].uniq!
-
-      combined_config
-    end
-  end
-end

data/lib/lapsoss/middleware/sample_filter.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Lapsoss
-  module Middleware
-    class SampleFilter < Base
-      def initialize(app, sample_rate: 1.0, sample_callback: nil)
-        super(app)
-        @sample_rate = sample_rate
-        @sample_callback = sample_callback
-      end
-
-      def call(event, hint = {})
-        # Apply custom sampling logic first
-        return nil if @sample_callback && !@sample_callback.call(event, hint)
-
-        # Apply rate-based sampling
-        return nil if (@sample_rate < 1.0) && (rand > @sample_rate)
-
-        @app.call(event, hint)
-      end
-    end
-  end
-end

data/lib/lapsoss/middleware/sampling_middleware.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Lapsoss
-  module Middleware
-    class SamplingMiddleware < Base
-      def initialize(app, sampler)
-        super(app)
-        @sampler = sampler
-      end
-
-      def call(event, hint = {})
-        return nil unless @sampler.sample?(event, hint)
-
-        @app.call(event, hint)
-      end
-    end
-  end
-end

data/lib/lapsoss/middleware/user_context_enhancer.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Lapsoss
-  module Middleware
-    class UserContextEnhancer < Base
-      def initialize(app, user_provider: nil, privacy_mode: false)
-        super(app)
-        @user_provider = user_provider
-        @privacy_mode = privacy_mode
-      end
-
-      def call(event, hint = {})
-        enhance_user_context(event, hint)
-        @app.call(event, hint)
-      end
-
-      private
-
-      def enhance_user_context(event, hint)
-        # Get user from provider if available
-        user_data = @user_provider&.call(event, hint) || {}
-
-        # Merge with existing user context
-        existing_user = event.context[:user] || {}
-        enhanced_user = existing_user.merge(user_data)
-
-        # Apply privacy filtering if enabled
-        enhanced_user = apply_privacy_filtering(enhanced_user) if @privacy_mode
-
-        event.context[:user] = enhanced_user unless enhanced_user.empty?
-      end
-
-      def apply_privacy_filtering(user_data)
-        # Remove sensitive fields in privacy mode
-        sensitive_fields = %i[email phone address ssn credit_card]
-        filtered = user_data.dup
-
-        sensitive_fields.each do |field|
-          filtered[field] = "[FILTERED]" if filtered.key?(field)
-        end
-
-        filtered
-      end
-    end
-  end
-end

data/lib/lapsoss/release_providers.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module Lapsoss
-  # Built-in release providers for common scenarios
-  class ReleaseProviders
-    def self.from_file(file_path)
-      lambda do
-        return nil unless File.exist?(file_path)
-
-        content = File.read(file_path).strip
-        return nil if content.empty?
-
-        # Try to parse as JSON first
-        begin
-          JSON.parse(content)
-        rescue JSON::ParserError
-          # Treat as plain text version
-          { version: content }
-        end
-      end
-    end
-
-    def self.from_ruby_constant(constant_name)
-      lambda do
-        constant = Object.const_get(constant_name)
-        { version: constant.to_s }
-      rescue NameError
-        nil
-      end
-    end
-
-    def self.from_gemfile_lock
-      lambda do
-        return nil unless File.exist?("Gemfile.lock")
-
-        content = File.read("Gemfile.lock")
-
-        # Extract gems with versions
-        gems = {}
-        content.scan(/^\s{4}(\w+)\s+\(([^)]+)\)/).each do |name, version|
-          gems[name] = version
-        end
-
-        { gems: gems }
-      end
-    end
-
-    def self.from_package_json
-      lambda do
-        return nil unless File.exist?("package.json")
-
-        begin
-          package_info = JSON.parse(File.read("package.json"))
-          {
-            version: package_info["version"],
-            name: package_info["name"],
-            dependencies: package_info["dependencies"]&.keys
-          }.compact
-        rescue JSON::ParserError
-          nil
-        end
-      end
-    end
-
-    def self.from_rails_application
-      lambda do
-        return nil unless defined?(Rails) && Rails.respond_to?(:application)
-
-        app = Rails.application
-        return nil unless app
-
-        info = {
-          rails_version: Rails.version,
-          environment: Rails.env,
-          root: Rails.root.to_s
-        }
-
-        # Get application version if defined
-        info[:app_version] = app.class.version if app.class.respond_to?(:version)
-
-        # Get application name
-        info[:app_name] = app.class.name if app.class.respond_to?(:name)
-
-        info
-      end
-    end
-
-    def self.from_capistrano
-      lambda do
-        # Check for Capistrano deployment files
-        %w[REVISION current/REVISION].each do |file|
-          next unless File.exist?(file)
-
-          revision = File.read(file).strip
-          next if revision.empty?
-
-          return {
-            revision: revision,
-            deployed_at: File.mtime(file),
-            deployment_method: "capistrano"
-          }
-        end
-
-        nil
-      end
-    end
-  end
-end

data/lib/lapsoss/sampling/adaptive_sampler.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Lapsoss
-  module Sampling
-    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.zone.now
-        @mutex = Mutex.new
-      end
-
-      def sample?(_event, _hint = {})
-        @mutex.synchronize do
-          @events_count += 1
-
-          # Adjust rate periodically
-          now = Time.zone.now
-          if now - @last_adjustment > @adjustment_period
-            adjust_rate
-            @last_adjustment = now
-            @events_count = 0
-          end
-        end
-
-        @current_rate > rand
-      end
-
-      attr_reader :current_rate
-
-      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
-  end
-end

data/lib/lapsoss/sampling/composite_sampler.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Lapsoss
-  module Sampling
-    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
-  end
-end

data/lib/lapsoss/sampling/consistent_hash_sampler.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require "digest"
-
-module Lapsoss
-  module Sampling
-    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
-  end
-end

data/lib/lapsoss/sampling/exception_type_sampler.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Lapsoss
-  module Sampling
-    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
-  end
-end