activerabbit-ai 0.4.0 → 0.4.2

data/lib/active_rabbit/client/railtie.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "logger"
+
 begin
   require "rails/railtie"
 rescue LoadError
@@ -10,51 +12,327 @@ rescue LoadError
 end
 
 require "securerandom"
+require_relative "../reporting"
+require_relative "../middleware/error_capture_middleware"
 
 module ActiveRabbit
   module Client
     class Railtie < Rails::Railtie
       config.active_rabbit = ActiveSupport::OrderedOptions.new
 
-      initializer "active_rabbit.configure" do |app|
+      initializer "active_rabbit.configure", after: :initialize_logger do |app|
+        if Rails.env.development?
+          puts "\n=== ActiveRabbit Configure ==="
+          puts "Environment: #{Rails.env}"
+          puts "Already configured? #{ActiveRabbit::Client.configured?}"
+          puts "================================\n"
+        end
+
         # Configure ActiveRabbit from Rails configuration
         ActiveRabbit::Client.configure do |config|
           config.environment = Rails.env
-          config.logger = Rails.logger
+          config.logger = Rails.logger rescue Logger.new(STDOUT)
           config.release = detect_release(app)
         end
 
+        if Rails.env.development?
+          puts "\n=== ActiveRabbit Post-Configure ==="
+          puts "Now configured? #{ActiveRabbit::Client.configured?}"
+          puts "Configuration: #{ActiveRabbit::Client.configuration.inspect}"
+          puts "================================\n"
+        end
+
         # Set up exception tracking
         setup_exception_tracking(app) if ActiveRabbit::Client.configured?
       end
 
