lapsoss 0.3.1 → 0.4.2

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
@@ -272,42 +263,46 @@ module Lapsoss
       @fingerprint_callback = value
     end
 
-    # Configuration validation
+    # Configuration validation - just log warnings, don't fail
     def validate!
-      validate_sample_rate!(@sample_rate, "sample_rate") if @sample_rate
+      # Check sample rate is between 0 and 1
+      if @sample_rate && (@sample_rate < 0 || @sample_rate > 1)
+        logger.warn "sample_rate should be between 0 and 1, got #{@sample_rate}"
+      end
+
+      # Check callables
       validate_callable!(@before_send, "before_send")
       validate_callable!(@error_handler, "error_handler")
       validate_callable!(@fingerprint_callback, "fingerprint_callback")
+
+      # Log if environment looks unusual
       validate_environment!(@environment, "environment") if @environment
 
-      # Validate transport settings
-      validate_timeout!(@transport_timeout, "transport_timeout")
-      validate_retries!(@transport_max_retries, "transport_max_retries")
-      validate_timeout!(@transport_initial_backoff, "transport_initial_backoff")
-      validate_timeout!(@transport_max_backoff, "transport_max_backoff")
+      # Just log if transport settings look unusual
+      if @transport_timeout && @transport_timeout <= 0
+        logger.warn "transport_timeout should be positive, got #{@transport_timeout}"
+      end
 
-      if @transport_backoff_multiplier
-        validate_type!(@transport_backoff_multiplier, [ Numeric ], "transport_backoff_multiplier")
-        validate_numeric_range!(@transport_backoff_multiplier, 1.0..10.0, "transport_backoff_multiplier")
+      if @transport_max_retries && @transport_max_retries < 0
+        logger.warn "transport_max_retries should be non-negative, got #{@transport_max_retries}"
       end
 
-      # Validate that initial backoff is less than max backoff
       if @transport_initial_backoff && @transport_max_backoff && @transport_initial_backoff > @transport_max_backoff
-        raise ValidationError,
-              "transport_initial_backoff (#{@transport_initial_backoff}) must 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
+      # Validate adapter configurations exist
       @adapter_configs.each do |name, config|
-        validate_adapter_config!(name, config)
+        if config[:type].blank?
+          logger.warn "Adapter '#{name}' has no type specified"
+        end
       end
+
+      true
     end
 
     private
 
-    def validate_adapter_config!(name, config)
-      validate_presence!(config[:type], "adapter type for '#{name}'")
-      validate_type!(config[:settings], [ Hash ], "adapter settings for '#{name}'")
-    end
+    # Adapter config validation moved to inline logging
   end
 end

data/lib/lapsoss/event.rb

@@ -1,131 +1,125 @@
 # frozen_string_literal: true
 
-module Lapsoss
-  class Event
-    attr_accessor :type, :timestamp, :level, :message, :exception, :context, :environment, :fingerprint,
-                  :backtrace_frames
-
-    def initialize(type:, level: :info, **attributes)
-      @type = type
-      @level = level
-      @timestamp = Utils.current_time
-      @context = {}
-      @environment = Lapsoss.configuration.environment
-
-      attributes.each do |key, value|
-        instance_variable_set("@#{key}", value) if respond_to?("#{key}=")
-      end
-
-      # Process backtrace if we have an exception
-      @backtrace_frames = process_backtrace if @exception
-
-      # Set message from exception if not provided
-      @message ||= @exception.message if @exception
+require "active_support/core_ext/hash"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/time"
+require "active_support/json"
 
