lapsoss 0.1.0 → 0.2.0

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: /Errno::(ENOENT|EACCES).*\/tmp\//,
-        fingerprint: "tmp-file-error"
+        pattern: %r{Errno::(ENOENT|EACCES).*/tmp/},
+        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
 
@@ -121,11 +121,9 @@ module Lapsoss
       parts << event.message if event.message
 
       # Include first few backtrace lines for context
-      if event.exception&.backtrace
-        parts.concat(event.exception.backtrace.first(3))
-      end
+      parts.concat(event.exception.backtrace.first(3)) if event.exception&.backtrace
 
-      parts.compact.join(" ")
+      parts.compact.join(' ')
     end
 
     def generate_default_fingerprint(event)
@@ -143,17 +141,15 @@ 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
 
       # Include environment if configured
-      if @include_environment && event.environment
-        components << event.environment
-      end
+      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
 
@@ -164,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)
@@ -194,18 +190,18 @@ module Lapsoss
 
       # Find first non-gem, non-framework line
       app_line = backtrace.find do |line|
-        !line.include?("/gems/") &&
-        !line.include?("/ruby/") &&
-        !line.include?("(eval)") &&
-        !line.start_with?("[")
+        line.exclude?('/gems/') &&
+          line.exclude?('/ruby/') &&
+          line.exclude?('(eval)') &&
+          !line.start_with?('[')
       end
 
       line_to_use = app_line || backtrace.first
 
       if @normalize_paths
         # Extract just filename:line_number
-        if line_to_use.match(%r{([^/]+):(\d+)})
-          "#{$1}:#{$2}"
+        if line_to_use =~ %r{([^/]+):(\d+)}
+          "#{::Regexp.last_match(1)}:#{::Regexp.last_match(2)}"
         else
           line_to_use
         end

data/lib/lapsoss/http_client.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require "faraday"
-require "faraday/retry"
-require "json"
-require "zlib"
+require 'faraday'
+require 'faraday/retry'
+require 'json'
+require 'zlib'
 
 module Lapsoss
   # HTTP client wrapper using Faraday with retry logic
   class HttpClient
-    USER_AGENT = "lapsoss/#{Lapsoss::VERSION}"
+    USER_AGENT = "lapsoss/#{Lapsoss::VERSION}".freeze
 
     def initialize(base_url, config = {})
       @base_url = base_url
@@ -53,18 +53,52 @@ module Lapsoss
         conn.options.open_timeout = @config[:timeout] || 5
 
         # Configure SSL
-        if @config.key?(:ssl_verify)
-          conn.ssl.verify = @config[:ssl_verify]
-        end
+        conn.ssl.verify = @config[:ssl_verify] if @config.key?(:ssl_verify)
 
         # Set user agent
-        conn.headers["User-Agent"] = USER_AGENT
+        conn.headers['User-Agent'] = USER_AGENT
 
-        # Use default adapter
-        conn.adapter Faraday.default_adapter
+        # Auto-detect and use appropriate adapter
+        conn.adapter detect_optimal_adapter
       end
     end
 
