activerabbit-ai 0.4.1 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc6f70049c2b884248d9d15062ab2bb69887cdcf0430e92c96213d6a81559310
-  data.tar.gz: 2dd36a9c979f33b42bbe22e5422bc659a7d4c0752b312d9b8345cd2d11ad65bb
+  metadata.gz: 86853d97a830e8d411ba9052ff231b29a2cddb526799e6b5c89e848ce026c7b2
+  data.tar.gz: 1faeb9a59503089d03b0ecda80fab72cd8028b3bfd49f4da5c5d25ff9cfb3139
 SHA512:
-  metadata.gz: eebd3ced14adfd6831ec0405e2a33df376eb2e510156e37a78195038710133f75d2794b5aae06322ba3a7f1d29cb6633531a9eacc25e842df49995d85334739b
-  data.tar.gz: cc369187974da2d7c9b8fffccfc0079f875e1d78ae3644197eedeadfc64d0ab3e881c99ee1755597f85371bd7d923dbac2f8e403c0f62666c39fe75b070a0ee8
+  metadata.gz: 760d010f75113d98d6e2f83fd3768d37d7cf67e307c24418717caa8c07ea489337ed7923ef876ed7bb95e4556e6780466efaec374d2ffc62d00b7b16a37f6fda
+  data.tar.gz: 441b28d1cc42c02a13c3efe4d387674932fceafca7c8571c6b24792ac69134338050ad030ebe65253ee48387e108b8b7d85014866bd42fed1e56f1c9fa356647

data/CHANGELOG.md

@@ -2,6 +2,42 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.4.4] - 2025-10-22
+
+### Improved
+- **Time-based error deduplication**: Changed from "once per server lifecycle" to time-window based
+- Added `dedupe_window` configuration option (default: 300 seconds / 5 minutes)
+- Set `dedupe_window` to `0` to disable deduplication (useful for development/testing)
+- Automatic memory cleanup of old dedupe entries (keeps last hour only)
+- Better logging when errors are deduplicated
+
+### Fixed
+- Error deduplication no longer prevents same error from being reported after time window expires
+- Memory leak prevention by cleaning old deduplication entries
+
+## [0.4.3] - 2025-10-22
+
+### Fixed
+- **Critical bug fix**: Removed reference to non-existent `ActiveRabbit::Client::Dedupe` class in error reporter
+- Error tracking now works properly via Rails error reporter integration
+- Errors are successfully captured and sent to ActiveRabbit API
+
+## [0.4.2] - 2025-01-04
+
+### Fixed
+- **Major Rails 6.1 compatibility fix**: Added Rails Engine as primary integration method
+- Engine loads after Rails initialization (safer than Railtie)
+- Added comprehensive error handling for Rails loading edge cases
+- Fallback mechanism: Engine -> Railtie -> Graceful degradation
+- Fixed Logger initialization issues in Docker environments
+- Added better error messages for debugging Rails integration issues
+
+### Added
+- Rails Engine integration (`ActiveRabbit::Client::Engine`)
+- Safer middleware insertion with error handling
+- Enhanced shutdown hooks and signal handling
+- Better request context management
+
 ## [0.4.1] - 2025-01-04
 
 ### Fixed

data/README.md