-      initializer "active_rabbit.subscribe_to_notifications" do
-        next unless ActiveRabbit::Client.configured?
+      initializer "active_rabbit.subscribe_to_notifications" do |app|
+        # Defer subscription until after application initializers (configuration complete)
+        app.config.after_initialize do
+          # Subscribe regardless; each handler guards on configured?
+          subscribe_to_controller_events
+          subscribe_to_active_record_events
+          subscribe_to_action_view_events
+          subscribe_to_action_mailer_events if defined?(ActionMailer)
+          subscribe_to_exception_notifications
+
+          # Fallback: low-level rack.exception subscription (older Rails and deep middleware errors)
+          ActiveSupport::Notifications.subscribe("rack.exception") do |*args|
+            begin
+              payload = args.last
+              exception = payload[:exception_object]
+              env = payload[:env]
+              next unless exception
+
+              ActiveRabbit::Reporting.report_exception(
+                exception,
+                env: env,
+                handled: false,
+                source: "rack.exception",
+                force: true
+              )
+            rescue => e
+              Rails.logger.error "[ActiveRabbit] Error handling rack.exception: #{e.class}: #{e.message}" if defined?(Rails)
+            end
+          end
+        end
+      end
+
+      # Configure middleware after logger is initialized to avoid init cycles
+      initializer "active_rabbit.add_middleware", after: :initialize_logger do |app|
+        if Rails.env.development?
+          puts "\n=== ActiveRabbit Railtie Loading ==="
+          puts "Rails Environment: #{Rails.env}"
+          puts "Rails Middleware Stack Phase: #{app.middleware.respond_to?(:middlewares) ? 'Ready' : 'Not Ready'}"
+          puts "================================\n"
+          puts "\n=== Initial Middleware Stack ==="
+          puts "(not available at this boot phase)"
+          puts "=======================\n"
+        end
+
+        puts "\n=== Adding ActiveRabbit Middleware ===" if Rails.env.development?
+        # Handle both development (DebugExceptions) and production (ShowExceptions)
+        if defined?(ActionDispatch::DebugExceptions)
+          puts "[ActiveRabbit] Found DebugExceptions, configuring middleware..." if Rails.env.development?
+
+          # First remove any existing middleware to avoid duplicates
+          begin
+            app.config.middleware.delete(ActiveRabbit::Client::ExceptionMiddleware)
+            app.config.middleware.delete(ActiveRabbit::Client::RequestContextMiddleware)
+            app.config.middleware.delete(ActiveRabbit::Client::RoutingErrorCatcher)
+            puts "[ActiveRabbit] Cleaned up existing middleware" if Rails.env.development?
+          rescue => e
+            puts "[ActiveRabbit] Error cleaning middleware: #{e.message}"
+          end
+
+          # Insert middleware in the correct order
+          puts "[ActiveRabbit] Inserting middleware..." if Rails.env.development?
+
+          # Insert ErrorCaptureMiddleware after DebugExceptions to rely on rescue path
+          app.config.middleware.insert_after(ActionDispatch::DebugExceptions, ActiveRabbit::Middleware::ErrorCaptureMiddleware)
+
+          # Insert RequestContextMiddleware early in the stack
+          puts "[ActiveRabbit] Inserting RequestContextMiddleware before RequestId" if Rails.env.development?
+          app.config.middleware.insert_before(ActionDispatch::RequestId, ActiveRabbit::Client::RequestContextMiddleware)
+
+          # Insert ExceptionMiddleware before Rails' exception handlers (kept for env-based reporting)
+          puts "[ActiveRabbit] Inserting ExceptionMiddleware before DebugExceptions" if Rails.env.development?
+          app.config.middleware.insert_before(ActionDispatch::DebugExceptions, ActiveRabbit::Client::ExceptionMiddleware)
+
+          # Insert RoutingErrorCatcher after Rails' exception handlers
+          puts "[ActiveRabbit] Inserting RoutingErrorCatcher after DebugExceptions" if Rails.env.development?
+          app.config.middleware.insert_after(ActionDispatch::DebugExceptions, ActiveRabbit::Client::RoutingErrorCatcher)
+
+          puts "[ActiveRabbit] Middleware insertion complete" if Rails.env.development?
+
+        elsif defined?(ActionDispatch::ShowExceptions)
+          puts "[ActiveRabbit] Found ShowExceptions, configuring middleware..." if Rails.env.development?
+
+          # First remove any existing middleware to avoid duplicates
+          begin
+            app.config.middleware.delete(ActiveRabbit::Client::ExceptionMiddleware)
+            app.config.middleware.delete(ActiveRabbit::Client::RequestContextMiddleware)
+            app.config.middleware.delete(ActiveRabbit::Client::RoutingErrorCatcher)
+            puts "[ActiveRabbit] Cleaned up existing middleware" if Rails.env.development?
+          rescue => e
+            puts "[ActiveRabbit] Error cleaning middleware: #{e.message}"
+          end
+
+          # Insert middleware in the correct order
+          puts "[ActiveRabbit] Inserting middleware..." if Rails.env.development?
+
+          # Insert ErrorCaptureMiddleware after ShowExceptions
+          app.config.middleware.insert_after(ActionDispatch::ShowExceptions, ActiveRabbit::Middleware::ErrorCaptureMiddleware)
+
+          # Insert RequestContextMiddleware early in the stack
+          puts "[ActiveRabbit] Inserting RequestContextMiddleware before RequestId" if Rails.env.development?
+          app.config.middleware.insert_before(ActionDispatch::RequestId, ActiveRabbit::Client::RequestContextMiddleware)
 
-        # Subscribe to Action Controller events
-        subscribe_to_controller_events
+          # Insert ExceptionMiddleware before Rails' exception handlers
+          puts "[ActiveRabbit] Inserting ExceptionMiddleware before ShowExceptions" if Rails.env.development?
+          app.config.middleware.insert_before(ActionDispatch::ShowExceptions, ActiveRabbit::Client::ExceptionMiddleware)
 
-        # Subscribe to Active Record events
-        subscribe_to_active_record_events
+          # Insert RoutingErrorCatcher after Rails' exception handlers
+          puts "[ActiveRabbit] Inserting RoutingErrorCatcher after ShowExceptions" if Rails.env.development?
+          app.config.middleware.insert_after(ActionDispatch::ShowExceptions, ActiveRabbit::Client::RoutingErrorCatcher)
 
