lapsoss 0.3.1 → 0.4.0

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

@@ -98,10 +98,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
 

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/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/scope.rb

@@ -12,12 +12,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)
       @breadcrumbs << breadcrumb
       # Keep breadcrumbs to a reasonable limit
       @breadcrumbs.shift if @breadcrumbs.length > 20

data/lib/lapsoss/scrubber.rb

@@ -53,10 +53,10 @@ module Lapsoss
       @scrubbed_objects[data] = true
 
       case data
-      when Hash
-        scrub_hash(data)
-      when Array
-        scrub_array(data)
+      in Hash => hash
+        scrub_hash(hash)
+      in Array => array
+        scrub_array(array)
       else
         scrub_value(data)
       end
@@ -68,12 +68,15 @@ module Lapsoss
 
         result[key] = if should_scrub_field?(key_string)
                         generate_scrub_value(value)
-        elsif value.is_a?(Hash)
-                        scrub_recursive(value)
-        elsif value.is_a?(Array)
-                        scrub_array(value)
         else
-                        scrub_value(value)
+                        case value
+                        in Hash => h
+                          scrub_recursive(h)
+                        in Array => a
+                          scrub_array(a)
+                        else
+                          scrub_value(value)
+                        end
         end
       end
     end
@@ -101,8 +104,9 @@ module Lapsoss
     end
 
     def field_matches_pattern?(field_name, pattern)
-      if pattern.is_a?(Regexp)
-        pattern.match?(field_name)
+      case pattern
+      in Regexp => regex
+        regex.match?(field_name)
       else
         field_name.include?(pattern.to_s.downcase)
       end

data/lib/lapsoss/user_context.rb

@@ -96,12 +96,22 @@ module Lapsoss
 
         sanitized[key] = if sensitive_field?(key_sym)
                            "[REDACTED]"
-        elsif value.is_a?(Hash)
-                           sanitize_for_logging(value)
-        elsif value.is_a?(Array)
-                           value.map { |v| v.is_a?(Hash) ? sanitize_for_logging(v) : v }
         else
-                           value
+                           case value
+                           in Hash => h
+                             sanitize_for_logging(h)
+                           in Array => arr
+                             arr.map do |v|
+                               case v
+                               in Hash => h
+                                 sanitize_for_logging(h)
+                               else
+                                 v
+                               end
+                             end
+                           else
+                             value
+                           end
         end
       end
 

data/lib/lapsoss/utils.rb

@@ -5,8 +5,6 @@ module Lapsoss
     module_function
 
     def current_time
-      if Time.respond_to?(:zone) && Time.zone
-      end
       Time.zone.now
     end
   end

data/lib/lapsoss/validators.rb

@@ -1,129 +1,164 @@
 # frozen_string_literal: true
 
-require "uri"
-
 module Lapsoss
   module Validators
     class ValidationError < StandardError; end
 
     module_function
 
+    # Simple presence check - just ensure it's not blank
     def validate_presence!(value, name)
-      if value.nil? || (value.respond_to?(:empty?) && value.empty?)
-        raise ValidationError, "#{name} is required and cannot be nil or empty"
-      end
-    end
+      return unless value.blank?
 
-    def validate_type!(value, types, name)
-      types = Array(types)
-      unless types.any? { |type| value.is_a?(type) }
-        type_names = types.map(&:name).join(" or ")
-        raise ValidationError, "#{name} must be a #{type_names}, got #{value.class} (#{value.inspect})"
-      end
+      Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} is missing or blank"
+      false
     end
 
+    # Check if callable, log warning if not
     def validate_callable!(value, name)
-      unless value.nil? || value.respond_to?(:call)
-        raise ValidationError, "#{name} must be callable (respond_to? :call) or nil, got #{value.class}"
+      return true if value.nil? || value.respond_to?(:call)
+
+      Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} should be callable but got #{value.class}"
+      false
+    end
+
+    # Just log DSN issues, don't fail
+    def validate_dsn!(dsn_string, name = "DSN")
+      return true if dsn_string.blank?
+
+      begin
+        uri = URI.parse(dsn_string)
+
+        if uri.user.blank?
+          Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} appears to be missing public key"
+        end
+
+        if uri.host.blank?
+          Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} appears to be missing host"
+        end
+
+        true
+      rescue URI::InvalidURIError => e
+        Lapsoss.configuration.logger&.error "[Lapsoss] #{name} couldn't be parsed: #{e.message}"
+        false
       end
     end
 