@@ -236,6 +236,65 @@ ActiveRabbit::Client.configure do |config|
 end
 ```
 
+### Recommended Exceptions to Capture
+
+Below is a practical list of exceptions APMs should capture by default in a Rails app. Some are optional/noisy and typically excluded unless needed.
+
+- Core (Ruby/Stdlib)
+  - `StandardError`, `RuntimeError`, `NoMethodError`, `NameError`, `ArgumentError`, `TypeError`, `IndexError`, `KeyError`
+  - `Timeout::Error`, `JSON::ParserError`, `OpenSSL::SSL::SSLError`, `SocketError`, `Errno::ECONNREFUSED`/`ETIMEDOUT`/`EHOSTUNREACH`
+
+- ActionPack / Controllers
+  - `ActionController::ParameterMissing`
+  - `ActionController::BadRequest`
+  - `ActionController::InvalidAuthenticityToken` (optional; can be noisy)
+  - `ActionController::UnknownFormat`
+  - `ActionController::NotImplemented`
+
+- Routing (optional/noisy)
+  - `ActionController::RoutingError` (commonly excluded; enable only if needed)
+
+- Views / Templates
+  - `ActionView::Template::Error`
+  - `ActionView::MissingTemplate`
+  - `Encoding::UndefinedConversionError` (template rendering)
+
+- ActiveRecord / Database
+  - `ActiveRecord::RecordInvalid`
+  - `ActiveRecord::RecordNotFound` (optional; may be expected business logic)
+  - `ActiveRecord::StatementInvalid` (includes `PG::Error` subclasses)
+  - `ActiveRecord::Deadlocked`, `ActiveRecord::LockWaitTimeout`
+  - `ActiveRecord::RecordNotUnique`
+  - `ActiveRecord::ConnectionTimeoutError`
+  - `ActiveRecord::SerializationFailure`
+
+- Background Jobs (ActiveJob/Sidekiq)
+  - `ActiveJob::DeserializationError`
+  - Any unhandled exception raised in job `perform`
+
+- Networking/HTTP Clients
+  - `Net::OpenTimeout`, `Net::ReadTimeout`
+  - `Faraday::TimeoutError`, `Faraday::ConnectionFailed`
+  - `HTTP::Error` (http.rb), `RestClient::Exception`
+
+- Caching/Redis
+  - `Redis::BaseError`, `Redis::TimeoutError`, `Redis::CannotConnectError`
+
+- ActiveStorage
+  - `ActiveStorage::IntegrityError`
+  - `ActiveStorage::FileNotFoundError`
+
+- ActionCable
+  - `ActionCable::Connection::Authorization::UnauthorizedError` (if applicable)
+
+- Security/Crypto
+  - `ActiveSupport::MessageEncryptor::InvalidMessage`
+  - `ActiveSupport::MessageVerifier::InvalidSignature`
+
+Notes:
+- Optional/noisy: `RoutingError`, `RecordNotFound`, `InvalidAuthenticityToken`. Consider monitoring via metrics or targeted capture.
+- If exceptions are rescued by your app, enable reporting of rescued exceptions (`before_send_exception`/custom middleware) so they are still tracked when appropriate.
+
 ### Callbacks
 
 ```ruby

data/lib/active_rabbit/client/action_mailer_patch.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+return unless defined?(ActionMailer)
+
+module ActiveRabbit
+  module Client
+    module ActionMailerPatch
+      def deliver_now
+        start_time = Time.now
+        super
+      ensure
+        if ActiveRabbit::Client.configured?
+          duration_ms = ((Time.now - start_time) * 1000).round(2)
+          ActiveRabbit::Client.track_event(
+            "email_sent",
+            {
+              mailer: self.class.name,
+              message_id: (message.message_id rescue nil),
+              subject: (message.subject rescue nil),
+              to: (Array(message.to).first rescue nil),
+              duration_ms: duration_ms
+            }
+          )
+        end
+      end
+
+      def deliver_later
+        ActiveRabbit::Client.track_event(
+          "email_enqueued",
+          { mailer: self.class.name, subject: (message.subject rescue nil), to: (Array(message.to).first rescue nil) }
+        ) if ActiveRabbit::Client.configured?
+        super
+      end
+    end
+  end
+end
+
+ActionMailer::MessageDelivery.prepend(ActiveRabbit::Client::ActionMailerPatch)
+
+

data/lib/active_rabbit/client/active_job_extensions.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ActiveRabbit
+  module Client
+    module ActiveJobExtensions
+      def self.included(base)
+        base.around_perform do |job, block|
+          start_time = Time.now
+
+          Thread.current[:active_rabbit_job_context] = {
+            job_class: job.class.name,
+            job_id: job.job_id,
+            queue_name: job.queue_name,
+            arguments: ActiveRabbit::Client::ActiveJobExtensions.scrub_arguments(job.arguments),
+            provider_job_id: (job.respond_to?(:provider_job_id) ? job.provider_job_id : nil)
+          }
+
+          begin
+            block.call
+
+            duration_ms = ((Time.now - start_time) * 1000).round(2)
+            if ActiveRabbit::Client.configured?
+              ActiveRabbit::Client.track_performance(
+                "active_job.perform",
+                duration_ms,
+                metadata: { job_class: job.class.name, queue_name: job.queue_name, status: "completed" }
+              )
+            end
+          rescue Exception => exception
+            duration_ms = ((Time.now - start_time) * 1000).round(2)
+            if ActiveRabbit::Client.configured?
+              ActiveRabbit::Client.track_performance(
+                "active_job.perform",
+                duration_ms,
+                metadata: { job_class: job.class.name, queue_name: job.queue_name, status: "failed" }
+              )
+
+              ActiveRabbit::Client.track_exception(
+                exception,
+                context: {
+                  job: {
+                    job_class: job.class.name,
+                    job_id: job.job_id,
+                    queue_name: job.queue_name,
+                    arguments: ActiveRabbit::Client::ActiveJobExtensions.scrub_arguments(job.arguments)
+                  }
+                },
+                tags: { component: "active_job", queue: job.queue_name }
+              )
+            end
+            raise
+          ensure
+            Thread.current[:active_rabbit_job_context] = nil
+          end
+        end
+      end
+
+      def self.scrub_arguments(args)
+        return args unless ActiveRabbit::Client.configuration&.enable_pii_scrubbing
+        PiiScrubber.new(ActiveRabbit::Client.configuration).scrub(args)
+      end
+    end
+  end
+end
+
+

