lapsoss 0.4.0 → 0.4.4

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
@@ -38,7 +49,7 @@ module Lapsoss
     end
 
     initializer "lapsoss.rails_error_subscriber", after: "lapsoss.add_middleware" do |app|
-      app.executor.error_reporter.subscribe(Lapsoss::RailsErrorSubscriber.new)
+      Rails.error.subscribe(Lapsoss::RailsErrorSubscriber.new)
     end
   end
 end

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

data/lib/lapsoss/scrubber.rb

@@ -4,169 +4,32 @@ require "active_support/parameter_filter"
 
 module Lapsoss
   class Scrubber
-    DEFAULT_SCRUB_FIELDS = %w[
-      password passwd pwd secret token key api_key access_token
-      authorization auth_token session_token csrf_token
-      credit_card cc_number card_number ssn social_security_number
-      phone mobile email_address
-    ].freeze
-
-    PROTECTED_EVENT_FIELDS = %w[
-      type timestamp level message exception environment context
-    ].freeze
-
-    ATTACHMENT_CLASSES = %w[
-      ActionDispatch::Http::UploadedFile
-      Rack::Multipart::UploadedFile
-      Tempfile
+    # Match Rails conventions - these are only used when Rails is not available
+    # Rails uses partial matching, so 'passw' matches 'password'
+    DEFAULT_SCRUB_FIELDS = %i[
+      passw email secret token _key crypt salt certificate otp ssn cvv cvc
     ].freeze
 
     def initialize(config = {})
-      @rails_parameter_filter = rails_parameter_filter
-
-      # Only use custom scrubbing if Rails parameter filter is not available
-      return if @rails_parameter_filter
-
-      @scrub_fields = Array(config[:scrub_fields] || DEFAULT_SCRUB_FIELDS)
-      @scrub_all = config[:scrub_all] || false
-      @whitelist_fields = Array(config[:whitelist_fields] || [])
-      @randomize_scrub_length = config[:randomize_scrub_length] || false
-      @scrub_value = config[:scrub_value] || "**SCRUBBED**"
-    end
-
-    def scrub(data)
-      return data if data.nil?
-
-      # If Rails parameter filter is available, use it exclusively
-      return @rails_parameter_filter.filter(data) if @rails_parameter_filter
-
-      # Fallback to custom scrubbing logic only if Rails filter is not available
-      @scrubbed_objects = {}.compare_by_identity
-      scrub_recursive(data)
-    end
-
-    private
-
-    def scrub_recursive(data)
-      return data if @scrubbed_objects.key?(data)
-
-      @scrubbed_objects[data] = true
-
-      case data
-      in Hash => hash
-        scrub_hash(hash)
-      in Array => array
-        scrub_array(array)
+      # Combine: Rails filter parameters + custom fields (if provided)
+      base_params = if defined?(Rails) && Rails.respond_to?(:application) && Rails.application
+                      Rails.application.config.filter_parameters.presence || DEFAULT_SCRUB_FIELDS
       else
-        scrub_value(data)
+                      DEFAULT_SCRUB_FIELDS
       end
-    end
 
-    def scrub_hash(hash)
-      hash.each_with_object({}) do |(key, value), result|
-        key_string = key.to_s.downcase
-
-        result[key] = if should_scrub_field?(key_string)
-                        generate_scrub_value(value)
-        else
-                        case value
-                        in Hash => h
-                          scrub_recursive(h)
-                        in Array => a
-                          scrub_array(a)
-                        else
-                          scrub_value(value)
-                        end
-        end
-      end
-    end
-
-    def scrub_array(array)
-      array.map do |item|
-        scrub_recursive(item)
-      end
-    end
-
-    def scrub_value(value)
-      if attachment_value?(value)
-        scrub_attachment(value)
+      filter_params = if config[:scrub_fields]
+                        Array(base_params) + Array(config[:scrub_fields])
       else
-        value
+                        base_params
       end
-    end
-
-    def should_scrub_field?(field_name)
-      return false if whitelisted_field?(field_name)
-      return false if protected_event_field?(field_name)
-      return true if @scrub_all
 
-      @scrub_fields.any? { |pattern| field_matches_pattern?(field_name, pattern) }
+      @filter = ActiveSupport::ParameterFilter.new(filter_params)
     end
 
-    def field_matches_pattern?(field_name, pattern)
-      case pattern
-      in Regexp => regex
-        regex.match?(field_name)
-      else
-        field_name.include?(pattern.to_s.downcase)
-      end
-    end
-
-    def whitelisted_field?(field_name)
-      @whitelist_fields.any? { |pattern| field_matches_pattern?(field_name, pattern) }
-    end
-
-    def protected_event_field?(field_name)
-      PROTECTED_EVENT_FIELDS.include?(field_name.to_s)
-    end
-
-    def whitelisted_value?(_value)
-      # Basic implementation - could be extended
-      false
-    end
-
-    def attachment_value?(value)
-      return false unless value.respond_to?(:class)
-
-      ATTACHMENT_CLASSES.include?(value.class.name)
-    end
-
-    def scrub_attachment(attachment)
-      {
-        __attachment__: true,
-        content_type: safe_call(attachment, :content_type),
-        original_filename: safe_call(attachment, :original_filename),
-        size: safe_call(attachment, :size) || safe_call(attachment, :tempfile, :size)
-      }
-    rescue StandardError => e
-      { __attachment__: true, error: "Failed to extract attachment info: #{e.message}" }
-    end
-
-    def safe_call(object, *methods)
-      methods.reduce(object) do |obj, method|
-        obj.respond_to?(method) ? obj.public_send(method) : nil
-      end
-    end
-
-    def generate_scrub_value(_original_value)
-      if @randomize_scrub_length
-        "*" * rand(6..12)
-      else
-        @scrub_value
-      end
-    end
-
-    def rails_parameter_filter
-      return nil unless defined?(Rails) && Rails.respond_to?(:application) && Rails.application
-      return nil unless defined?(ActiveSupport::ParameterFilter)
-
-      filter_params = Rails.application.config.filter_parameters
-      return nil if filter_params.empty?
-
-      ActiveSupport::ParameterFilter.new(filter_params)
-    rescue StandardError
-      # Fallback silently if Rails config is not available
-      nil
+    def scrub(data)
+      return data if data.nil?
+      @filter.filter(data)
     end
   end
 end

data/lib/lapsoss/validators.rb

@@ -1,164 +1,100 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/object/blank"
+
 module Lapsoss
   module Validators
-    class ValidationError < StandardError; end
+    extend ActiveSupport::Concern
 
     module_function
 
-    # Simple presence check - just ensure it's not blank
-    def validate_presence!(value, name)
-      return unless value.blank?
+    def logger
+      Lapsoss.configuration.logger
+    end
 
-      Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} is missing or blank"
+    # Simple presence check using AS blank?
+    def validate_presence!(value, name)
+      return true if value.present?
+      logger.warn "#{name} is missing or blank"
       false
     end
 