-      # Generate fingerprint after all attributes are set (unless explicitly set to nil or a value)
-      @fingerprint = generate_fingerprint if @fingerprint.nil? && !attributes.key?(:fingerprint)
-    end
+module Lapsoss
+  # Immutable event structure using Ruby 3.3 Data class
+  Event = Data.define(
+    :type,           # :exception, :message, :transaction
+    :level,          # :debug, :info, :warning, :error, :fatal
+    :timestamp,
+    :message,
+    :exception,
+    :context,
+    :environment,
+    :fingerprint,
+    :backtrace_frames
+  ) do
+    # Factory method with smart defaults
+    def self.build(type:, level: :info, **attributes)
+      timestamp = attributes[:timestamp] || Time.now
+      environment = attributes[:environment].presence || Lapsoss.configuration.environment
+      context = attributes[:context] || {}
+
+      # Process exception if present
+      exception = attributes[:exception]
+      message = attributes[:message].presence || exception&.message
+      backtrace_frames = process_backtrace(exception) if exception
+
+      # Generate fingerprint
+      fingerprint = attributes.fetch(:fingerprint) {
+        generate_fingerprint(type, message, exception, environment)
+      }
 
-    def to_h
-      data = {
+      new(
         type: type,
-        timestamp: timestamp,
         level: level,
+        timestamp: timestamp,
         message: message,
-        exception: exception_data,
-        backtrace: backtrace_data,
+        exception: exception,
         context: context,
         environment: environment,
-        fingerprint: fingerprint
-      }.compact
-
-      scrub_sensitive_data(data)
+        fingerprint: fingerprint,
+        backtrace_frames: backtrace_frames
+      )
     end
 
-    def scrub_sensitive_data(data)
-      config = Lapsoss.configuration
-
-      scrubber = Scrubber.new(
-        scrub_fields: config.scrub_fields,
-        scrub_all: config.scrub_all,
-        whitelist_fields: config.whitelist_fields,
-        randomize_scrub_length: config.randomize_scrub_length
-      )
+    # ActiveSupport::JSON serialization
+    def as_json(options = nil)
+      to_h.compact_blank.as_json(options)
+    end
 
-      scrubber.scrub(data)
+    def to_json(options = nil)
+      ActiveSupport::JSON.encode(as_json(options))
     end
 
-    def generate_fingerprint
-      config = Lapsoss.configuration
+    # Helper methods
+    def exception_type = exception&.class&.name
 
-      fingerprinter = Fingerprinter.new(
-        custom_callback: config.fingerprint_callback,
-        patterns: config.fingerprint_patterns,
-        normalize_paths: config.normalize_fingerprint_paths,
-        normalize_ids: config.normalize_fingerprint_ids,
-        include_environment: config.fingerprint_include_environment
-      )
+    def exception_message = exception&.message
 
-      fingerprinter.generate_fingerprint(self)
-    end
+    def has_exception? = exception.present?
 
-    def process_backtrace
-      return nil unless @exception&.backtrace
+    def has_backtrace? = backtrace_frames.present?
 
-      config = Lapsoss.configuration
+    def backtrace = exception&.backtrace
 
-      processor = BacktraceProcessor.new(
-        context_lines: config.backtrace_context_lines,
-        max_frames: config.backtrace_max_frames,
-        enable_code_context: config.backtrace_enable_code_context,
-        strip_load_path: config.backtrace_strip_load_path,
-        in_app_patterns: config.backtrace_in_app_patterns,
-        exclude_patterns: config.backtrace_exclude_patterns
-      )
+    def request_context = context.dig(:extra, :request) || context.dig(:extra, "request")
 
-      processor.process_exception_backtrace(@exception)
-    end
+    def user_context = context[:user]
 
-    private
+    def tags = context[:tags] || {}
 
-    def exception_data
-      return nil unless exception
+    def extra = context[:extra] || {}
 
-      {
-        class: exception.class.name,
-        message: exception.message,
-        backtrace: exception.backtrace&.first(20)
-      }
-    end
+    def breadcrumbs = context[:breadcrumbs] || []
 
