lapsoss 0.4.6 → 0.4.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc2f5c5b2a06b525bb921e683c87a201e93507c795b6cff7e4cddc33d3716880
-  data.tar.gz: 3d5bce60161f233758b0f39fdf54197ac7c5b0db921709ac3e1a4e54531bf669
+  metadata.gz: 6e053057613e5678e160556abda63a224b056bb4b0b4b1d291282b2c1a8476ea
+  data.tar.gz: c6109d65cfb08dc095c45862565b6754a720e18d52f27814c0606a307964f328
 SHA512:
-  metadata.gz: 569ae7372bbe9f3984c0cb1b13074e1442af9f34cb21e74124f04db1a62227a7ac08c8d856d08c739e9da05a799c288260b72e62e8e7df44f5fa853bfacf5d7b
-  data.tar.gz: 6e17e4ffdd5d757fb70414da87e188ee12dbc1469bb37ac978554c2fc5146e5f86ebb257daefe37748e3129140d402d34c517ac1c756aa56c56defdd41a159e9
+  metadata.gz: 944d8581a4dc544e14f2daf5094d9af5d59e5f387802212a2342f8b33f88790e218fe365df882cc6b56444edeb72addf1815ff4851c6eb9f5e50ecf388d22797
+  data.tar.gz: e4c712a550906d722d7a954d04560de2f4d6119a51d8c5271ca73cf4b7b8ca8a45ea238eddc3fb11366dbd35bc9f3dbc5cb3dc85544f4bbee8ccdd38d78858ec

data/README.md

@@ -23,10 +23,10 @@ Lapsoss.configure do |config|
   # Monday: Using Bugsnag
   config.use_bugsnag(api_key: ENV['BUGSNAG_KEY'])
 
-  # Tuesday: Add Sentry for comparison
-  config.use_sentry(dsn: ENV['SENTRY_DSN'])
+  # Tuesday: Add Telebugs for comparison
+  config.use_telebugs(dsn: ENV['TELEBUGS_DSN'])
 
-  # Wednesday: Drop Bugsnag, keep Sentry
+  # Wednesday: Drop Bugsnag, keep Telebugs
   # Just remove the line. Zero code changes.
 end
 ```
@@ -64,7 +64,7 @@ That's it. No 500-line examples needed.
 
 ## Built for Rails, Not Around It
 
-Lapsoss integrates with Rails' native error reporting API introduced in Rails 7. No monkey-patching, no middleware gymnastics:
+Lapsoss integrates with Rails' native error reporting API introduced in Rails 7. No monkey-patching, no global error handlers:
 
 ```ruby
 # It just works with Rails.error:
@@ -74,6 +74,56 @@ end
 # Automatically captured by whatever service you configured
 ```
 
+### Rails Integration Options
+
+**Option 1: Automatic Rails.error Integration (Recommended)**
+```ruby
+# config/initializers/lapsoss.rb  
+Lapsoss.configure do |config|
+  config.use_appsignal(push_api_key: ENV['APPSIGNAL_KEY'])
+end
+
+# That's it! All Rails errors are automatically captured
+# Works with Rails.error.handle, Rails.error.record, Rails.error.report
+# No code changes needed - just configure and go
+```
+
+**Option 2: Add Controller Context (Optional)**
+```ruby
+# app/controllers/application_controller.rb
+class ApplicationController < ActionController::Base
+  include Lapsoss::RailsControllerContext
+end
+
+# Now all errors include controller/action context:
+# { controller: "users", action: "show", controller_class: "UsersController" }
+```
+
+**Option 3: Manual Error Reporting (Your Choice)**
+```ruby
+# In controllers, jobs, or anywhere you want explicit control
+begin
+  process_payment
+rescue => e
+  Lapsoss.capture_exception(e, user_id: current_user.id)
+  # Handle gracefully...
+end
+
+# Or use Rails.error directly with your configured services
+Rails.error.report(e, context: { user_id: current_user.id })
+```
+
+### No Global Patching Philosophy
+
+Unlike other gems, Lapsoss **never** automatically captures all exceptions. You stay in control:
+
+- ✅ **Rails.error integration only** - Uses Rails' official API
+- ✅ **Explicit error handling** - You choose what to capture
+- ✅ **No global hooks** - Your app behavior never changes
+- ✅ **Optional controller context** - Include if you want it
+
+This means your application behaves exactly the same with or without Lapsoss. No surprises, no changed behavior, no conflicts with other gems.
+
 ## Zero-Downtime Vendor Migration
 
 ```ruby