+    def detect_optimal_adapter
+      if fiber_scheduler_active? && async_adapter_available? && !force_sync_mode?
+        log_adapter_selection(:async)
+        :async_http
+      else
+        log_adapter_selection(:sync)
+        Faraday.default_adapter
+      end
+    end
+
+    def fiber_scheduler_active?
+      Fiber.current_scheduler != nil
+    end
+
+    def async_adapter_available?
+      require 'async/http/faraday'
+      true
+    rescue LoadError
+      false
+    end
+
+    def force_sync_mode?
+      Lapsoss.configuration.force_sync_http
+    end
+
+    def log_adapter_selection(adapter_type)
+      return unless Lapsoss.configuration.debug?
+
+      Lapsoss.configuration.logger&.debug(
+        "[Lapsoss::HttpClient] Using #{adapter_type} HTTP adapter " \
+        "(fiber_scheduler: #{fiber_scheduler_active?}, " \
+        "async_available: #{async_adapter_available?}, " \
+        "force_sync: #{force_sync_mode?})"
+      )
+    end
+
     def retry_options
       {
         max: @config[:max_retries] || 3,

data/lib/lapsoss/middleware.rb

@@ -22,14 +22,10 @@ module Lapsoss
 
       def call(event, hint = {})
         # Apply custom sampling logic first
-        if @sample_callback
-          return nil unless @sample_callback.call(event, hint)
-        end
+        return nil if @sample_callback && !@sample_callback.call(event, hint)
 
         # Apply rate-based sampling
-        if @sample_rate < 1.0
-          return nil if rand > @sample_rate
-        end
+        return nil if (@sample_rate < 1.0) && (rand > @sample_rate)
 
         @app.call(event, hint)
       end
@@ -44,6 +40,7 @@ module Lapsoss
 
       def call(event, hint = {})
         return nil if should_exclude?(event)
+
         @app.call(event, hint)
       end
 
@@ -95,22 +92,18 @@ module Lapsoss
         enhanced_user = existing_user.merge(user_data)
 
         # Apply privacy filtering if enabled
-        if @privacy_mode
-          enhanced_user = apply_privacy_filtering(enhanced_user)
-        end
+        enhanced_user = apply_privacy_filtering(enhanced_user) if @privacy_mode
 
         event.context[:user] = enhanced_user unless enhanced_user.empty?
       end
 
       def apply_privacy_filtering(user_data)
         # Remove sensitive fields in privacy mode
-        sensitive_fields = [:email, :phone, :address, :ssn, :credit_card]
+        sensitive_fields = %i[email phone address ssn credit_card]
         filtered = user_data.dup
 
         sensitive_fields.each do |field|
-          if filtered.key?(field)
-            filtered[field] = "[FILTERED]"
-          end
+          filtered[field] = '[FILTERED]' if filtered.key?(field)
         end
 
         filtered
@@ -133,9 +126,7 @@ module Lapsoss
       def add_release_info(event, hint)
         release_info = @release_provider&.call(event, hint) || auto_detect_release
 
-        if release_info
-          event.context[:release] = release_info
-        end
+        event.context[:release] = release_info if release_info
       end
 
       def auto_detect_release
@@ -155,7 +146,7 @@ module Lapsoss
       end
 
       def detect_git_info
-        return nil unless File.exist?(".git")
+        return nil unless File.exist?('.git')
 
         begin
           # Get current commit SHA
@@ -164,11 +155,11 @@ module Lapsoss
 
           # Get branch name
           branch = `git rev-parse --abbrev-ref HEAD`.strip
-          branch = nil if branch.empty? || branch == "HEAD"
+          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.at(commit_time.to_i)
+          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
@@ -189,43 +180,43 @@ module Lapsoss
         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"]
+        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["DYNO"]
-          info[:slug_commit] = ENV["HEROKU_SLUG_COMMIT"]
+        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["AWS_REGION"]
+        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"]
+        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["KUBERNETES_NAMESPACE"]
-          info[:pod_name] = ENV["HOSTNAME"]
+        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 parse_deployment_time(time_str)
-        Time.parse(time_str)
+        Time.zone.parse(time_str)
       rescue StandardError
         nil
       end
@@ -253,6 +244,7 @@ module Lapsoss
 
       def call(event, hint = {})
         return nil unless @condition.call(event, hint)
+
         @app.call(event, hint)
       end
     end
@@ -266,6 +258,7 @@ module Lapsoss
       def call(event, hint = {})
         transformed_event = @transformer.call(event, hint)
         return nil unless transformed_event
+
         @app.call(transformed_event, hint)
       end
     end
@@ -281,14 +274,12 @@ module Lapsoss
 
       def call(event, hint = {})
         @mutex.synchronize do
-          now = Time.now
+          now = Time.zone.now
           # Remove old events outside time window
           @events.reject! { |timestamp| now - timestamp > @time_window }
 
           # Check if we're over the limit
-          if @events.length >= @max_events
-            return nil
-          end
+          return nil if @events.length >= @max_events
 
           # Add current event
           @events << now
@@ -346,6 +337,7 @@ module Lapsoss
 
       def call(event, hint = {})
         return nil unless @sampler.sample?(event, hint)
+
         @app.call(event, hint)
       end
     end

data/lib/lapsoss/pipeline.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "middleware"
+require_relative 'middleware'
 
 module Lapsoss
   class Pipeline
@@ -46,7 +46,7 @@ module Lapsoss
 
     def build_chain
       # The final app just returns the event
-      final_app = lambda { |event, hint| event }
+      final_app = ->(event, _hint) { event }
 
       # Build middleware chain from right to left
       @middlewares.reverse.reduce(final_app) do |app, middleware_config|
@@ -115,17 +115,13 @@ module Lapsoss
       self
     end
 
-    def use_middleware(middleware_class, *args, **kwargs)
-      @pipeline.use(middleware_class, *args, **kwargs)
+    def use_middleware(middleware_class, *, **)
+      @pipeline.use(middleware_class, *, **)
       self
     end
 
-    def build
-      @pipeline.build
-    end
+    delegate :build, to: :@pipeline
 
-    def pipeline
-      @pipeline
-    end
+    attr_reader :pipeline
   end
 end

data/lib/lapsoss/railtie.rb

@@ -4,7 +4,7 @@ module Lapsoss
   class Railtie < Rails::Railtie
     config.lapsoss = ActiveSupport::OrderedOptions.new
 
-    initializer "lapsoss.configure" do |app|
+    initializer 'lapsoss.configure' do |_app|
       Lapsoss.configure do |config|
         config.environment ||= Rails.env
         config.logger ||= Rails.logger
@@ -18,13 +18,13 @@ module Lapsoss
       end
     end
 
-    initializer "lapsoss.rails_error_subscriber", after: "lapsoss.configure" do |app|
-      if Rails.version.to_f >= 7.0
-        app.executor.error_reporter.subscribe(Lapsoss::RailsErrorSubscriber.new)
-      end
+    initializer 'lapsoss.add_middleware', after: 'lapsoss.configure' do |app|
+      app.middleware.insert_before ActionDispatch::ShowExceptions, Lapsoss::Middleware
     end
 
-
+    initializer 'lapsoss.rails_error_subscriber', after: 'lapsoss.add_middleware' do |app|
+      app.executor.error_reporter.subscribe(Lapsoss::RailsErrorSubscriber.new)
+    end
 
     rake_tasks do
       # Add any Lapsoss-specific rake tasks here
@@ -43,7 +43,7 @@ module Lapsoss
         level: level,
         tags: {
           handled: handled,
-          source: source || "rails"
+          source: source || 'rails'
         },
         context: context
       )
