lapsoss 0.1.0

data/lib/lapsoss/exclusions.rb

@@ -0,0 +1,429 @@
+# 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
+      {
+        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.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
+
+  # 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/fingerprinter.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Lapsoss
+  class Fingerprinter
+    DEFAULT_PATTERNS = [
+      # User/ID normalization patterns
+      {
+        pattern: /User \d+ (not found|invalid|missing)/i,
+        fingerprint: "user-lookup-error"
+      },
+      {
+        pattern: /Record \d+ (not found|invalid|missing)/i,
+        fingerprint: "record-lookup-error"
+      },
+
+      # URL/Path normalization patterns
+      {
+        pattern: %r{/users/\d+(/.*)?},
+        fingerprint: "users-id-endpoint"
+      },
+      {
+        pattern: %r{/api/v\d+/.*},
+        fingerprint: "api-endpoint"
+      },
+
+      # Database error patterns
+      {
+        pattern: /PG::ConnectionBad|Mysql2::Error|SQLite3::BusyException/,
+        fingerprint: "database-connection-error"
+      },
+      {
+        pattern: /ActiveRecord::RecordNotFound/,
+        fingerprint: "record-not-found"
+      },
+      {
+        pattern: /ActiveRecord::StatementInvalid.*timeout/i,
+        fingerprint: "database-timeout"
+      },
+
+      # Network error patterns
+      {
+        pattern: /Net::(TimeoutError|ReadTimeout|OpenTimeout)/,
+        fingerprint: "network-timeout"
+      },
+      {
+        pattern: /Errno::(ECONNREFUSED|ECONNRESET|EHOSTUNREACH)/,
+        fingerprint: "network-connection-error"
+      },
+
+      # File system patterns
+      {
+        pattern: /Errno::(ENOENT|EACCES).*\/tmp\//,
+        fingerprint: "tmp-file-error"
+      },
+      {
+        pattern: /No such file or directory.*\.log/,
+        fingerprint: "log-file-missing"
+      },
+
+      # Memory/Resource patterns
+      {
+        pattern: /NoMemoryError|SystemStackError/,
+        fingerprint: "memory-resource-error"
+      }
+    ].freeze
+
+    def initialize(config = {})
+      @custom_callback = config[:custom_callback]
+      @patterns = config[:patterns] || DEFAULT_PATTERNS
+      @normalize_paths = config.fetch(:normalize_paths, true)
+      @normalize_ids = config.fetch(:normalize_ids, true)
+      @include_environment = config.fetch(:include_environment, false)
+    end
+
+    def generate_fingerprint(event)
+      # Try custom callback first
+      if @custom_callback
+        custom_result = @custom_callback.call(event)
+        return custom_result if custom_result
+      end
+
+      # Try pattern matching
+      pattern_result = match_patterns(event)
+      return pattern_result if pattern_result
+
+      # Fall back to default fingerprinting
+      generate_default_fingerprint(event)
+    end
+
+    private
+
+    def match_patterns(event)
+      full_error_text = build_error_text(event)
+
+      @patterns.each do |pattern_config|
+        pattern = pattern_config[:pattern]
+        fingerprint = pattern_config[:fingerprint]
+
+        if pattern.is_a?(Regexp) && full_error_text.match?(pattern)
+          return fingerprint
+        elsif pattern.is_a?(String) && full_error_text.include?(pattern)
+          return fingerprint
+        end
+      end
+
+      nil
+    end
+
+    def build_error_text(event)
+      parts = []
+
+      # Include exception class
+      if event.exception
+        parts << event.exception.class.name
+        parts << event.exception.message if event.exception.message
+      end
+
+      # Include event message
+      parts << event.message if event.message
+
+      # Include first few backtrace lines for context
+      if event.exception&.backtrace
+        parts.concat(event.exception.backtrace.first(3))
+      end
+
+      parts.compact.join(" ")
+    end
+
+    def generate_default_fingerprint(event)
+      components = []
+
+      # Exception type
+      if event.exception
+        components << event.exception.class.name
+
+        # Normalized message
+        message = normalize_message(event.exception.message)
+        components << message if message
+
+        # Primary stack frame location
+        primary_location = extract_primary_location(event.exception.backtrace)
+        components << primary_location if primary_location
+      elsif event.message
+        components << "message"
+        components << normalize_message(event.message)
+      end
+
+      # Include environment if configured
+      if @include_environment && event.environment
+        components << event.environment
+      end
+
+      # Generate hash from components
+      content = components.compact.join("|")
+      Digest::SHA256.hexdigest(content)[0, 16] # Use first 16 chars for readability
+    end
+
+    def normalize_message(message)
+      return nil unless message
+
+      normalized = message.dup
+
+      if @normalize_ids
+        # Replace UUIDs first (before numeric IDs)
+        normalized.gsub!(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i, ":uuid")
+
+        # Replace hex hashes with placeholder
+        normalized.gsub!(/\b[0-9a-f]{32,}\b/i, ":hash")
+
+        # Replace numeric IDs with placeholder (after UUIDs and hashes)
+        normalized.gsub!(/\b\d{3,}\b/, ":id")
+      end
+
+      if @normalize_paths
+        # Replace absolute file paths with placeholder
+        normalized.gsub!(%r{/[^/\s]+(?:/[^/\s]+)*\.[a-zA-Z0-9]+}, ":filepath")
+        normalized.gsub!(%r{/[^/\s]+(?:/[^/\s]+)+(?:/)?}, ":dirpath")
+
+        # Replace timestamps
+        normalized.gsub!(/\b\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}/, ":timestamp")
+
+        # Replace URLs with placeholder
+        normalized.gsub!(%r{https?://[^\s]+}, ":url")
+      end
+
+      # Clean up extra whitespace
+      normalized.strip.squeeze(" ")
+    end
+
+    def extract_primary_location(backtrace)
+      return nil unless backtrace&.any?
+
+      # Find first non-gem, non-framework line
+      app_line = backtrace.find do |line|
+        !line.include?("/gems/") &&
+        !line.include?("/ruby/") &&
+        !line.include?("(eval)") &&
+        !line.start_with?("[")
+      end
+
+      line_to_use = app_line || backtrace.first
+
+      if @normalize_paths
+        # Extract just filename:line_number
+        if line_to_use.match(%r{([^/]+):(\d+)})
+          "#{$1}:#{$2}"
+        else
+          line_to_use
+        end
+      else
+        line_to_use
+      end
+    end
+  end
+end