-    def validate_numeric_range!(value, range, name)
-      validate_type!(value, [ Numeric ], name)
-      unless range.cover?(value)
-        raise ValidationError, "#{name} must be between #{range.min} and #{range.max}, got #{value}"
+    # Validate sample rate is between 0 and 1
+    def validate_sample_rate!(value, name)
+      return true if value.nil?
+
+      if value < 0 || value > 1
+        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} should be between 0 and 1, got #{value}"
       end
+      true
     end
 
-    def validate_url!(value, name)
-      return if value.nil?
+    # Validate timeout values
+    def validate_timeout!(value, name)
+      return true if value.nil?
 
-      validate_type!(value, [ String ], name)
+      if value <= 0
+        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} should be positive, got #{value}"
+      end
+      true
+    end
 
-      begin
-        uri = URI.parse(value)
-        raise ValidationError, "#{name} must be a valid URL with scheme and host" unless uri.scheme && uri.host
-        raise ValidationError, "#{name} must use http or https scheme" unless %w[http https].include?(uri.scheme)
-      rescue URI::InvalidURIError => e
-        raise ValidationError, "#{name} is not a valid URL: #{e.message}"
+    # Validate retry count
+    def validate_retries!(value, name)
+      return true if value.nil?
+
+      if value < 0
+        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} should be non-negative, got #{value}"
       end
+      true
     end
 
-    def validate_dsn!(dsn_string, name = "DSN")
-      return if dsn_string.nil?
+    # Validate environment string
+    def validate_environment!(value, name)
+      return true if value.nil?
 
-      validate_type!(dsn_string, [ String ], name)
+      if value.to_s.strip.empty?
+        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} should not be empty"
+      end
+      true
+    end
 
-      begin
-        uri = URI.parse(dsn_string)
+    # Validate type
+    def validate_type!(value, expected_types, name)
+      return true if value.nil?
 
-        # Check required components
-        validate_presence!(uri.scheme, "#{name} scheme")
-        validate_presence!(uri.host, "#{name} host")
-        validate_presence!(uri.user, "#{name} public key")
+      unless expected_types.any? { |type| value.is_a?(type) }
+        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} should be one of #{expected_types.join(', ')}, got #{value.class}"
+      end
+      true
+    end
 
-        # Validate scheme
-        raise ValidationError, "#{name} must use http or https scheme" unless %w[http https].include?(uri.scheme)
+    # Validate numeric range
+    def validate_numeric_range!(value, range, name)
+      return true if value.nil?
 
-        # Extract project ID from path
-        path_parts = uri.path&.split("/") || []
-        project_id = path_parts.last
-        validate_presence!(project_id, "#{name} project ID")
+      unless range.include?(value)
+        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} should be within #{range}, got #{value}"
+      end
+      true
+    end
 
-        # Validate project ID is numeric
-        unless project_id.match?(/^\d+$/)
-          raise ValidationError, "#{name} project ID must be numeric, got '#{project_id}'"
-        end
-      rescue URI::InvalidURIError => e
-        raise ValidationError, "#{name} is not a valid URI: #{e.message}"
+    # Validate boolean
+    def validate_boolean!(value, name)
+      return true if value.nil?
+
+      unless [ true, false ].include?(value)
+        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} should be true or false, got #{value}"
       end
+      true
     end
 
+    # Just check presence, don't validate format
     def validate_api_key!(value, name, format: nil)
-      validate_presence!(value, name)
-      validate_type!(value, [ String ], name)
+      if value.blank?
+        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} is missing"
+        return false
+      end
 
+      # Optional format hint for logging only
       case format
       when :uuid
         unless value.match?(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i)
-          raise ValidationError, "#{name} must be a valid UUID format"
+          Lapsoss.configuration.logger&.info "[Lapsoss] #{name} doesn't look like a UUID, but continuing anyway"
         end
-      when :hex
-        raise ValidationError, "#{name} must be a valid hexadecimal string" unless value.match?(/\A[0-9a-f]+\z/i)
       when :alphanumeric