-    # Check if callable, log warning if not
+    # Check if callable
     def validate_callable!(value, name)
       return true if value.nil? || value.respond_to?(:call)
-
-      Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} should be callable but got #{value.class}"
+      logger.warn "#{name} should be callable but got #{value.class}"
       false
     end
 
-    # Just log DSN issues, don't fail
+    # DSN validation - just log issues
     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
+      uri = URI.parse(dsn_string)
+      logger.warn "#{name} appears to be missing public key" if uri.user.blank?
+      logger.warn "#{name} appears to be missing host" if uri.host.blank?
+      true
+    rescue URI::InvalidURIError => e
+      logger.error "#{name} couldn't be parsed: #{e.message}"
+      false
     end
 
-    # Validate sample rate is between 0 and 1
+    # Validate numeric ranges using AS Range#cover?
     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
+      return true if (0..1).cover?(value)
+      logger.warn "#{name} should be between 0 and 1, got #{value}"
+      false
     end
 
-    # Validate timeout values
     def validate_timeout!(value, name)
       return true if value.nil?
-
-      if value <= 0
-        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} should be positive, got #{value}"
-      end
-      true
+      return true if value.positive?
+      logger.warn "#{name} should be positive, got #{value}"
+      false
     end
 
-    # 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
-
-    # Validate environment string
-    def validate_environment!(value, name)
-      return true if value.nil?
-
-      if value.to_s.strip.empty?
-        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} should not be empty"
-      end
-      true
-    end
-
-    # Validate type
-    def validate_type!(value, expected_types, name)
-      return true if value.nil?
-
-      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
+      return true if value >= 0
+      logger.warn "#{name} should be non-negative, got #{value}"
+      false
     end
 