-        # Subscribe to Action View events
-        subscribe_to_action_view_events
+        else
+          puts "[ActiveRabbit] No exception handlers found, using fallback configuration" if Rails.env.development?
+          app.config.middleware.use(ActiveRabbit::Middleware::ErrorCaptureMiddleware)
+          app.config.middleware.use(ActiveRabbit::Client::RequestContextMiddleware)
+          app.config.middleware.use(ActiveRabbit::Client::ExceptionMiddleware)
+          app.config.middleware.use(ActiveRabbit::Client::RoutingErrorCatcher)
+        end
+
+        if Rails.env.development?
+          puts "\n=== Final Middleware Stack ==="
+          puts "(will be printed after initialize)"
+          puts "=======================\n"
+        end
 
-        # Subscribe to Action Mailer events (if available)
-        subscribe_to_action_mailer_events if defined?(ActionMailer)
+          # Add debug wrappers in development
+        if Rails.env.development?
+          # Wrap ExceptionMiddleware for detailed error tracking
+          ActiveRabbit::Client::ExceptionMiddleware.class_eval do
+            alias_method :__ar_original_call, :call unless method_defined?(:__ar_original_call)
+            def call(env)
+              puts "\n=== ExceptionMiddleware Enter ==="
+              puts "Path: #{env['PATH_INFO']}"
+              puts "Method: #{env['REQUEST_METHOD']}"
+              puts "Current Exception: #{env['action_dispatch.exception']&.class} - #{env['action_dispatch.exception']&.message}"
+              puts "Current Error: #{env['action_dispatch.error']&.class} - #{env['action_dispatch.error']&.message}"
+              puts "Rack Exception: #{env['rack.exception']&.class} - #{env['rack.exception']&.message}"
+              puts "Exception Backtrace: #{env['action_dispatch.exception']&.backtrace&.first(3)&.join("\n                    ")}"
+              puts "Error Backtrace: #{env['action_dispatch.error']&.backtrace&.first(3)&.join("\n                ")}"
+              puts "Rack Backtrace: #{env['rack.exception']&.backtrace&.first(3)&.join("\n               ")}"
+              puts "============================\n"
+
+              begin
+                status, headers, body = __ar_original_call(env)
+                puts "\n=== ExceptionMiddleware Exit (Success) ==="
+                puts "Status: #{status}"
+                puts "Headers: #{headers.inspect}"
+                puts "Final Exception: #{env['action_dispatch.exception']&.class} - #{env['action_dispatch.exception']&.message}"
+                puts "Final Error: #{env['action_dispatch.error']&.class} - #{env['action_dispatch.error']&.message}"
+                puts "Final Rack Exception: #{env['rack.exception']&.class} - #{env['rack.exception']&.message}"
+                puts "Final Exception Backtrace: #{env['action_dispatch.exception']&.backtrace&.first(3)&.join("\n                          ")}"
+                puts "Final Error Backtrace: #{env['action_dispatch.error']&.backtrace&.first(3)&.join("\n                      ")}"
+                puts "Final Rack Backtrace: #{env['rack.exception']&.backtrace&.first(3)&.join("\n                     ")}"
+                puts "===========================\n"
+                [status, headers, body]
+              rescue => e
+                puts "\n=== ExceptionMiddleware Exit (Error) ==="
+                puts "Error: #{e.class} - #{e.message}"
+                puts "Error Backtrace: #{e.backtrace&.first(3)&.join("\n              ")}"
+                puts "Original Exception: #{env['action_dispatch.exception']&.class} - #{env['action_dispatch.exception']&.message}"
+                puts "Original Error: #{env['action_dispatch.error']&.class} - #{env['action_dispatch.error']&.message}"
+                puts "Original Rack Exception: #{env['rack.exception']&.class} - #{env['rack.exception']&.message}"
+                puts "Original Exception Backtrace: #{env['action_dispatch.exception']&.backtrace&.first(3)&.join("\n                          ")}"
+                puts "Original Error Backtrace: #{env['action_dispatch.error']&.backtrace&.first(3)&.join("\n                      ")}"
+                puts "Original Rack Backtrace: #{env['rack.exception']&.backtrace&.first(3)&.join("\n                     ")}"
+                puts "===========================\n"
+                raise
+              end
+            end
+          end
+
+          # Wrap RoutingErrorCatcher for detailed error tracking
+          ActiveRabbit::Client::RoutingErrorCatcher.class_eval do
+            alias_method :__ar_routing_original_call, :call unless method_defined?(:__ar_routing_original_call)
+            def call(env)
+              puts "\n=== RoutingErrorCatcher Enter ==="
+              puts "Path: #{env['PATH_INFO']}"
+              puts "Method: #{env['REQUEST_METHOD']}"
+              puts "Status: #{env['action_dispatch.exception']&.class}"
+              puts "============================\n"
+
+              begin
+                status, headers, body = __ar_routing_original_call(env)
+                puts "\n=== RoutingErrorCatcher Exit (Success) ==="
+                puts "Status: #{status}"
+                puts "===========================\n"
+                [status, headers, body]
+              rescue => e
+                puts "\n=== RoutingErrorCatcher Exit (Error) ==="
+                puts "Error: #{e.class} - #{e.message}"
+                puts "Backtrace: #{e.backtrace&.first(3)&.join("\n           ")}"
+                puts "===========================\n"
+                raise
+              end
+            end
+          end
+        end
+
+        # In development, add a hook to verify middleware after initialization
+        if Rails.env.development?
+          app.config.after_initialize do
+            Rails.logger.info "\n=== ActiveRabbit Configuration ==="
+            Rails.logger.info "Version: #{ActiveRabbit::Client::VERSION}"
+            Rails.logger.info "Environment: #{Rails.env}"
+            Rails.logger.info "API URL: #{ActiveRabbit::Client.configuration.api_url}"
+            Rails.logger.info "================================"
+
+            Rails.logger.info "\n=== Middleware Stack ==="
+            (Rails.application.middleware.middlewares rescue []).each do |mw|
+              klass = (mw.respond_to?(:klass) ? mw.klass.name : mw.to_s) rescue mw.inspect
+              Rails.logger.info "  #{klass}"
+            end
+            Rails.logger.info "======================="
+
+            # Skip missing-middleware warnings in development since we may inject via alternate paths
+            unless Rails.env.development?
+              # Verify our middleware is present
+              our_middleware = [
+                ActiveRabbit::Client::ExceptionMiddleware,
+                ActiveRabbit::Client::RequestContextMiddleware,
+                ActiveRabbit::Client::RoutingErrorCatcher
+              ]
+
+              stack_list = (Rails.application.middleware.middlewares rescue [])
+              missing = our_middleware.reject { |m| stack_list.any? { |x| (x.respond_to?(:klass) ? x.klass == m : false) } }
+
+              if missing.any?
+                Rails.logger.warn "\n⚠️  Missing ActiveRabbit middleware:"
+                missing.each { |m| Rails.logger.warn "  - #{m}" }
+                Rails.logger.warn "This might affect error tracking!"
+              end
+            end
+          end
+        end
 