data/lib/active_rabbit/client/configuration.rb

@@ -11,12 +11,13 @@ module ActiveRabbit
       attr_accessor :batch_size, :flush_interval, :queue_size
       attr_accessor :enable_performance_monitoring, :enable_n_plus_one_detection
       attr_accessor :enable_pii_scrubbing, :pii_fields
-      attr_accessor :ignored_exceptions, :ignored_user_agents
+      attr_accessor :ignored_exceptions, :ignored_user_agents, :ignore_404
       attr_accessor :release, :server_name, :logger
       attr_accessor :before_send_event, :before_send_exception
+      attr_accessor :dedupe_window  # Time window in seconds for error deduplication (0 = disabled)
 
       def initialize
-        @api_url = ENV.fetch("active_rabbit_API_URL", "https://api.activerabbit.com")
+        @api_url = ENV.fetch("active_rabbit_API_URL", "https://api.activerabbit.ai")
         @api_key = ENV["active_rabbit_API_KEY"]
         @project_id = ENV["active_rabbit_PROJECT_ID"]
         @environment = ENV.fetch("active_rabbit_ENVIRONMENT", detect_environment)
@@ -45,9 +46,10 @@ module ActiveRabbit
         ]
 
         # Filtering
+        # default ignores (404 controlled by ignore_404)
+        @ignore_404 = true
         @ignored_exceptions = %w[
           ActiveRecord::RecordNotFound
-          ActionController::RoutingError
           ActionController::InvalidAuthenticityToken
           CGI::Session::CookieStore::TamperedWithCookie
         ]
@@ -59,6 +61,9 @@ module ActiveRabbit
           /Twitterbot/i
         ]
 
+        # Deduplication (0 = disabled, time in seconds for same error to be considered duplicate)
+        @dedupe_window = 300  # 5 minutes by default
+
         # Metadata
         @release = detect_release
         @server_name = detect_server_name
@@ -83,6 +88,14 @@ module ActiveRabbit
 
       def should_ignore_exception?(exception)
         return false unless exception
+        # Special-case 404 via flag
+        if @ignore_404
+          begin
+            return true if exception.is_a?(ActionController::RoutingError)
+          rescue NameError
+            # Ignore if AC not loaded
+          end
+        end
 
         ignored_exceptions.any? do |ignored|
           case ignored

data/lib/active_rabbit/client/dedupe.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module ActiveRabbit
+  module Client
+    module Dedupe
+      extend self
+
+      WINDOW_SECONDS = 5
+
+      @seen = {}
+      @lock = Monitor.new
+
+      def seen_recently?(exception, context = {}, window: WINDOW_SECONDS)
+        key = build_key(exception, context)
+        now = Time.now.to_f
+        @lock.synchronize do
+          prune!(now, window)
+          last = @seen[key]
+          @seen[key] = now
+          return last && (now - last) < window
+        end
+      end
+
+      private
+
+      def prune!(now, window)
+        cutoff = now - window
+        @seen.delete_if { |_k, ts| ts < cutoff }
+      end
+
+      def build_key(exception, context)
+        top = Array(exception.backtrace).first.to_s
+        req_id = context[:request]&.[](:request_id) || context[:request_id] || context[:requestId]
+        [exception.class.name, top, req_id].join("|")
+      end
+    end
+  end
+end
+
+