@@ -84,21 +134,22 @@ gem 'bugsnag' # Keep your existing gem for now
 # Step 2: Configure dual reporting
 Lapsoss.configure do |config|
   config.use_bugsnag(api_key: ENV['BUGSNAG_KEY'])
-  config.use_sentry(dsn: ENV['SENTRY_DSN'])
+  config.use_telebugs(dsn: ENV['TELEBUGS_DSN'])
 end
 
 # Step 3: Gradually replace Bugsnag calls
 # Old: Bugsnag.notify(e)
 # New: Lapsoss.capture_exception(e)
 
-# Step 4: Remove bugsnag gem when ready
-# Your app keeps running, now on Sentry
+# Step 4: Remove bugsnag gem when ready  
+# Your app keeps running, now on Telebugs
 ```
 
 ## Why Not Just Use Vendor SDKs?
 
 **Vendor SDKs monkey-patch your application:**
 - Sentry patches Net::HTTP, Redis, and 20+ other gems
+- Bugsnag patches ActionController, ActiveJob, and more
 - Each vendor races to patch the same methods
 - Multiple SDKs = multiple layers of patches
 - Your app behavior changes based on load order
@@ -114,8 +165,8 @@ end
 ### GDPR Compliance
 ```ruby
 # Route EU data to EU servers, US data to US servers
-config.use_sentry(name: :us, dsn: ENV['US_DSN'])
-config.use_sentry(name: :eu, dsn: ENV['EU_DSN'])
+config.use_sentry(name: :us, dsn: ENV['US_SENTRY_DSN'])
+config.use_telebugs(name: :eu, dsn: ENV['EU_TELEBUGS_DSN'])
 ```
 
 ### A/B Testing Error Services
@@ -128,8 +179,8 @@ config.use_sentry(name: :candidate, dsn: ENV['SENTRY_DSN'])
 ### High Availability
 ```ruby
 # Multiple providers for redundancy
-config.use_sentry(name: :primary, dsn: ENV['PRIMARY_DSN'])
-config.use_rollbar(name: :backup, access_token: ENV['BACKUP_TOKEN'])
+config.use_telebugs(name: :primary, dsn: ENV['PRIMARY_DSN'])
+config.use_appsignal(name: :backup, push_api_key: ENV['APPSIGNAL_KEY'])
 ```
 
 ## Yes, We Require ActiveSupport
@@ -172,7 +223,7 @@ All adapters are pure Ruby implementations with no external SDK dependencies:
 ```ruby
 # config/initializers/lapsoss.rb
 Lapsoss.configure do |config|
-  config.use_sentry(dsn: ENV["SENTRY_DSN"])
+  config.use_telebugs(dsn: ENV["TELEBUGS_DSN"])
 end
 ```
 
@@ -203,7 +254,7 @@ end
 ```ruby
 Lapsoss.configure do |config|
   # Adapter setup
-  config.use_sentry(dsn: ENV['SENTRY_DSN'])
+  config.use_rollbar(access_token: ENV['ROLLBAR_TOKEN'])
 
   # Data scrubbing (uses Rails filter_parameters automatically)
   config.scrub_fields = %w[password credit_card ssn] # Or leave nil to use Rails defaults

data/lib/lapsoss/adapters/sentry_adapter.rb

@@ -110,8 +110,9 @@ module Lapsoss
           user: event.user_context.presence,
           extra: event.extra.presence,
           breadcrumbs: format_breadcrumbs(event.breadcrumbs),
+          transaction: event.transaction,
           sdk: {
-            name: "sentry.ruby",
+            name: "lapsoss.ruby",
             version: Lapsoss::VERSION
           }
         }.compact_blank

data/lib/lapsoss/adapters/telebugs_adapter.rb

