lapsoss 0.4.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0faf08671ef4e1b0b36ccc9e29900b8e8b5e4a78ac61ffea6269294efee5881
-  data.tar.gz: b2c76c33817f3a939388970d21c5fc341ad6ce46e0ce20ef9b71ca5b5c565ae0
+  metadata.gz: 93ff41a78372ad8d5080a5b7d87c2783a1f5834020df285e2db5eb28f0a54d61
+  data.tar.gz: 1cbceab257813d8e7659d9a31abd2cfba0a33a6f5585776ed426c984c32a61e4
 SHA512:
-  metadata.gz: 5cfb22826215ffc2473410d6e984ecbd93f74ec0c011e742d7246549b29c1d77b9cb81c774cab311748c0b39cbfd9b9eccfdbb4324aa6da7a632ba8634eb3b19
-  data.tar.gz: f641a491be8007a0bc6780094803724f66efc79aa1e10cadbb1ac96c84a8ff30af119c763e1611dc3e2218305c4d0b5958b6f5c5f2863c7b5694b5ff7c9f0856
+  metadata.gz: da64a5b1ec01779137189432e8dfba438e3768a1af44f71de44f3827c6ef3f2eb27b49d1b6d88479a23c51218e328f4068a86b4e210a2f73b869d2ff7167bb30
+  data.tar.gz: 126e54769b4f4ad8dad6617c27b5a80aeba5ae073879b462c8c6e01346fbc6a78029aca8589b028b6eccf9900fd1cc24e8072d119098190dbb86ac0b88521eba

data/README.md

@@ -196,23 +196,82 @@ Lapsoss.configure do |config|
   # Data scrubbing (uses Rails filter_parameters automatically)
   config.scrub_fields = %w[password credit_card ssn] # Or leave nil to use Rails defaults
 
-  # Error filtering
+  # Performance
+  config.async = true # Send errors in background
+
+  # Sampling (see docs/sampling_strategies.md for advanced examples)
+  config.sample_rate = Rails.env.production? ? 0.25 : 1.0
+  
+  # Transport settings
+  config.transport_timeout = 10 # seconds
+  config.transport_max_retries = 3
+end
+```
+
+### Filtering Errors
+
+You decide what errors to track. Lapsoss doesn't make assumptions:
+
+```ruby
+Lapsoss.configure do |config|
+  # Use the before_send callback for simple filtering
   config.before_send = lambda do |event|
     # Return nil to prevent sending
     return nil if event.exception.is_a?(ActiveRecord::RecordNotFound)
     event
   end
+  
+  # Or use the exclusion filter for more complex rules
+  config.exclusion_filter = Lapsoss::ExclusionFilter.new(
+    # Exclude specific exception types
+    excluded_exceptions: [
+      "ActionController::RoutingError",  # Your choice
+      "ActiveRecord::RecordNotFound"     # Your decision
+    ],
+    
+    # Exclude by pattern matching
+    excluded_patterns: [
+      /timeout/i,           # If timeouts are expected in your app
+      /user not found/i     # If these are normal in your workflow
+    ],
+    
+    # Exclude specific error messages
+    excluded_messages: [
+      "No route matches",
+      "Invalid authenticity token"
+    ]
+  )
+  
+  # Add custom exclusion logic
+  config.exclusion_filter.add_exclusion(:custom, lambda do |event|
+    # Your business logic here
+    event.context[:request]&.dig(:user_agent)&.match?(/bot/i)
+  end)
+end
+```
 
-  # Sampling
-  config.sample_rate = Rails.env.production? ? 0.25 : 1.0
+#### Common Patterns (Your Choice)
 
-  # Performance
-  config.async = true # Send errors in background
-  config.transport_timeout = 10 # seconds
-  config.transport_max_retries = 3
+```ruby
+# Development/Test exclusions
+if Rails.env.development?
+  config.exclusion_filter.add_exclusion(:exception, "RSpec::Expectations::ExpectationNotMetError")
+  config.exclusion_filter.add_exclusion(:exception, "Minitest::Assertion")
 end
