activerabbit-ai 0.4.4 → 0.4.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86853d97a830e8d411ba9052ff231b29a2cddb526799e6b5c89e848ce026c7b2
-  data.tar.gz: 1faeb9a59503089d03b0ecda80fab72cd8028b3bfd49f4da5c5d25ff9cfb3139
+  metadata.gz: 06e58258544f159566a756467253a1a2a6a0a696479b37cd1f265902928a3f8c
+  data.tar.gz: e12b3dcd16a43ca524027e2b0ecd608d8bbe0441f2f89586d7bb5d1f57dbda1a
 SHA512:
-  metadata.gz: 760d010f75113d98d6e2f83fd3768d37d7cf67e307c24418717caa8c07ea489337ed7923ef876ed7bb95e4556e6780466efaec374d2ffc62d00b7b16a37f6fda
-  data.tar.gz: 441b28d1cc42c02a13c3efe4d387674932fceafca7c8571c6b24792ac69134338050ad030ebe65253ee48387e108b8b7d85014866bd42fed1e56f1c9fa356647
+  metadata.gz: eb2e853ad6f3791c567a9498af2a6684756042d0b7fa626e94ae057910422a594f0d705f5fbc923334af52c110062701db37c86766d14be17ef41d495e758fae
+  data.tar.gz: d498e0a7c16cb8abeb8c96724caf88ad32ac598e0d84994c90712de3e8f182a763aaeda73f39c8a3f94b00c31ff1b5b3629535946313a8adec952ccb0bf0466b

data/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.4.7] - 2025-11-06
+
+### Fixed
+- **Multiple duplicate events**: Disabled Rails Error Reporter and rack.exception fallback subscriptions
+- These mechanisms were creating 3-4 duplicate events for each error
+- Middleware is now the single source of truth for error capture, providing the best context
+- Each error now creates exactly ONE event instead of 3-4
+
+### Changed
+- Rails Error Reporter subscription: DISABLED (middleware captures all controller errors)
+- rack.exception subscription: DISABLED (middleware captures all rack-level errors)
+- Middleware remains as the primary and only error capture mechanism
+
+## [0.4.6] - 2025-11-05
+
+### Fixed
+- **Duplicate issues bug**: Fixed error reporting creating duplicate issues with "unknown" controller_action
+- Error Reporter now properly extracts controller/action from Rails routing context
+- `rack.exception` fallback now also extracts controller_action correctly
+- All error capture mechanisms now produce consistent controller_action values, preventing duplicate issue grouping
+
+### Details
+Previously, the same error could create multiple issues in the dashboard:
+- Middleware capture: `TestController#action` ✓
+- Rails Error Reporter: `unknown` ✗ (created duplicate)
+- Rack.exception fallback: `unknown` ✗ (created duplicate)
+
+Now all mechanisms extract and use the same controller_action format, ensuring errors are properly grouped into a single issue.
+
 ## [0.4.4] - 2025-10-22
 
 ### Improved

data/lib/active_rabbit/client/error_reporter.rb

@@ -12,23 +12,23 @@ module ActiveRabbit
 
             # Time-based deduplication: track errors with timestamps
             $reported_errors ||= {}
-            
+
             # Generate a unique key for this error
             error_key = "#{exception.class.name}:#{exception.message}:#{exception.backtrace&.first}"
-            
+
             # Get dedupe window from config (default 5 minutes, 0 = disabled)
-            dedupe_window = defined?(ActiveRabbit::Client.configuration.dedupe_window) ? 
+            dedupe_window = defined?(ActiveRabbit::Client.configuration.dedupe_window) ?
                             ActiveRabbit::Client.configuration.dedupe_window : 300
-            
+
             current_time = Time.now.to_i
             last_seen = $reported_errors[error_key]
-            
+
             # Report if: never seen before, OR dedupe disabled (0), OR outside dedupe window
             should_report = last_seen.nil? || dedupe_window == 0 || (current_time - last_seen) > dedupe_window
-            
+
             if should_report
               $reported_errors[error_key] = current_time
-              
+
               # Clean old entries to prevent memory leak (keep last hour)
               $reported_errors.delete_if { |_, timestamp| current_time - timestamp > 3600 }
 
@@ -56,6 +56,20 @@ module ActiveRabbit
             # Top-level convenience for UI
             ctx[:request_path] = ctx[:request][:path]
             ctx[:request_method] = ctx[:request][:method]
+            
+            # Extract controller_action from routing info to prevent duplicate issues
+            routing = req_info[:routing]
+            if routing && routing[:controller] && routing[:action]
+              controller_name = routing[:controller].to_s
+              action_name = routing[:action].to_s
+              ctx[:controller_action] = "#{controller_name}##{action_name}"
+            end
+          else
+            # Fallback: Try to extract from controller instance in context
+            controller = context && (context[:controller] || context['controller'])
+            if controller && controller.respond_to?(:controller_name) && controller.respond_to?(:action_name)
+              ctx[:controller_action] = "#{controller.controller_name.camelize}Controller##{controller.action_name}"
+            end
           end
 
           if defined?(ActionController::RoutingError) && exception.is_a?(ActionController::RoutingError)

data/lib/active_rabbit/client/performance_monitor.rb

@@ -77,10 +77,22 @@ module ActiveRabbit
       private
 
       def build_performance_data(name:, duration_ms:, metadata:)