@@ -8,20 +8,25 @@ module Lapsoss
     # Telebugs is compatible with Sentry's API, so we inherit from SentryAdapter
     class TelebugsAdapter < SentryAdapter
       def initialize(name = :telebugs, settings = {})
+        debug_log "[TELEBUGS INIT] Initializing with settings: #{settings.inspect}"
         super(name, settings)
+        debug_log "[TELEBUGS INIT] Initialization complete, enabled: #{@enabled}"
       end
 
       private
 
       # Override to parse Telebugs DSN format
       def parse_dsn(dsn_string)
+        debug_log "[TELEBUGS DSN] Parsing DSN: #{dsn_string}"
         uri = URI.parse(dsn_string)
-        {
+        parsed = {
           public_key: uri.user,
           project_id: uri.path.split("/").last,
           host: uri.host,
           path: uri.path
         }
+        debug_log "[TELEBUGS DSN] Parsed: #{parsed.inspect}"
+        parsed
       end
 
       # Override to build Telebugs-specific API path
@@ -42,8 +47,42 @@ module Lapsoss
         uri = URI.parse(@settings[:dsn])
         # For Telebug, we use the full URL without port (unless non-standard)
         port = (uri.port == 443 || uri.port == 80) ? "" : ":#{uri.port}"
-        self.class.api_endpoint = "#{uri.scheme}://#{uri.host}#{port}"
-        self.class.api_path = build_api_path(uri)
+        endpoint = "#{uri.scheme}://#{uri.host}#{port}"
+        api_path = build_api_path(uri)
+
+        debug_log "[TELEBUGS ENDPOINT] Setting endpoint: #{endpoint}"
+        debug_log "[TELEBUGS ENDPOINT] Setting API path: #{api_path}"
+
+        self.class.api_endpoint = endpoint
+        self.class.api_path = api_path
+      end
+
+      public
+
+      # Override capture to add debug logging
+      def capture(event)
+        debug_log "[TELEBUGS DEBUG] Capture called for event: #{event.type}"
+        debug_log "[TELEBUGS DEBUG] DSN configured: #{@dsn.inspect}"
+        debug_log "[TELEBUGS DEBUG] Endpoint: #{self.class.api_endpoint}"
+        debug_log "[TELEBUGS DEBUG] API Path: #{self.class.api_path}"
+
+        result = super(event)
+        debug_log "[TELEBUGS DEBUG] Event sent successfully, response: #{result.inspect}"
+        result
+      rescue => e
+        debug_log "[TELEBUGS ERROR] Failed to send: #{e.message}", :error
+        debug_log "[TELEBUGS ERROR] Backtrace: #{e.backtrace.first(5).join("\n")}", :error
+        raise
+      end
+
+      def debug_log(message, level = :info)
+        return unless @debug
+
+        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+          Rails.logger.public_send(level, message)
+        elsif @logger
+          @logger.public_send(level, message)
+        end
       end
 
       # Override headers builder to add Telebugs-specific headers

data/lib/lapsoss/client.rb

@@ -6,32 +6,35 @@ module Lapsoss
   class Client
     def initialize(configuration)
       @configuration = configuration
-      @executor = Concurrent::FixedThreadPool.new(5) if @configuration.async
+      # Note: We're using Thread.new directly for async mode instead of a thread pool
+      # The Concurrent::FixedThreadPool had issues in Rails development mode
     end
 
     def capture_exception(exception, **context)
-      return unless @configuration.enabled
+      return nil unless @configuration.enabled
 
       with_scope(context) do |scope|
         event = Event.build(
           type: :exception,
           level: :error,
           exception: exception,
-          context: scope_to_context(scope)
+          context: scope_to_context(scope),
+          transaction: scope.transaction_name
         )
         capture_event(event)
       end
     end
 
     def capture_message(message, level: :info, **context)
-      return unless @configuration.enabled
+      return nil unless @configuration.enabled
 
       with_scope(context) do |scope|
         event = Event.build(
           type: :message,
           level: level,
           message: message,
-          context: scope_to_context(scope)
+          context: scope_to_context(scope),
+          transaction: scope.transaction_name
         )
         capture_event(event)
       end
@@ -58,30 +61,54 @@ module Lapsoss
     end
 
     def flush(timeout: 2)
-      Registry.instance.flush(timeout: timeout)
+      @configuration.logger.debug("[LAPSOSS] Flush called with timeout: #{timeout}")
+      # Give threads a moment to complete
+      sleep(0.5) if @configuration.async
+
+      # Flush individual adapters if they support it
+      Registry.instance.active.each do |adapter|
+        adapter.flush(timeout: timeout) if adapter.respond_to?(:flush)
+      end
     end
 
     def shutdown
-      @executor&.shutdown
       Registry.instance.shutdown
     end
 
     private
 
     def capture_event(event)
+      @configuration.logger.debug("[LAPSOSS] capture_event called, async: #{@configuration.async}, executor: #{@executor.inspect}")
+
       # Apply pipeline processing if enabled
       if @configuration.enable_pipeline && @configuration.pipeline
         event = @configuration.pipeline.call(event)
-        return unless event
+        return nil unless event
       end
 
       event = run_before_send(event)
-      return unless event
+      return nil unless event
 
       if @configuration.async
-        @executor.post { Router.process_event(event) }
+        @configuration.logger.debug("[LAPSOSS ASYNC] About to process event asynchronously")
+
+        # Use Thread.new for now - the executor pool seems to have issues in Rails dev mode
+        thread = Thread.new do
+          begin
+            @configuration.logger.debug("[LAPSOSS ASYNC] Background thread started")
+            Router.process_event(event)
+            @configuration.logger.debug("[LAPSOSS ASYNC] Background thread completed")
+          rescue => e
+            @configuration.logger.error("[LAPSOSS ASYNC ERROR] Failed in background: #{e.message}")
+            @configuration.logger.error(e.backtrace.join("\n")) if @configuration.debug
+          end
+        end
+
+        thread
       else
+        @configuration.logger.debug("[LAPSOSS SYNC] Processing event synchronously")
         Router.process_event(event)
+        nil
       end
     rescue StandardError => e
       handle_capture_error(e)

data/lib/lapsoss/configuration.rb

@@ -59,6 +59,7 @@ module Lapsoss
       # Pipeline settings
       @enable_pipeline = true
       @pipeline_builder = nil
+      @pipeline = nil
       @sampling_strategy = nil
       # Rails error filtering
       @skip_rails_cache_errors = true
@@ -185,7 +186,12 @@ module Lapsoss
     end
 
     def pipeline
-      @pipeline_builder&.pipeline
+      @pipeline || @pipeline_builder&.pipeline
+    end
+
+    def pipeline=(value)
+      validate_callable!(value, "pipeline") if value
+      @pipeline = value
     end
 
     # Sampling configuration

data/lib/lapsoss/event.rb

@@ -16,7 +16,8 @@ module Lapsoss
     :context,
     :environment,
     :fingerprint,
-    :backtrace_frames
+    :backtrace_frames,
+    :transaction     # Controller#action or task name where event occurred
   ) do
     # Factory method with smart defaults
     def self.build(type:, level: :info, **attributes)
