lapsoss 0.4.5 → 0.4.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5db26196bdbf6e69d90c126041f7310681e240ef22e61f0a3aee12035f7616da
-  data.tar.gz: 93a2c75b6af04e776aca9c24f3704ddba51b4a2432d5d6db0f736874bef17c69
+  metadata.gz: 6e053057613e5678e160556abda63a224b056bb4b0b4b1d291282b2c1a8476ea
+  data.tar.gz: c6109d65cfb08dc095c45862565b6754a720e18d52f27814c0606a307964f328
 SHA512:
-  metadata.gz: 38d9d2d1c1e2f67997b71cae8776b2c7ef8b3aca5d13d563080304c63b84b1db227eb923618b1ae078223cfc20dfebf5d1620dcf01eed92ee62d53461bf36e1e
-  data.tar.gz: 1831cda3198ad594c850fd5579fed77aa9097ee4f497dd81374bb265ee237addc4d31fab0447d6164cff6fb64695869eba42366e0820647725d0725566158ff8
+  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/concerns/http_delivery.rb

@@ -122,7 +122,7 @@ module Lapsoss
         end
 
         def user_agent
-          "Lapsoss/#{Lapsoss::VERSION} Ruby/#{RUBY_VERSION} Rails/#{Rails.version if defined?(Rails)}"
+          Base::USER_AGENT
         end
       end
     end

data/lib/lapsoss/adapters/sentry_adapter.rb

@@ -2,6 +2,7 @@
 
 require "active_support/core_ext/object/blank"
 require "uri"
+require "lapsoss/runtime_context"
 
 module Lapsoss
   module Adapters
@@ -80,7 +81,7 @@ module Lapsoss
           content_type: "application/json"
         }
 
-        item_payload = build_envelope_wrapper(event)
+        item_payload = build_sentry_event(event)
 
         # Sentry envelope is newline-delimited JSON
         [
@@ -90,6 +91,89 @@ module Lapsoss
         ].join("\n")
       end
 
+      # Build Sentry-compliant event structure
+      def build_sentry_event(event)
+        context = RuntimeContext.current
+        event_id = event.fingerprint.presence || SecureRandom.uuid
+
+        base_event = {
+          event_id: event_id,
+          timestamp: format_timestamp(event.timestamp),
+          platform: "ruby",
+          level: map_level(event.level),
+          environment: event.environment.presence || "production",
+          release: context.release,
+          server_name: context.server_name,
+          modules: context.modules,
+          contexts: context.to_contexts,
+          tags: event.tags.presence,
+          user: event.user_context.presence,
+          extra: event.extra.presence,
+          breadcrumbs: format_breadcrumbs(event.breadcrumbs),
+          transaction: event.transaction,
+          sdk: {
+            name: "lapsoss.ruby",
+            version: Lapsoss::VERSION
+          }
+        }.compact_blank
+
+        # Add event-specific data
+        case event.type
+        when :exception
+          base_event.merge(build_exception_envelope(event))
+        when :message
+          base_event.merge(
+            message: event.message,
+            level: map_level(event.level)
+          )
+        else
+          base_event
+        end
+      end
+
+      def build_exception_envelope(event)
+        {
+          exception: {
+            values: [ {
+              type: event.exception_type,
+              value: event.exception_message,
+              module: nil,
+              thread_id: Thread.current.object_id,
+              stacktrace: build_sentry_stacktrace(event),
+              mechanism: { type: "generic", handled: true }
+            } ]
+          },
+          threads: {
+            values: [ {
+              id: Thread.current.object_id,
+              name: Thread.current.name,
+              crashed: true,
+              current: true
+            } ]
+          }
+        }
+      end
+
+      def build_sentry_stacktrace(event)
+        return nil unless event.has_backtrace?
+
+        frames = event.backtrace_frames.map do |frame|
+          {
+            filename: frame.filename,
+            abs_path: frame.absolute_path || frame.filename,
+            function: frame.method_name || frame.function,
+            lineno: frame.line_number,
+            in_app: frame.in_app,
+            pre_context: frame.code_context&.dig(:pre_context),
+            context_line: frame.code_context&.dig(:context_line),
+            post_context: frame.code_context&.dig(:post_context)
+          }.compact
+        end
+
+        # Sentry expects frames in reverse order (oldest to newest)
+        { frames: frames.reverse }
+      end
+
       # Override serialization for Sentry's envelope format
       def serialize_payload(envelope_string)
         # Sentry envelopes are already formatted, just compress if needed

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

