lapsoss 0.2.0 → 0.3.0

data/lib/lapsoss/exclusion_filter.rb

@@ -153,277 +153,4 @@ module Lapsoss
       @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.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
-
-  # 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

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'digest'
+require "digest"
 
 module Lapsoss
   class Fingerprinter
@@ -8,61 +8,61 @@ module Lapsoss
       # User/ID normalization patterns
       {
         pattern: /User \d+ (not found|invalid|missing)/i,
-        fingerprint: 'user-lookup-error'
+        fingerprint: "user-lookup-error"
       },
       {
         pattern: /Record \d+ (not found|invalid|missing)/i,
-        fingerprint: 'record-lookup-error'
+        fingerprint: "record-lookup-error"
       },
 
       # URL/Path normalization patterns
       {
         pattern: %r{/users/\d+(/.*)?},
-        fingerprint: 'users-id-endpoint'
+        fingerprint: "users-id-endpoint"
       },
       {
         pattern: %r{/api/v\d+/.*},
-        fingerprint: 'api-endpoint'
+        fingerprint: "api-endpoint"
       },
 
       # Database error patterns
       {
         pattern: /PG::ConnectionBad|Mysql2::Error|SQLite3::BusyException/,
-        fingerprint: 'database-connection-error'
+        fingerprint: "database-connection-error"
       },
       {
         pattern: /ActiveRecord::RecordNotFound/,
-        fingerprint: 'record-not-found'
+        fingerprint: "record-not-found"
       },
       {
         pattern: /ActiveRecord::StatementInvalid.*timeout/i,
-        fingerprint: 'database-timeout'
+        fingerprint: "database-timeout"
       },
 
       # Network error patterns
       {
         pattern: /Net::(TimeoutError|ReadTimeout|OpenTimeout)/,
-        fingerprint: 'network-timeout'
+        fingerprint: "network-timeout"
       },
       {
         pattern: /Errno::(ECONNREFUSED|ECONNRESET|EHOSTUNREACH)/,
-        fingerprint: 'network-connection-error'
+        fingerprint: "network-connection-error"
       },
 
       # File system patterns
       {
         pattern: %r{Errno::(ENOENT|EACCES).*/tmp/},
-        fingerprint: 'tmp-file-error'
+        fingerprint: "tmp-file-error"
       },
       {
         pattern: /No such file or directory.*\.log/,
-        fingerprint: 'log-file-missing'
+        fingerprint: "log-file-missing"
       },
 
       # Memory/Resource patterns
       {
         pattern: /NoMemoryError|SystemStackError/,
-        fingerprint: 'memory-resource-error'
+        fingerprint: "memory-resource-error"
       }
     ].freeze
 
@@ -123,7 +123,7 @@ module Lapsoss
       # Include first few backtrace lines for context
       parts.concat(event.exception.backtrace.first(3)) if event.exception&.backtrace
 
-      parts.compact.join(' ')
+      parts.compact.join(" ")
     end
 
     def generate_default_fingerprint(event)
@@ -141,7 +141,7 @@ module Lapsoss
         primary_location = extract_primary_location(event.exception.backtrace)
         components << primary_location if primary_location
       elsif event.message
-        components << 'message'
+        components << "message"
         components << normalize_message(event.message)
       end
 
@@ -149,7 +149,7 @@ module Lapsoss
       components << event.environment if @include_environment && event.environment
 
       # Generate hash from components
-      content = components.compact.join('|')
+      content = components.compact.join("|")
       Digest::SHA256.hexdigest(content)[0, 16] # Use first 16 chars for readability
     end
 
@@ -160,29 +160,29 @@ module Lapsoss
 
       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')
+        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')
+        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')
+        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')
+        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')
+        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')
+        normalized.gsub!(%r{https?://[^\s]+}, ":url")
       end
 
       # Clean up extra whitespace
-      normalized.strip.squeeze(' ')
+      normalized.strip.squeeze(" ")
     end
 
     def extract_primary_location(backtrace)
@@ -190,10 +190,10 @@ module Lapsoss
 
       # Find first non-gem, non-framework line
       app_line = backtrace.find do |line|
-        line.exclude?('/gems/') &&
-          line.exclude?('/ruby/') &&
-          line.exclude?('(eval)') &&
-          !line.start_with?('[')
+        line.exclude?("/gems/") &&
+          line.exclude?("/ruby/") &&
+          line.exclude?("(eval)") &&
+          !line.start_with?("[")
       end
 
       line_to_use = app_line || backtrace.first