@@ -43,7 +44,8 @@ module Lapsoss
         context: context,
         environment: environment,
         fingerprint: fingerprint,
-        backtrace_frames: backtrace_frames
+        backtrace_frames: backtrace_frames,
+        transaction: attributes[:transaction]
       )
     end
 

data/lib/lapsoss/merged_scope.rb

@@ -25,6 +25,24 @@ module Lapsoss
       @breadcrumbs ||= merge_breadcrumbs
     end
 
+    def transaction_name
+      # Check scope stack first (most recent wins)
+      @scope_stack.reverse_each do |context|
+        return context[:transaction_name] if context[:transaction_name]
+      end
+      # Fall back to base scope
+      @base_scope.transaction_name
+    end
+
+    def transaction_source
+      # Check scope stack first (most recent wins)
+      @scope_stack.reverse_each do |context|
+        return context[:transaction_source] if context[:transaction_source]
+      end
+      # Fall back to base scope
+      @base_scope.transaction_source
+    end
+
     def add_breadcrumb(message, type: :default, **metadata)
       breadcrumb = Breadcrumb.build(message, type: type, metadata: metadata)
       @own_breadcrumbs << breadcrumb
@@ -34,6 +52,10 @@ module Lapsoss
       @breadcrumbs = nil
     end
 