-        # Subscribe to exception notifications
-        subscribe_to_exception_notifications
+        Rails.logger.info "[ActiveRabbit] Middleware configured successfully"
       end
 
-      initializer "active_rabbit.add_middleware" do |app|
-        next unless ActiveRabbit::Client.configured?
+      initializer "active_rabbit.error_reporter" do |app|
+        # Defer attaching so application config has been applied
+        app.config.after_initialize do
+          ActiveRabbit::Client::ErrorReporter.attach!
+        end
+      end
 
-        # Add request context middleware
-        app.middleware.insert_before ActionDispatch::ShowExceptions, RequestContextMiddleware
+      initializer "active_rabbit.sidekiq" do
+        next unless defined?(Sidekiq)
 
-        # Add exception catching middleware
-        app.middleware.insert_before ActionDispatch::ShowExceptions, ExceptionMiddleware
+        # Report unhandled Sidekiq job errors
+        Sidekiq.configure_server do |config|
+          config.error_handlers << proc do |exception, context|
+            begin
+              ActiveRabbit::Client.track_exception(
+                exception,
+                context: { source: 'sidekiq', job: context }
+              )
+            rescue => e
+              Rails.logger.error "[ActiveRabbit] Sidekiq error handler failed: #{e.class} - #{e.message}" if defined?(Rails)
+            end
+          end
+        end
+      end
+
+      initializer "active_rabbit.active_job" do |app|
+        next unless defined?(ActiveJob)
+
+        # Load extension
+        begin
+          require_relative "active_job_extensions"
+        rescue LoadError
+        end
+
+        app.config.after_initialize do
+          begin
+            ActiveJob::Base.include(ActiveRabbit::Client::ActiveJobExtensions)
+          rescue => e
+            Rails.logger.error "[ActiveRabbit] Failed to include ActiveJobExtensions: #{e.message}" if defined?(Rails)
+          end
+        end
+      end
+
+      initializer "active_rabbit.action_mailer" do |app|
+        next unless defined?(ActionMailer)
+
+        begin
+          require_relative "action_mailer_patch"
+        rescue LoadError
+        end
       end
 
       initializer "active_rabbit.setup_shutdown_hooks" do