data/lib/active_rabbit/client/error_reporter.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+require 'set'
+require_relative '../reporting'
+
+module ActiveRabbit
+  module Client
+    module ErrorReporter
+      class Subscriber
+        def report(exception, handled:, severity:, context:, source: nil)
+          begin
+            Rails.logger.info "[ActiveRabbit] Error reporter caught: #{exception.class}: #{exception.message}" if defined?(Rails.logger)
+
+            # 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) ? 
+                            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 }
+
+              enriched = build_enriched_context(exception, handled: handled, severity: severity, context: context)
+              ActiveRabbit::Client.track_exception(exception, handled: handled, context: enriched)
+            else
+              Rails.logger.debug "[ActiveRabbit] Error deduplicated (last seen #{current_time - last_seen}s ago)" if defined?(Rails.logger)
+            end
+          rescue => e
+            Rails.logger.error "[ActiveRabbit] Error in ErrorReporter::Subscriber#report: #{e.class} - #{e.message}" if defined?(Rails.logger)
+          end
+        end
+
+        private
+
+        def build_enriched_context(exception, handled:, severity:, context: {})
+          ctx = { handled: handled, severity: severity, source: 'rails_error_reporter' }
+          ctx[:framework_context] = context || {}
+
+          env = context && (context[:env] || context['env'])
+          if env
+            req_info = ActiveRabbit::Reporting.rack_request_info(env)
+            ctx[:request] = req_info[:request]
+            ctx[:routing] = req_info[:routing]
+            # Top-level convenience for UI
+            ctx[:request_path] = ctx[:request][:path]
+            ctx[:request_method] = ctx[:request][:method]
+          end
+
+          if defined?(ActionController::RoutingError) && exception.is_a?(ActionController::RoutingError)
+            ctx[:controller_action] = 'Routing#not_found'
+            ctx[:error_type] = 'route_not_found'
+            ctx[:error_status] = 404
+            ctx[:error_component] = 'ActionDispatch'
+            ctx[:error_source] = 'Router'
+            ctx[:tags] = (ctx[:tags] || {}).merge(error_type: 'routing_error', severity: 'warning')
+          end
+
+          ctx
+        end
+      end
+
+      def self.attach!
+        # Rails 7.0+: Rails.error; earlier versions no-op
+        if defined?(Rails) && Rails.respond_to?(:error)
+          Rails.logger.info "[ActiveRabbit] Attaching to Rails error reporter" if defined?(Rails.logger)
+
+          subscriber = Subscriber.new
+          Rails.error.subscribe(subscriber)
+
+          Rails.logger.info "[ActiveRabbit] Rails error reporter attached successfully" if defined?(Rails.logger)
+        else
+          Rails.logger.info "[ActiveRabbit] Rails error reporter not available (Rails < 7.0)" if defined?(Rails.logger)
+        end
+      end
+    end
+  end
+end

data/lib/active_rabbit/client/event_processor.rb

@@ -102,6 +102,11 @@ module ActiveRabbit
           context[:request] = Thread.current[:active_rabbit_request_context]
         end
 
+        # Background job information (if available)
+        if defined?(Thread) && Thread.current[:active_rabbit_job_context]
+          context[:job] = Thread.current[:active_rabbit_job_context]
+        end
+
         context
       end
 

data/lib/active_rabbit/client/exception_tracker.rb

@@ -13,15 +13,16 @@ module ActiveRabbit
         @http_client = http_client
       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 exception
-        return if should_ignore_exception?(exception)
+        return if !force && should_ignore_exception?(exception)
 
         exception_data = build_exception_data(
           exception: exception,
           context: context,
           user_id: user_id,
-          tags: tags
+          tags: tags,
+          handled: handled
         )
 
         # Apply before_send callback if configured
@@ -30,7 +31,27 @@ module ActiveRabbit
           return unless exception_data # Callback can filter out exceptions by returning nil
         end
 
-        http_client.post_exception(exception_data)
+        # Send exception to API and return response
+        configuration.logger&.info("[ActiveRabbit] Preparing to send exception: #{exception.class.name}")
+        configuration.logger&.debug("[ActiveRabbit] Exception data: #{exception_data.inspect}")
+
+        # Ensure we have required fields
+        unless exception_data[:exception_class] && exception_data[:message] && exception_data[:backtrace]
+          configuration.logger&.error("[ActiveRabbit] Missing required fields in exception data")
+          configuration.logger&.debug("[ActiveRabbit] Available fields: #{exception_data.keys.inspect}")
+          return nil
+        end
+
+        response = http_client.post_exception(exception_data)
+
+        if response.nil?
+          configuration.logger&.error("[ActiveRabbit] Failed to send exception - both primary and fallback endpoints failed")
+          return nil
+        end
+
+        configuration.logger&.info("[ActiveRabbit] Exception successfully sent to API")
+        configuration.logger&.debug("[ActiveRabbit] API Response: #{response.inspect}")
+        response
       end
 
       def flush