+    def set_transaction_name(name, source: nil)
+      @base_scope.set_transaction_name(name, source: source)
+    end
+
     private
 
     def merge_hash_contexts(key)

data/lib/lapsoss/rails_controller_context.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  # Optional concern to add controller and action context to Rails.error
+  # Include this in ApplicationController or specific controllers to get more detailed context
+  #
+  # Example:
+  #   class ApplicationController < ActionController::Base
+  #     include Lapsoss::RailsControllerContext
+  #   end
+  module RailsControllerContext
+    extend ActiveSupport::Concern
+
+    included do
+      prepend_before_action :set_lapsoss_controller_context
+    end
+
+    private
+
+    def set_lapsoss_controller_context
+      # Set context in Lapsoss scope if available
+      Lapsoss::Current.scope&.set_context("controller", {
+        controller: controller_name,
+        action: action_name,
+        controller_class: self.class.name
+      })
+
+      # Set context in Rails.error for ecosystem-wide availability
+      Rails.error.set_context(
+        controller: controller_name,
+        action: action_name,
+        controller_class: self.class.name
+      )
+    end
+  end
+end

data/lib/lapsoss/rails_controller_transaction.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module RailsControllerTransaction
+    extend ActiveSupport::Concern
+
+    included do
+      around_action :lapsoss_capture_transaction
+    end
+
+    private
+
+    def lapsoss_capture_transaction
+      if Lapsoss.client
+        transaction_name = "#{self.class.name}##{action_name}"
+
+        # Set the transaction name in the current scope
+        Lapsoss::Current.scope.set_transaction_name(transaction_name, source: :view)
+
+        # Add breadcrumb for the action
+        Lapsoss::Current.scope.add_breadcrumb(
+          "Processing #{transaction_name}",
+          type: :navigation,
+          controller: self.class.name,
+          action: action_name,
+          params: request.filtered_parameters
+        )
+      end
+
+      yield
+    end
+  end
+end

data/lib/lapsoss/railtie.rb

@@ -2,13 +2,7 @@
 
 module Lapsoss
   class Railtie < Rails::Railtie
-    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
+    # Debug logging removed - will be handled by the configured logger
     config.lapsoss = ActiveSupport::OrderedOptions.new
 
     initializer "lapsoss.configure" do |_app|
@@ -20,12 +14,11 @@ module Lapsoss
                                  Rails.env
         end
 
-        # 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
+        # Use Rails logger if available
+        config.logger ||= Rails.logger
+
+        # Set debug level in development
+        config.debug = Rails.env.development?
 
         config.release ||= if Rails.application.respond_to?(:version)
                              Rails.application.version.to_s
@@ -41,15 +34,16 @@ module Lapsoss
       end
     end
 
-    initializer "lapsoss.add_middleware" do |app|
-      require "lapsoss/rails_middleware"
 
-      # Use config.middleware to ensure it's added during initialization
-      app.config.middleware.use Lapsoss::RailsMiddleware
+    initializer "lapsoss.rails_error_subscriber" do |app|
+      Rails.error.subscribe(Lapsoss::RailsErrorSubscriber.new)
     end
 
-    initializer "lapsoss.rails_error_subscriber", after: "lapsoss.add_middleware" do |app|
-      Rails.error.subscribe(Lapsoss::RailsErrorSubscriber.new)
+    initializer "lapsoss.controller_transaction" do
+      ActiveSupport.on_load(:action_controller) do
+        require "lapsoss/rails_controller_transaction"
+        include Lapsoss::RailsControllerTransaction
+      end
     end
   end
 end

data/lib/lapsoss/router.rb

@@ -8,8 +8,13 @@ module Lapsoss
       #
       # @param event [Lapsoss::Event] The event to process.
       def process_event(event)