@@ -3,6 +3,7 @@
 module Lapsoss
   BacktraceFrame = Data.define(
     :filename,
+    :absolute_path,
     :line_number,
     :method_name,
     :in_app,
@@ -19,6 +20,7 @@ module Lapsoss
     def to_h
       {
         filename: filename,
+        absolute_path: absolute_path,
         line_number: line_number,
         method: method_name,
         function: function,
@@ -30,9 +32,13 @@ module Lapsoss
     end
 
     def add_code_context(processor, context_lines = 3)
-      return unless filename && line_number && File.exist?(filename)
+      return unless line_number
 
-      with(code_context: processor.get_code_context(filename, line_number, context_lines))
+      # Use absolute path if available, otherwise try filename
+      path_to_read = absolute_path || filename
+      return unless path_to_read
+
+      with(code_context: processor.get_code_context(path_to_read, line_number, context_lines))
     end
 
     def valid?

data/lib/lapsoss/backtrace_frame_factory.rb

@@ -75,10 +75,14 @@ module Lapsoss
       filename, line_number, method_name, function, module_name, block_info = parse_line_components
 
       in_app = determine_app_status(filename)
-      filename = normalize_path(filename) if filename
+
+      # Keep both absolute and normalized paths
+      absolute_path = filename
+      normalized_filename = normalize_path(filename) if filename
 
       BacktraceFrame.new(
-        filename: filename,
+        filename: normalized_filename,
+        absolute_path: absolute_path,
         line_number: line_number,
         method_name: method_name,
         in_app: in_app,

data/lib/lapsoss/backtrace_processor.rb

@@ -196,8 +196,7 @@ module Lapsoss
 
     # Get code context around a specific line number using ActiveSupport::Cache
     def get_code_context(filename, line_number, context_lines = 3)
-      return nil unless filename && File.exist?(filename)
-      return nil if File.size(filename) > (@config[:max_file_size] || (1024 * 1024))
+      return nil unless filename
 
       lines = @file_cache.fetch(filename) do
         read_file_safely(filename)
@@ -229,6 +228,9 @@ module Lapsoss
     private
 
     def read_file_safely(filename)
+      # Don't read huge files
+      return [] if File.exist?(filename) && File.size(filename) > (@config[:max_file_size] || (1024 * 1024))
+
       File.readlines(filename, chomp: true)
     rescue StandardError
       []

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+require "socket"
+
+module Lapsoss
+  # Boot-time context collection using Data class
+  RuntimeContext = Data.define(:os, :runtime, :modules, :server_name, :release) do
+    def self.current
+      @current ||= new(
+        os: collect_os_context,
+        runtime: collect_runtime_context,
+        modules: collect_modules,
+        server_name: collect_server_name,
+        release: collect_release
+      )
+    end
+
+    def self.collect_os_context
+      {
+        name: RbConfig::CONFIG["host_os"],
+        version: `uname -r 2>/dev/null`.strip.presence,
+        build: `uname -v 2>/dev/null`.strip.presence,
+        kernel_version: `uname -a 2>/dev/null`.strip.presence,
+        machine: RbConfig::CONFIG["host_cpu"]
+      }.compact
+    rescue
+      { name: RbConfig::CONFIG["host_os"] }
+    end
+
+    def self.collect_runtime_context
+      {
+        name: "ruby",
+        version: RUBY_DESCRIPTION
+      }
+    end
+
+    def self.collect_modules
+      return {} unless defined?(Bundler)
+
+      Bundler.load.specs.each_with_object({}) do |spec, h|
+        h[spec.name] = spec.version.to_s
+      end
+    rescue
+      {}
+    end
+
+    def self.collect_server_name
+      Socket.gethostname
+    rescue
+      "unknown"
+    end
+
+    def self.collect_release
+      # Try to get from git if available
+      if File.exist?(".git")
+        `git rev-parse HEAD 2>/dev/null`.strip.presence
+      end
+    rescue
+      nil
+    end
+
+    def to_contexts
+      {
+        os: os,
+        runtime: runtime
+      }
+    end
+  end
+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.5"
+  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.5
+  version: 0.4.9
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -249,12 +249,14 @@ 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
 - lib/lapsoss/router.rb
+- lib/lapsoss/runtime_context.rb
 - lib/lapsoss/sampling/base.rb
 - lib/lapsoss/sampling/rate_limiter.rb
 - lib/lapsoss/sampling/uniform_sampler.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