lapsoss 0.4.0 → 0.4.2

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

data/lib/lapsoss/sampling/health_based_sampler.rb

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

data/lib/lapsoss/sampling/sampling_factory.rb

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