+        metadata = metadata || {}
+
+        # Extract important fields from metadata for top-level inclusion
+        controller = metadata[:controller] || metadata["controller"]
+        action = metadata[:action] || metadata["action"]
+        controller_action = "#{controller}##{action}" if controller && action
+
         data = {
           name: name.to_s,
           duration_ms: duration_ms.to_f,
-          metadata: scrub_pii(metadata || {}),
+          db_duration_ms: metadata[:db_runtime] || metadata["db_runtime"],
+          view_duration_ms: metadata[:view_runtime] || metadata["view_runtime"],
+          controller_action: controller_action,
+          request_path: metadata[:path] || metadata["path"],
+          request_method: metadata[:method] || metadata["method"],
+          metadata: scrub_pii(metadata),
           timestamp: Time.now.iso8601(3),
           environment: configuration.environment,
           release: configuration.release,

data/lib/active_rabbit/client/railtie.rb

@@ -46,35 +46,39 @@ module ActiveRabbit
         setup_exception_tracking(app) if ActiveRabbit::Client.configured?
       end
 
-      initializer "active_rabbit.subscribe_to_notifications" do |app|
-        # Defer subscription until after application initializers (configuration complete)
+      initializer "active_rabbit.subscribe_to_notifications", after: :load_config_initializers do |app|
+        Rails.logger.info "[ActiveRabbit] Setting up performance notifications subscriptions"
+        # 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
+        Rails.logger.info "[ActiveRabbit] Subscriptions setup complete"
+
+        # Defer complex subscriptions until after initialization
         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
+          # DISABLED: rack.exception creates duplicate events because middleware already catches all errors
+          # The middleware is the primary error capture mechanism and catches errors at the optimal level
+          # 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
 
@@ -284,10 +288,11 @@ module ActiveRabbit
       end
 
       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
+        # DISABLED: Rails error reporter creates duplicate events because middleware already catches all errors
+        # The middleware provides better context and catches errors at the right level
+        # app.config.after_initialize do
+        #   ActiveRabbit::Client::ErrorReporter.attach!
+        # end
       end
 
       initializer "active_rabbit.sidekiq" do
@@ -387,10 +392,20 @@ module ActiveRabbit
       end
 
       def subscribe_to_controller_events
+        Rails.logger.info "[ActiveRabbit] Subscribing to controller events (configured=#{ActiveRabbit::Client.configured?})"
+
         ActiveSupport::Notifications.subscribe "process_action.action_controller" do |name, started, finished, unique_id, payload|
           begin
+            unless ActiveRabbit::Client.configured?
+              Rails.logger.debug "[ActiveRabbit] Skipping performance tracking - not configured"
+              return
+            end
+
             duration_ms = ((finished - started) * 1000).round(2)
 
+            Rails.logger.info "[ActiveRabbit] 📊 Controller action: #{payload[:controller]}##{payload[:action]} - #{duration_ms}ms"
+            Rails.logger.info "[ActiveRabbit] 📊 DB runtime: #{payload[:db_runtime]}, View runtime: #{payload[:view_runtime]}"
+
             ActiveRabbit::Client.track_performance(
               "controller.action",
               duration_ms,

data/lib/active_rabbit/client/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRabbit
   module Client
-    VERSION = "0.4.4"
+    VERSION = "0.4.7"
   end
 end

data/lib/active_rabbit/reporting.rb

@@ -16,6 +16,14 @@ module ActiveRabbit
       enriched_context[:source] ||= source
       enriched_context[:handled] = handled if !enriched_context.key?(:handled)
 
+      # Extract controller_action from routing info to prevent duplicate issues
+      routing = req_info[:routing]
+      if routing && routing[:controller] && routing[:action] && !enriched_context[:controller_action]
+        controller_name = routing[:controller].to_s
+        action_name = routing[:action].to_s
+        enriched_context[:controller_action] = "#{controller_name}##{action_name}"
+      end
+
       # Enrich for routing errors so UI shows controller action and 404 specifics
       if defined?(ActionController::RoutingError) && exception.is_a?(ActionController::RoutingError)
         enriched_context[:controller_action] ||= 'Routing#not_found'

data/lib/active_rabbit.rb

@@ -4,11 +4,4 @@ require_relative "active_rabbit/client"
 require_relative "active_rabbit/routing/not_found_app"
 
 # Load Rails integration
-if defined?(Rails)
-  begin
-    require_relative "active_rabbit/client/railtie"
-  rescue => e
-    warn "[ActiveRabbit] Rails integration failed: #{e.message}" if Rails.env&.development?
-    warn "[ActiveRabbit] Backtrace: #{e.backtrace.first(5).join(', ')}" if Rails.env&.development?
-  end
-end
+require_relative "active_rabbit/client/railtie" if defined?(Rails)

data/lib/activerabbit-ai.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Compatibility loader for Bundler and Rails autoloading
+# because gem names cannot map "-" to "_" automatically.
+# This ensures `require "activerabbit-ai"` loads the real code.
+
+require_relative "active_rabbit"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerabbit-ai
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.7
 platform: ruby
 authors:
 - Alex Shapalov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-10-23 00:00:00.000000000 Z
+date: 2025-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -81,6 +81,7 @@ files:
 - README.md
 - Rakefile
 - TESTING_GUIDE.md
+- activerabbit-ai-0.4.5.gem
 - check_api_data.rb
 - examples/rails_app_testing.rb
 - examples/rails_integration.rb
@@ -105,6 +106,7 @@ files:
 - lib/active_rabbit/middleware/error_capture_middleware.rb
 - lib/active_rabbit/reporting.rb
 - lib/active_rabbit/routing/not_found_app.rb
+- lib/activerabbit-ai.rb
 - script/test_production_readiness.rb
 - script/test_rails_integration.rb
 - setup_local_gem_testing.sh