-    def backtrace_data
-      return nil unless @backtrace_frames&.any?
+    # Apply data scrubbing
+    def scrubbed
+      scrubber = Scrubber.new(
+        scrub_fields: Lapsoss.configuration.scrub_fields,
+        scrub_all: Lapsoss.configuration.scrub_all,
+        whitelist_fields: Lapsoss.configuration.whitelist_fields,
+        randomize_scrub_length: Lapsoss.configuration.randomize_scrub_length
+      )
 
-      @backtrace_frames.map(&:to_h)
+      with(context: scrubber.scrub(context))
     end
 
-    public
+    private
 
-    def exception_type
-      exception&.class&.name
-    end
+    def self.process_backtrace(exception)
+      return nil unless exception&.backtrace.present?
 
-    def backtrace
-      if @backtrace_frames
-        @backtrace_frames.map(&:raw_line)
-      elsif exception
-        exception.backtrace
-      else
-        []
-      end
+      config = Lapsoss.configuration
+      processor = BacktraceProcessor.new(config)
+      processor.process_exception_backtrace(exception)
     end
 
-    def request_context
-      # Request context is stored in extra by the middleware
-      # Check both string and symbol keys for compatibility
-      return nil unless context[:extra]
+    def self.generate_fingerprint(type, message, exception, environment)
+      return nil unless Lapsoss.configuration.fingerprint_callback ||
+                       Lapsoss.configuration.fingerprint_patterns.present?
+
+      fingerprinter = Fingerprinter.new(
+        custom_callback: Lapsoss.configuration.fingerprint_callback,
+        patterns: Lapsoss.configuration.fingerprint_patterns,
+        normalize_paths: Lapsoss.configuration.normalize_fingerprint_paths,
+        normalize_ids: Lapsoss.configuration.normalize_fingerprint_ids,
+        include_environment: Lapsoss.configuration.fingerprint_include_environment
+      )
+
+      # Create a temporary event-like object for fingerprinting
+      temp_event = Struct.new(:type, :message, :exception, :environment).new(
+        type,
+        message,
+        exception,
+        environment
+      )
 
-      context[:extra]["request"] || context[:extra][:request]
+      fingerprinter.generate_fingerprint(temp_event)
     end
   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)
 
@@ -98,10 +116,13 @@ module Lapsoss
         pattern = pattern_config[:pattern]
         fingerprint = pattern_config[:fingerprint]
 
-        if pattern.is_a?(Regexp) && full_error_text.match?(pattern)
+        case pattern
+        in Regexp if pattern.match?(full_error_text)
           return fingerprint
-        elsif pattern.is_a?(String) && full_error_text.include?(pattern)
+        in String if full_error_text.include?(pattern)
           return fingerprint
+        else
+          # Continue to next pattern
         end
       end
 
@@ -167,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
@@ -198,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/merged_scope.rb

@@ -26,12 +26,7 @@ module Lapsoss
     end
 
     def add_breadcrumb(message, type: :default, **metadata)
-      breadcrumb = {
-        message: message,
-        type: type,
-        metadata: metadata,
-        timestamp: Time.now.utc
-      }
+      breadcrumb = Breadcrumb.build(message, type: type, metadata: metadata)
       @own_breadcrumbs << breadcrumb
       # Keep breadcrumbs to a reasonable limit
       @own_breadcrumbs.shift if @own_breadcrumbs.length > 20

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_error_subscriber.rb

@@ -22,10 +22,9 @@ module Lapsoss
     private
 
     def skip_error?(error, source)
-      # Skip cache-related Redis errors if configured to do so
-      if Lapsoss.configuration.skip_rails_cache_errors && source&.include?("cache") && defined?(Redis::CannotConnectError) && error.is_a?(Redis::CannotConnectError)
-        return true
-      end
+      # Skip Rails cache-related errors using Rails error reporter source
+      # Avoid referencing backend-specific gems (e.g., Redis)
+      return true if Lapsoss.configuration.skip_rails_cache_errors && source&.include?("cache")
 
       false
     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