@@ -85,6 +363,20 @@ module ActiveRabbit
         end
       end
 
+      # Boot diagnostics to confirm wiring
+      initializer "active_rabbit.boot_diagnostics" do |app|
+        app.config.after_initialize do
+          begin
+            reporting_file, reporting_line = ActiveRabbit::Reporting.method(:report_exception).source_location
+            http_file, http_line = ActiveRabbit::Client::HttpClient.instance_method(:post_exception).source_location
+            Rails.logger.info "[ActiveRabbit] Reporting loaded from #{reporting_file}:#{reporting_line}" if defined?(Rails)
+            Rails.logger.info "[ActiveRabbit] HttpClient#post_exception from #{http_file}:#{http_line}" if defined?(Rails)
+          rescue => e
+            Rails.logger.debug "[ActiveRabbit] boot diagnostics failed: #{e.message}" if defined?(Rails)
+          end
+        end
+      end
+
       private
 
       def setup_exception_tracking(app)
@@ -235,6 +527,7 @@ module ActiveRabbit
 
           ActiveRabbit::Client.track_exception(
             exception,
+            handled: true,
             context: {
               request: {
                 method: data[:method],
@@ -363,41 +656,92 @@ module ActiveRabbit
       end
 
       def call(env)
-        @app.call(env)
-      rescue Exception => exception
-        # Track the exception, but don't let tracking errors break the request
+        # debug start - using Rails.logger to ensure it appears in development.log
+        Rails.logger.info "[AR] ExceptionMiddleware ENTER path=#{env['PATH_INFO']}" if defined?(Rails)
+        warn "[AR] ExceptionMiddleware ENTER path=#{env['PATH_INFO']}"
+        warn "[AR] Current exceptions in env:"
+        warn "  - action_dispatch.exception: #{env['action_dispatch.exception']&.class}"
+        warn "  - rack.exception: #{env['rack.exception']&.class}"
+        warn "  - action_dispatch.error: #{env['action_dispatch.error']&.class}"
+
         begin
-          request = ActionDispatch::Request.new(env)
+          # Try to call the app, catch any exceptions
+          status, headers, body = @app.call(env)
+          warn "[AR] App call completed with status: #{status}"
+
+          # Check for exceptions in env after app call
+          if (ex = env["action_dispatch.exception"] || env["rack.exception"] || env["action_dispatch.error"])
+            Rails.logger.info "[AR] env exception present: #{ex.class}: #{ex.message}" if defined?(Rails)
+            warn "[AR] env exception present: #{ex.class}: #{ex.message}"
+            warn "[AR] Exception backtrace: #{ex.backtrace&.first(3)&.join("\n           ")}"
+            safe_report(ex, env, 'Rails rescued exception')
+          else
+            Rails.logger.info "[AR] env exception NOT present" if defined?(Rails)
+            warn "[AR] env exception NOT present"
+            warn "[AR] Final env check:"
+            warn "  - action_dispatch.exception: #{env['action_dispatch.exception']&.class}"
+            warn "  - rack.exception: #{env['rack.exception']&.class}"
+            warn "  - action_dispatch.error: #{env['action_dispatch.error']&.class}"
+          end
 
-          ActiveRabbit::Client.track_exception(
-            exception,
-            context: {
-              request: {
-                method: request.method,
-                path: request.path,
-                query_string: request.query_string,
-                user_agent: request.headers["User-Agent"],
-                ip_address: request.remote_ip,
-                referer: request.referer,
-                headers: sanitize_headers(request.headers)
-              },
-              middleware: {
-                caught_by: 'ExceptionMiddleware',
-                timestamp: Time.now.iso8601(3)
-              }
+          # Return the response
+          [status, headers, body]
+        rescue => e
+          # Primary path: catch raw exceptions before Rails rescuers
+          Rails.logger.info "[AR] RESCUE caught: #{e.class}: #{e.message}" if defined?(Rails)
+          warn "[AR] RESCUE caught: #{e.class}: #{e.message}"
+          warn "[AR] Rescue backtrace: #{e.backtrace&.first(3)&.join("\n           ")}"
+
+          # Report the exception
+          safe_report(e, env, 'Raw exception caught')
+
+          # Let Rails handle the exception
+          env["action_dispatch.exception"] = e
+          env["rack.exception"] = e
+          raise
+        end
+      end
+
+      private
+
+      def safe_report(exception, env, source)
+        begin
+          request = ActionDispatch::Request.new(env)
+          warn "[AR] safe_report called for #{source}"
+          warn "[AR] Exception: #{exception.class.name} - #{exception.message}"
+          warn "[AR] Backtrace: #{exception.backtrace&.first(3)&.join("\n           ")}"
+
+          context = {
+            request: {
+              method: request.method,
+              path: request.path,
+              query_string: request.query_string,
+              user_agent: request.headers["User-Agent"],
+              ip_address: request.remote_ip,
+              referer: request.referer,
+              headers: sanitize_headers(request.headers)
+            },
+            middleware: {
+              caught_by: 'ExceptionMiddleware',
+              source: source,
+              timestamp: Time.now.iso8601(3)
             }
-          )
+          }
+
+          warn "[AR] Tracking with context: #{context.inspect}"
+
+          result = ActiveRabbit::Client.track_exception(exception, context: context)
+          warn "[AR] Track result: #{result.inspect}"
+
+          Rails.logger.info "[ActiveRabbit] Tracked #{source}: #{exception.class.name} - #{exception.message}" if defined?(Rails)
         rescue => tracking_error
           # Log tracking errors but don't let them interfere with exception handling
+          warn "[AR] Error in safe_report: #{tracking_error.class} - #{tracking_error.message}"
+          warn "[AR] Error backtrace: #{tracking_error.backtrace&.first(3)&.join("\n           ")}"
           Rails.logger.error "[ActiveRabbit] Error tracking exception: #{tracking_error.message}" if defined?(Rails)
         end
-
-        # Re-raise the original exception so Rails can handle it normally
-        raise exception
       end
 
-      private
-
       def sanitize_headers(headers)
         # Only include safe headers to avoid PII
         safe_headers = {}
@@ -412,5 +756,107 @@ module ActiveRabbit
         safe_headers
       end
     end
+
+    # Middleware for catching routing errors
+    class RoutingErrorCatcher
+      def initialize(app) = @app = app
+
+      def call(env)
+        status, headers, body = @app.call(env)
+
+        if status == 404
+          Rails.logger.debug "[ActiveRabbit] RoutingErrorCatcher: 404 detected for #{env['PATH_INFO']}"
+          exception = env["action_dispatch.exception"] || env["rack.exception"] || env["action_dispatch.error"]
+
+          if exception && exception.is_a?(ActionController::RoutingError)
+            Rails.logger.debug "[ActiveRabbit] Routing error caught: #{exception.message}"
+            track_routing_error(exception, env)
+          else
+            # If no exception found in env, create one manually for 404s on non-asset paths
+            if env['PATH_INFO'] && !env['PATH_INFO'].match?(/\.(css|js|png|jpg|gif|ico|svg)$/)
+              synthetic_error = create_synthetic_error(env)
+              track_routing_error(synthetic_error, env)
+            end
+          end
+        end
+
+        [status, headers, body]
+      rescue => e
+        # Catch any routing errors that weren't handled by Rails
+        if e.is_a?(ActionController::RoutingError)
+          Rails.logger.debug "[ActiveRabbit] Unhandled routing error caught: #{e.message}"
+          track_routing_error(e, env, handled: false)
+        end
+        raise
+      end
+
+      private
+
+      def create_synthetic_error(env)
+        error = ActionController::RoutingError.new("No route matches [#{env['REQUEST_METHOD']}] \"#{env['PATH_INFO']}\"")
+        error.set_backtrace([
+          "#{Rails.root}/config/routes.rb:1:in `route_not_found'",
+          "#{__FILE__}:#{__LINE__}:in `call'",
+          "actionpack/lib/action_dispatch/middleware/debug_exceptions.rb:31:in `call'"
+        ])
+        error
+      end
+
+      def track_routing_error(error, env, handled: true)
+        return unless defined?(ActiveRabbit::Client)
+
+        context = {
+          controller_action: 'Routing#not_found',
+          error_type: 'Route Not Found',
+          error_message: error.message,
+          error_location: error.backtrace&.first,
+          error_severity: :warning,
+          error_status: 404,
+          error_source: 'Router',
+          error_component: 'ActionDispatch',
+          error_action: 'route_lookup',
+          request_details: "#{env['REQUEST_METHOD']} #{env['PATH_INFO']} (No Route)",
+          response_time: "N/A (Routing Error)",
+          routing_info: "No matching route for path: #{env['PATH_INFO']}",
+          environment: Rails.env,
+          occurred_at: Time.current.iso8601(3),
+          request_path: env['PATH_INFO'],
+          request_method: env['REQUEST_METHOD'],
+          handled: handled,
+          error: {
+            class: error.class.name,
+            message: error.message,
+            backtrace_preview: error.backtrace&.first(3),
+            handled: handled,
+            severity: :warning,
+            framework: 'Rails',
+            component: 'Router',
+            error_group: 'Routing Error',
+            error_type: 'route_not_found'
+          },
+          request: {
+            method: env['REQUEST_METHOD'],
+            path: env['PATH_INFO'],
+            query_string: env['QUERY_STRING'],
+            user_agent: env['HTTP_USER_AGENT'],
+            ip_address: env['REMOTE_ADDR']
+          },
+          routing: {
+            attempted_path: env['PATH_INFO'],
+            available_routes: 'See Rails routes',
+            error_type: 'route_not_found'
+          },
+          source: 'routing_error_catcher',
+          tags: {
+            error_type: 'routing_error',
+            handled: handled,
+            severity: 'warning'
+          }
+        }
+
+        # Force reporting so 404 ignore filters don't drop this
+        ActiveRabbit::Client.track_exception(error, context: context, handled: handled, force: true)
+      end
+    end
   end
 end

data/lib/active_rabbit/client/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRabbit
   module Client
-    VERSION = "0.4.0"
+    VERSION = "0.4.2"
   end
 end

data/lib/active_rabbit/client.rb

@@ -8,6 +8,7 @@ require_relative "client/exception_tracker"
 require_relative "client/performance_monitor"
 require_relative "client/n_plus_one_detector"
 require_relative "client/pii_scrubber"
+require_relative "client/error_reporter"
 
 # Rails integration (optional)
 begin
@@ -58,15 +59,28 @@ module ActiveRabbit
         )
       end
 
-      def track_exception(exception, context: {}, user_id: nil, tags: {})
+      def track_exception(exception, context: {}, user_id: nil, tags: {}, handled: nil, force: false)
         return unless configured?
 
-        exception_tracker.track_exception(
+        context_with_tags = context
+
+        # Track the exception
+        args = {
           exception: exception,
-          context: context,
+          context: context_with_tags,
           user_id: user_id,
           tags: tags
-        )
+        }
+        args[:handled] = handled unless handled.nil?
+        args[:force] = true if force
+
+        result = exception_tracker.track_exception(**args)
+
+        # Log the result
+        configuration.logger&.info("[ActiveRabbit] Exception tracked: #{exception.class.name}")
+        configuration.logger&.debug("[ActiveRabbit] Exception tracking result: #{result.inspect}")
+
+        result
       end
 
       def track_performance(name, duration_ms, metadata: {})
@@ -108,6 +122,11 @@ module ActiveRabbit
         http_client.shutdown
       end
 
+      # Manual capture convenience for non-Rails contexts
+      def capture_exception(exception, context: {}, user_id: nil, tags: {})
+        track_exception(exception, context: context, user_id: user_id, tags: tags)
+      end
+
       private
 
       def event_processor