-        Registry.instance.active.each do |adapter|
+        adapters = Registry.instance.active
+        Lapsoss.configuration.logger.debug("[LAPSOSS ROUTER] Processing event to #{adapters.length} adapters: #{adapters.map(&:name).join(', ')}")
+
+        adapters.each do |adapter|
+          Lapsoss.configuration.logger.info("[LAPSOSS ROUTER] About to call #{adapter.name}.capture")
           adapter.capture(event)
+          Lapsoss.configuration.logger.info("[LAPSOSS ROUTER] Adapter #{adapter.name} completed")
         rescue StandardError => e
           handle_adapter_error(adapter, event, e)
         end

data/lib/lapsoss/scope.rb

@@ -3,12 +3,15 @@
 module Lapsoss
   class Scope
     attr_reader :breadcrumbs, :tags, :user, :extra
+    attr_accessor :transaction_name, :transaction_source
 
     def initialize
       @breadcrumbs = []
       @tags = {}
       @user = {}
       @extra = {}
+      @transaction_name = nil
+      @transaction_source = nil
     end
 
     def add_breadcrumb(message, type: :default, **metadata)
@@ -36,6 +39,8 @@ module Lapsoss
       @tags.clear
       @user.clear
       @extra.clear
+      @transaction_name = nil
+      @transaction_source = nil
     end
 
     def set_context(key, value)
@@ -61,5 +66,10 @@ module Lapsoss
     def set_extras(extras)
       @extra.merge!(extras)
     end
+
+    def set_transaction_name(name, source: nil)
+      @transaction_name = name
+      @transaction_source = source if source
+    end
   end
 end

data/lib/lapsoss/version.rb

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

data/lib/lapsoss.rb

@@ -37,6 +37,8 @@ module Lapsoss
     end
 
     def capture_exception(exception, **context)
+      configuration.logger.debug "[LAPSOSS] capture_exception called for #{exception.class}"
+      return unless client
       client.capture_exception(exception, **context)
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lapsoss
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 0.4.9
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -249,8 +249,9 @@ files:
 - lib/lapsoss/middleware/release_tracker.rb
 - lib/lapsoss/pipeline.rb
 - lib/lapsoss/pipeline_builder.rb
+- lib/lapsoss/rails_controller_context.rb
+- lib/lapsoss/rails_controller_transaction.rb
 - lib/lapsoss/rails_error_subscriber.rb
-- lib/lapsoss/rails_middleware.rb
 - lib/lapsoss/railtie.rb
 - lib/lapsoss/registry.rb
 - lib/lapsoss/release_tracker.rb

data/lib/lapsoss/rails_middleware.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module Lapsoss
-  class RailsMiddleware
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      Lapsoss::Current.with_clean_scope do
-        # Add request context to current scope
-        if Lapsoss.configuration.capture_request_context
-          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.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
-          raise
-        end
-      end
-    end
-
-    private
-
-    def add_request_context(env)
-      request = Rack::Request.new(env)
-
-      return unless Lapsoss::Current.scope
-
-      Lapsoss::Current.scope.set_context("request", {
-                                           method: request.request_method,
-                                           url: request.url,
-                                           path: request.path,
-                                           query_string: request.query_string,
-                                           headers: extract_headers(env),
-                                           ip: request.ip,
-                                           user_agent: request.user_agent,
-                                           referer: request.referer,
-                                           request_id: env["action_dispatch.request_id"] || env["HTTP_X_REQUEST_ID"]
-                                         })
-
-      # Add user context if available
-      return unless env["warden"]&.user
-
-      user = env["warden"].user
-      Lapsoss::Current.scope.set_user(
-        id: user.id,
-        email: user.respond_to?(:email) ? user.email : nil
-      )
-    end
-
-    def extract_headers(env)
-      headers = {}
-
-      env.each do |key, value|
-        if key.start_with?("HTTP_") && FILTERED_HEADERS.exclude?(key)
-          header_name = key.sub(/^HTTP_/, "").split("_").map(&:capitalize).join("-")
-          headers[header_name] = value
-        end
-      end
-
-      headers
-    end
-
-    FILTERED_HEADERS = %w[
-      HTTP_AUTHORIZATION
-      HTTP_COOKIE
-      HTTP_X_API_KEY
-      HTTP_X_AUTH_TOKEN
-    ].freeze
-  end
-end