-        raise ValidationError, "#{name} must be alphanumeric" unless value.match?(/\A[a-z0-9]+\z/i)
+        unless value.match?(/\A[a-z0-9]+\z/i)
+          Lapsoss.configuration.logger&.info "[Lapsoss] #{name} contains special characters, but continuing anyway"
+        end
       end
+
+      true
     end
 
+    # Environment validation - just log if unusual
     def validate_environment!(value, name = "environment")
-      return if value.nil?
-
-      validate_type!(value, [ String, Symbol ], name)
+      return true if value.blank?
 
-      env_string = value.to_s
-      unless env_string.match?(/\A[a-z0-9_-]+\z/i)
-        raise ValidationError, "#{name} must contain only alphanumeric characters, underscores, and hyphens"
+      common_envs = %w[development test staging production]
+      unless common_envs.include?(value.to_s.downcase)
+        Lapsoss.configuration.logger&.info "[Lapsoss] #{name} '#{value}' is non-standard (expected one of: #{common_envs.join(', ')})"
       end
-    end
-
-    def validate_sample_rate!(value, name = "sample_rate")
-      return if value.nil?
-
-      validate_numeric_range!(value, 0.0..1.0, name)
-    end
-
-    def validate_timeout!(value, name = "timeout")
-      return if value.nil?
 
-      validate_type!(value, [ Numeric ], name)
-      raise ValidationError, "#{name} must be positive, got #{value}" if value <= 0
+      true
     end
 
-    def validate_retries!(value, name = "max_retries")
-      return if value.nil?
+    # URL validation - just check parsability
+    def validate_url!(value, name)
+      return true if value.nil?
 
-      validate_type!(value, [ Integer ], name)
-      validate_numeric_range!(value, 0..10, name)
+      begin
+        URI.parse(value)
+        true
+      rescue URI::InvalidURIError => e
+        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} couldn't be parsed as URL: #{e.message}"
+        false
+      end
     end
   end
 end

data/lib/lapsoss/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lapsoss
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/lib/tasks/cassettes.rake

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+namespace :cassettes do
+  desc "Sanitize VCR cassettes by scrubbing sensitive data"
+  task :sanitize do
+    dir = File.expand_path("../../test/cassettes", __dir__)
+    files = Dir[File.join(dir, "*.yml")]
+    puts "Sanitizing #{files.size} cassette(s) in #{dir}..."
+
+    email_re = /\b[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\b/i
+    hostname_key_re = /"hostname":"[^"]+"/
+    home_path_re = Regexp.new(Regexp.escape(Dir.home))
+    api_key_pairs = [
+      [ /"apiKey":"[^"]+"/, '"apiKey":"<INSIGHT_HUB_API_KEY>"' ],
+      [ /"access_token":"[^"]+"/, '"access_token":"<ROLLBAR_ACCESS_TOKEN>"' ],
+      [ /api_key=[^&]+/, "api_key=<APPSIGNAL_FRONTEND_API_KEY>" ]
+    ]
+
+    header_key_map = {
+      "X-Rollbar-Access-Token" => "<ROLLBAR_ACCESS_TOKEN>",
+      "Bugsnag-Api-Key" => "<INSIGHT_HUB_API_KEY>",
+      "Authorization" => "<AUTHORIZATION>"
+    }
+
+    files.each do |file|
+      content = File.read(file)
+
+      # Replace patterns in raw content safely
+      content = content.gsub(email_re, "<EMAIL>")
+      content = content.gsub(hostname_key_re, '"hostname":"<HOSTNAME>"')
+      content = content.gsub(home_path_re, "/home/user")
+      api_key_pairs.each { |(re, rep)| content = content.gsub(re, rep) }
+
+      # Normalize User-Agent references to avoid machine leakage
+      content = content.gsub(/User-Agent:\n\s+-\s+.+/, "User-Agent:\n  - lapsoss/x.y.z") rescue nil
+
+      # Rewrite known header values
+      header_key_map.each do |hdr, placeholder|
+        content = content.gsub(/#{hdr}:(?:\n\s+-\s+.*)/, "#{hdr}:\n  - \"#{placeholder}\"")
+      end
+
+      File.write(file, content)
+      puts "  scrubbed: #{File.basename(file)}"
+    end
+
+    puts "Done."
+  end
+end