-    # Validate numeric range
-    def validate_numeric_range!(value, range, name)
-      return true if value.nil?
-
-      unless range.include?(value)
-        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} should be within #{range}, got #{value}"
-      end
-      true
-    end
+    # Environment validation using AS presence
+    def validate_environment!(value, name = "environment")
+      return true if value.blank?
 
-    # Validate boolean
-    def validate_boolean!(value, name)
-      return true if value.nil?
+      value_str = value.to_s.strip
+      return true if value_str.present?
 
-      unless [ true, false ].include?(value)
-        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} should be true or false, got #{value}"
-      end
-      true
+      logger.warn "#{name} should not be empty"
+      false
     end
 
-    # Just check presence, don't validate format
+    # API key validation using AS blank?
     def validate_api_key!(value, name, format: nil)
-      if value.blank?
-        Lapsoss.configuration.logger&.warn "[Lapsoss] #{name} is missing"
-        return false
-      end
+      return false if value.blank? && logger.warn("#{name} is missing")
 
-      # Optional format hint for logging only
+      # Optional format hints
       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)
-          Lapsoss.configuration.logger&.info "[Lapsoss] #{name} doesn't look like a UUID, but continuing anyway"
-        end
+        logger.info "#{name} doesn't look like a UUID, but continuing anyway" 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)
       when :alphanumeric
-        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 true if value.blank?
-
-      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(', ')})"
+        logger.info "#{name} contains special characters, but continuing anyway" unless value.match?(/\A[a-z0-9]+\z/i)
       end
 
       true
     end
 
-    # URL validation - just check parsability
+    # URL validation
     def validate_url!(value, name)
       return true if value.nil?
-
-      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
+      URI.parse(value)
+      true
+    rescue URI::InvalidURIError => e
+      logger.warn "#{name} couldn't be parsed as URL: #{e.message}"
+      false
     end
   end
 end

data/lib/lapsoss/version.rb

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

data/lib/lapsoss.rb

@@ -44,6 +44,29 @@ module Lapsoss
       client.capture_message(message, level: level, **context)
     end
 
+    # Rails.error-compatible methods for non-Rails environments
+
+    # Handle errors and swallow them (like Rails.error.handle)
+    def handle(error_class = StandardError, fallback: nil, **context)
+      yield
+    rescue error_class => e
+      capture_exception(e, **context.merge(handled: true))
+      fallback.respond_to?(:call) ? fallback.call : fallback
+    end
+
+    # Record errors and re-raise them (like Rails.error.record)
+    def record(error_class = StandardError, **context)
+      yield
+    rescue error_class => e
+      capture_exception(e, **context.merge(handled: false))
+      raise
+    end
+
+    # Report an error manually (like Rails.error.report)
+    def report(exception, handled: true, **context)
+      capture_exception(exception, **context.merge(handled: handled))
+    end
+
     def add_breadcrumb(message, type: :default, **metadata)
       client.add_breadcrumb(message, type: type, **metadata)
     end