@@ -39,33 +60,83 @@ module ActiveRabbit
 
       private
 
-      def build_exception_data(exception:, context:, user_id:, tags:)
-        backtrace = parse_backtrace(exception.backtrace || [])
+      def build_exception_data(exception:, context:, user_id:, tags:, handled: nil)
+        parsed_bt = parse_backtrace(exception.backtrace || [])
+        backtrace_lines = parsed_bt.map { |frame| frame[:line] }
+
+        # Fallback: synthesize a helpful frame for routing errors with no backtrace
+        if backtrace_lines.empty?
+          synthetic = nil
+          if context && (context[:routing]&.[](:path) || context[:request_path])
+            path = context[:routing]&.[](:path) || context[:request_path]
+            synthetic = "#{defined?(Rails) && Rails.respond_to?(:root) ? Rails.root : 'app'}/config/routes.rb:1:in `route_not_found' for #{path}"
+          elsif exception && exception.message && exception.message =~ /No route matches \[(\w+)\] \"(.+?)\"/
+            path = $2
+            synthetic = "#{defined?(Rails) && Rails.respond_to?(:root) ? Rails.root : 'app'}/config/routes.rb:1:in `route_not_found' for #{path}"
+          end
+          backtrace_lines = [synthetic] if synthetic
+        end
 
+        # Build data in the format the API expects
         data = {
-          type: exception.class.name,
+          # Required fields
+          exception_class: exception.class.name,
           message: exception.message,
-          backtrace: backtrace,
-          fingerprint: generate_fingerprint(exception),
-          timestamp: Time.now.iso8601(3),
-          environment: configuration.environment,
-          release: configuration.release,
+          backtrace: backtrace_lines,
+
+          # Timing and environment
+          occurred_at: Time.now.iso8601(3),
+          environment: configuration.environment || 'development',
+          release_version: configuration.release,
           server_name: configuration.server_name,
-          context: scrub_pii(context || {}),
-          tags: tags || {}
-        }
 
-        data[:user_id] = user_id if user_id
-        data[:project_id] = configuration.project_id if configuration.project_id
+          # Context from the error
+          controller_action: context[:controller_action],
+          request_path: context[:request_path],
+          request_method: context[:request_method],
 
-        # Add runtime context
-        data[:runtime_context] = build_runtime_context
+          # Additional context
+          context: scrub_pii(context || {}),
+          tags: tags || {},
+          user_id: user_id,
+          project_id: configuration.project_id,
+
+          # Runtime info
+          runtime_context: build_runtime_context,
+
+          # Error details (for better UI display)
+          error_type: context[:error_type] || exception.class.name,
+          error_message: context[:error_message] || exception.message,
+          error_location: context[:error_location] || backtrace_lines.first,
+          error_severity: context[:error_severity] || :error,
+          error_status: context[:error_status] || 500,
+          error_source: context[:error_source] || 'Application',
+          error_component: context[:error_component] || 'Unknown',
+          error_action: context[:error_action],
+          handled: context.key?(:handled) ? context[:handled] : handled,
+
+          # Request details
+          request_details: context[:request_details],
+          response_time: context[:response_time],
+          routing_info: context[:routing_info]
+        }
 
         # Add request context if available
         if defined?(Thread) && Thread.current[:active_rabbit_request_context]
           data[:request_context] = Thread.current[:active_rabbit_request_context]
         end
 
+        # Add background job context if available
+        if defined?(Thread) && Thread.current[:active_rabbit_job_context]
+          data[:job_context] = Thread.current[:active_rabbit_job_context]
+        end
+
+        # Log what we're sending
+        configuration.logger&.debug("[ActiveRabbit] Built exception data:")
+        configuration.logger&.debug("[ActiveRabbit] - Required fields: class=#{data[:exception_class]}, message=#{data[:message]}, backtrace=#{data[:backtrace]&.first}")
+        configuration.logger&.debug("[ActiveRabbit] - Error details: type=#{data[:error_type]}, source=#{data[:error_source]}, component=#{data[:error_component]}")
+        configuration.logger&.debug("[ActiveRabbit] - Request info: path=#{data[:request_path]}, method=#{data[:request_method]}, action=#{data[:controller_action]}")
+
         data
       end