+
+# User input errors (if you don't want to track them)
+config.exclusion_filter.add_exclusion(:exception, "ActiveRecord::RecordInvalid")
+config.exclusion_filter.add_exclusion(:exception, "ActionController::ParameterMissing")
+
+# Bot traffic (if you want to exclude it)
+config.exclusion_filter.add_exclusion(:custom, lambda do |event|
+  request = event.context[:request]
+  request && request[:user_agent]&.match?(/googlebot|bingbot/i)
+end)
 ```
 
+Your app, your rules. Lapsoss just provides the mechanism.
+
 ### Data Protection
 
 Lapsoss automatically integrates with Rails' parameter filtering:

data/lib/lapsoss/client.rb

@@ -103,9 +103,7 @@ module Lapsoss
     end
 
     def handle_capture_error(error)
-      return unless @configuration.logger
-
-      @configuration.logger.error("[Lapsoss] Failed to capture event: #{error.message}")
+      @configuration.logger.error("Failed to capture event: #{error.message}")
     end
   end
 end

data/lib/lapsoss/configuration.rb

@@ -21,7 +21,7 @@ module Lapsoss
     def initialize
       @adapter_configs = {}
       @async = true
-      @logger = nil
+      @logger = Logger.new(nil) # Default null logger
       @environment = nil
       @enabled = true
       @release = nil
@@ -193,17 +193,8 @@ module Lapsoss
 
     def create_sampling_strategy
       case @sampling_strategy
-      when Symbol
-        case @sampling_strategy
-        when :production
-          Sampling::SamplingFactory.create_production_sampling
-        when :development
-          Sampling::SamplingFactory.create_development_sampling
-        when :user_focused
-          Sampling::SamplingFactory.create_user_focused_sampling
-        else
-          Sampling::UniformSampler.new(@sample_rate)
-        end
+      when Numeric
+        Sampling::UniformSampler.new(@sampling_strategy)
       when Proc
         @sampling_strategy
       when nil
@@ -276,7 +267,7 @@ module Lapsoss
     def validate!
       # Check sample rate is between 0 and 1
       if @sample_rate && (@sample_rate < 0 || @sample_rate > 1)
-        logger&.warn "[Lapsoss] sample_rate should be between 0 and 1, got #{@sample_rate}"
+        logger.warn "sample_rate should be between 0 and 1, got #{@sample_rate}"
       end
 
       # Check callables
@@ -289,21 +280,21 @@ module Lapsoss
 
       # Just log if transport settings look unusual
       if @transport_timeout && @transport_timeout <= 0
-        logger&.warn "[Lapsoss] transport_timeout should be positive, got #{@transport_timeout}"
+        logger.warn "transport_timeout should be positive, got #{@transport_timeout}"
       end
 
       if @transport_max_retries && @transport_max_retries < 0
-        logger&.warn "[Lapsoss] transport_max_retries should be non-negative, got #{@transport_max_retries}"
+        logger.warn "transport_max_retries should be non-negative, got #{@transport_max_retries}"
       end
 
       if @transport_initial_backoff && @transport_max_backoff && @transport_initial_backoff > @transport_max_backoff
-        logger&.warn "[Lapsoss] transport_initial_backoff (#{@transport_initial_backoff}) should be less than transport_max_backoff (#{@transport_max_backoff})"
+        logger.warn "transport_initial_backoff (#{@transport_initial_backoff}) should be less than transport_max_backoff (#{@transport_max_backoff})"
       end
 
       # Validate adapter configurations exist
       @adapter_configs.each do |name, config|
         if config[:type].blank?
-          logger&.warn "[Lapsoss] Adapter '#{name}' has no type specified"
+          logger.warn "Adapter '#{name}' has no type specified"
         end
       end
 

data/lib/lapsoss/fingerprinter.rb

@@ -4,8 +4,9 @@ require "digest"
 
 module Lapsoss
   class Fingerprinter
-    DEFAULT_PATTERNS = [
-      # User/ID normalization patterns
+    # Base patterns that are always available
+    BASE_PATTERNS = [
+      # Generic error message normalization
       {
         pattern: /User \d+ (not found|invalid|missing)/i,
         fingerprint: "user-lookup-error"
@@ -15,21 +16,25 @@ module Lapsoss
         fingerprint: "record-lookup-error"
       },
 
-      # URL/Path normalization patterns
+      # Network error patterns
       {
-        pattern: %r{/users/\d+(/.*)?},
-        fingerprint: "users-id-endpoint"
+        pattern: /Net::(TimeoutError|ReadTimeout|OpenTimeout)/,
+        fingerprint: "network-timeout"
       },
       {
-        pattern: %r{/api/v\d+/.*},
-        fingerprint: "api-endpoint"
+        pattern: /Errno::(ECONNREFUSED|ECONNRESET|EHOSTUNREACH)/,
+        fingerprint: "network-connection-error"
       },
 
-      # Database error patterns
+      # Memory/Resource patterns
       {
-        pattern: /PG::ConnectionBad|Mysql2::Error|SQLite3::BusyException/,
-        fingerprint: "database-connection-error"
-      },
+        pattern: /NoMemoryError|SystemStackError/,
+        fingerprint: "memory-resource-error"
+      }
+    ].freeze
+
+    # ActiveRecord-specific patterns (only loaded if ActiveRecord is defined)
+    ACTIVERECORD_PATTERNS = [
       {
         pattern: /ActiveRecord::RecordNotFound/,
         fingerprint: "record-not-found"
@@ -38,38 +43,34 @@ module Lapsoss
         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"
-      },
+        pattern: /ActiveRecord::ConnectionTimeoutError/,
+        fingerprint: "database-connection-timeout"
+      }
+    ].freeze
 
-      # File system patterns
+    # Database adapter patterns (only loaded if adapters are defined)
+    DATABASE_PATTERNS = [
       {
-        pattern: %r{Errno::(ENOENT|EACCES).*/tmp/},
-        fingerprint: "tmp-file-error"
+        pattern: /PG::ConnectionBad/,
+        fingerprint: "postgres-connection-error",
+        condition: -> { defined?(PG) }
       },
       {
-        pattern: /No such file or directory.*\.log/,
-        fingerprint: "log-file-missing"
+        pattern: /Mysql2::Error/,
+        fingerprint: "mysql-connection-error",
+        condition: -> { defined?(Mysql2) }
       },
-
-      # Memory/Resource patterns
       {
-        pattern: /NoMemoryError|SystemStackError/,
-        fingerprint: "memory-resource-error"
+        pattern: /SQLite3::BusyException/,
+        fingerprint: "sqlite-busy-error",
+        condition: -> { defined?(SQLite3) }
       }
     ].freeze
 
     def initialize(config = {})
       @custom_callback = config[:custom_callback]
-      @patterns = config[:patterns] || DEFAULT_PATTERNS
-      @normalize_paths = config.fetch(:normalize_paths, true)
+      @patterns = build_patterns(config[:patterns])
       @normalize_ids = config.fetch(:normalize_ids, true)
       @include_environment = config.fetch(:include_environment, false)
     end
@@ -91,6 +92,23 @@ module Lapsoss
 
     private
 
+    def build_patterns(custom_patterns)
+      return custom_patterns if custom_patterns
+
+      patterns = BASE_PATTERNS.dup
+
+      # Always include ActiveRecord patterns - they match on string names
+      patterns.concat(ACTIVERECORD_PATTERNS)
+
+      # Add database-specific patterns - they also match on string names
+      DATABASE_PATTERNS.each do |pattern_config|
+        # Skip the condition check - just match on error names
+        patterns << pattern_config.except(:condition)
+      end
+
+      patterns
+    end
+
     def match_patterns(event)
       full_error_text = build_error_text(event)
 
@@ -170,18 +188,9 @@ module Lapsoss
 
         # 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
@@ -201,13 +210,9 @@ module Lapsoss
 
       line_to_use = app_line || backtrace.first
 
-      if @normalize_paths
-        # Extract just filename:line_number
-        if line_to_use =~ %r{([^/]+):(\d+)}
-          "#{::Regexp.last_match(1)}:#{::Regexp.last_match(2)}"
-        else
-          line_to_use
-        end
+      # Extract just filename:line_number
+      if line_to_use =~ %r{([^/]+):(\d+)}
+        "#{::Regexp.last_match(1)}:#{::Regexp.last_match(2)}"
       else
         line_to_use
       end

data/lib/lapsoss/middleware/release_tracker.rb

@@ -3,114 +3,27 @@
 module Lapsoss
   module Middleware
     class ReleaseTracker < Base
-      def initialize(app, release_provider: nil)
+      def initialize(app, release: nil)
         super(app)
-        @release_provider = release_provider
+        @release = release
       end
 
       def call(event, hint = {})
-        add_release_info(event, hint)
+        if release = detect_release
+          event.context[:release] = release
+        end
         @app.call(event, hint)
       end
 
       private
 
-      def add_release_info(event, hint)
-        release_info = @release_provider&.call(event, hint) || auto_detect_release
-
-        event.context[:release] = release_info if release_info
-      end
-
-      def auto_detect_release
-        release_info = {}
-
-        # Try to detect Git information
-        if git_info = detect_git_info
-          release_info.merge!(git_info)
-        end
-
-        # Try to detect deployment info
-        if deployment_info = detect_deployment_info
-          release_info.merge!(deployment_info)
-        end
-
-        release_info.empty? ? nil : release_info
-      end
-
-      def detect_git_info
-        return nil unless File.exist?(".git")
-
-        begin
-          # Get current commit SHA
-          commit_sha = `git rev-parse HEAD`.strip
-          return nil if commit_sha.empty?
-
-          # Get branch name
-          branch = `git rev-parse --abbrev-ref HEAD`.strip
-          branch = nil if branch.empty? || branch == "HEAD"
-
-          # Get commit timestamp
-          commit_time = `git log -1 --format=%ct`.strip
-          commit_timestamp = commit_time.empty? ? nil : Time.zone.at(commit_time.to_i)
-
-          # Get tag if on a tag
-          tag = `git describe --exact-match --tags HEAD 2>/dev/null`.strip
-          tag = nil if tag.empty?
-
-          {
-            commit_sha: commit_sha,
-            branch: branch,
-            tag: tag,
-            commit_timestamp: commit_timestamp
-          }.compact
-        rescue StandardError
-          nil
-        end
-      end
-
-      def detect_deployment_info
-        info = {}
-
-        # Check common deployment environment variables
-        info[:deployment_id] = ENV["DEPLOYMENT_ID"] if ENV["DEPLOYMENT_ID"]
-        info[:build_number] = ENV["BUILD_NUMBER"] if ENV["BUILD_NUMBER"]
-        info[:deployment_time] = parse_deployment_time(ENV["DEPLOYMENT_TIME"]) if ENV["DEPLOYMENT_TIME"]
-
-        # Check Heroku
-        if ENV["HEROKU_APP_NAME"]
-          info[:platform] = "heroku"
-          info[:app_name] = ENV["HEROKU_APP_NAME"]
-          info[:dyno] = ENV.fetch("DYNO", nil)
-          info[:slug_commit] = ENV.fetch("HEROKU_SLUG_COMMIT", nil)
-        end
-
-        # Check AWS
-        if ENV["AWS_EXECUTION_ENV"]
-          info[:platform] = "aws"
-          info[:execution_env] = ENV["AWS_EXECUTION_ENV"]
-          info[:region] = ENV.fetch("AWS_REGION", nil)
-        end
-
-        # Check Docker
-        if ENV["DOCKER_CONTAINER_ID"] || File.exist?("/.dockerenv")
-          info[:platform] = "docker"
-          info[:container_id] = ENV["DOCKER_CONTAINER_ID"]
-        end
-
-        # Check Kubernetes
-        if ENV["KUBERNETES_SERVICE_HOST"]
-          info[:platform] = "kubernetes"
-          info[:namespace] = ENV.fetch("KUBERNETES_NAMESPACE", nil)
-          info[:pod_name] = ENV.fetch("HOSTNAME", nil)
-        end
-
-        info.empty? ? nil : info
-      end
+      def detect_release
+        # Use configured release
+        return @release.call if @release.respond_to?(:call)
+        return @release if @release.present?
 
-      def parse_deployment_time(time_str)
-        Time.zone.parse(time_str)
-      rescue StandardError
-        nil
+        # Use rails_app_version gem if available
+        Rails.application.version.to_s if defined?(Rails) && Rails.application.respond_to?(:version)
       end
     end
   end

data/lib/lapsoss/pipeline_builder.rb

@@ -25,8 +25,8 @@ module Lapsoss
       self
     end
 
-    def track_releases(provider: nil)
-      @pipeline.use(Middleware::ReleaseTracker, release_provider: provider)
+    def track_releases(release: nil)
+      @pipeline.use(Middleware::ReleaseTracker, release: release)
       self
     end
 

data/lib/lapsoss/rails_middleware.rb

@@ -10,14 +10,14 @@ module Lapsoss
       Lapsoss::Current.with_clean_scope do
         # Add request context to current scope
         if Lapsoss.configuration.capture_request_context
-          Rails.logger.debug "[Lapsoss] Adding request context" if Rails.env.test?
+          Rails.logger.tagged("Lapsoss") { Rails.logger.debug "Adding request context" } if Rails.env.test?
           add_request_context(env)
         end
 
         begin
           @app.call(env)
         rescue Exception => e
-          Rails.logger.debug { "[Lapsoss] Capturing exception: #{e.class} - #{e.message}" } if Rails.env.test?
+          Rails.logger.tagged("Lapsoss") { Rails.logger.debug "Capturing exception: #{e.class} - #{e.message}" } if Rails.env.test?
           # Capture the exception
           Lapsoss.capture_exception(e)
           # Re-raise the exception to maintain Rails error handling

data/lib/lapsoss/railtie.rb

@@ -2,7 +2,13 @@
 
 module Lapsoss
   class Railtie < Rails::Railtie
-    Rails.logger.debug "[Lapsoss] Railtie loaded" if ENV["DEBUG_LAPSOSS"]
+    if ENV["DEBUG_LAPSOSS"]
+      if Rails.logger.respond_to?(:tagged)
+        Rails.logger.tagged("Lapsoss") { Rails.logger.debug "Railtie loaded" }
+      else
+        Rails.logger.debug "[Lapsoss] Railtie loaded"
+      end
+    end
     config.lapsoss = ActiveSupport::OrderedOptions.new
 
     initializer "lapsoss.configure" do |_app|
@@ -14,7 +20,12 @@ module Lapsoss
                                  Rails.env
         end
 
-        config.logger ||= Rails.logger
+        # Use tagged logger for all Lapsoss logs
+        config.logger ||= if Rails.logger.respond_to?(:tagged)
+                            Rails.logger.tagged("Lapsoss")
+        else
+                            ActiveSupport::TaggedLogging.new(Rails.logger).tagged("Lapsoss")
+        end
 
         config.release ||= if Rails.application.respond_to?(:version)
                              Rails.application.version.to_s

data/lib/lapsoss/registry.rb

@@ -2,6 +2,7 @@
 
 require "singleton"
 require "concurrent"
+require "active_support/core_ext/string/inflections"
 
 module Lapsoss
   class Registry
@@ -42,7 +43,7 @@ module Lapsoss
       name = if adapter.respond_to?(:name) && adapter.name
                adapter.name.to_sym
       elsif adapter.class.name
-               adapter.class.name.split("::").last.to_sym
+               adapter.class.name.demodulize.underscore.to_sym
       else
                # Generate a unique name if class name is nil (anonymous class)
                :"adapter_#{adapter.object_id}"
@@ -116,13 +117,12 @@ module Lapsoss
     # Resolve adapter type to class
     def resolve_adapter_class(type)
       # Try to get the class by convention: Adapters::{Type}Adapter
-      class_name = "#{type.to_s.split('_').map(&:capitalize).join}Adapter"
+      class_name = "#{type.to_s.camelize}Adapter"
+      full_class_name = "Lapsoss::Adapters::#{class_name}"
 
-      begin
-        Adapters.const_get(class_name)
-      rescue NameError
-        raise AdapterNotFoundError, "Unknown adapter type: #{type}. Expected class: Lapsoss::Adapters::#{class_name}"
-      end
+      full_class_name.constantize
+    rescue NameError
+      raise AdapterNotFoundError, "Unknown adapter type: #{type}. Expected class: #{full_class_name}"
     end
   end
 end

data/lib/lapsoss/router.rb

@@ -19,10 +19,8 @@ module Lapsoss
 
       # Handle adapter errors gracefully
       def handle_adapter_error(adapter, event, error)
-        return unless Lapsoss.configuration.logger
-
         Lapsoss.configuration.logger.error(
-          "[Lapsoss] Adapter '#{adapter.name}' failed to capture event (type: #{event.type}): #{error.message}"
+          "Adapter '#{adapter.name}' failed to capture event (type: #{event.type}): #{error.message}"
         )
 
         # Call error handler if configured