@@ -53,8 +53,8 @@ module Lapsoss
 
     def skip_error?(error, source)
       # Skip cache-related Redis errors if configured to do so
-      if Lapsoss.configuration.skip_rails_cache_errors
-        return true if source&.include?("cache") && error.is_a?(Redis::CannotConnectError)
+      if Lapsoss.configuration.skip_rails_cache_errors && source&.include?('cache') && error.is_a?(Redis::CannotConnectError)
+        return true
       end
 
       false

data/lib/lapsoss/registry.rb

@@ -1,13 +1,7 @@
 # frozen_string_literal: true
 
-require "singleton"
-require "concurrent"
-require_relative "adapters/base"
-require_relative "adapters/logger_adapter"
-require_relative "adapters/sentry_adapter"
-require_relative "adapters/appsignal_adapter"
-require_relative "adapters/rollbar_adapter"
-require_relative "adapters/insight_hub_adapter"
+require 'singleton'
+require 'concurrent'
 
 module Lapsoss
   class Registry
@@ -38,12 +32,24 @@ module Lapsoss
       adapter
     end
 
+    # Register an adapter instance directly (for testing)
+    #
+    # @param adapter [Adapter] The adapter instance to register
+    def register_adapter(adapter)
+      name = if adapter.respond_to?(:name) && adapter.name
+               adapter.name.to_sym
+             else
+               adapter.class.name.split('::').last.to_sym
+             end
+      @adapters[name] = adapter
+    end
+
     # Unregister an adapter
     #
     # @param name [Symbol] The adapter name to remove
     def unregister(name)
       adapter = @adapters.delete(name.to_sym)
-      adapter&.shutdown if adapter&.respond_to?(:shutdown)
+      adapter&.shutdown if adapter.respond_to?(:shutdown)
       adapter
     end
 
@@ -79,7 +85,7 @@ module Lapsoss
 
     # Clear all adapters
     def clear!
-      @adapters.values.each do |adapter|
+      @adapters.each_value do |adapter|
         adapter.shutdown if adapter.respond_to?(:shutdown)
       end
       @adapters.clear
@@ -96,19 +102,14 @@ module Lapsoss
 
     # Resolve adapter type to class
     def resolve_adapter_class(type)
-      adapter_map[type.to_sym] || raise(AdapterNotFoundError, "Unknown adapter type: #{type}")
-    end
+      # Try to get the class by convention: Adapters::{Type}Adapter
+      class_name = "#{type.to_s.split('_').map(&:capitalize).join}Adapter"
 
-    # Map of adapter types to classes
-    def adapter_map
-      {
-        logger: Adapters::LoggerAdapter,
-        sentry: Adapters::SentryAdapter,
-        appsignal: Adapters::AppsignalAdapter,
-        rollbar: Adapters::RollbarAdapter,
-        insight_hub: Adapters::InsightHubAdapter,
-        bugsnag: Adapters::InsightHubAdapter # Backwards compatibility
-      }
+      begin
+        Adapters.const_get(class_name)
+      rescue NameError
+        raise AdapterNotFoundError, "Unknown adapter type: #{type}. Expected class: Lapsoss::Adapters::#{class_name}"
+      end
     end
   end
 end