activerabbit-ai 0.4.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec5ef4721bc8a2096c534eb4f04e54d0520daa42dc95341feefa5bca17ba88e7
-  data.tar.gz: bd3b5b9eb8879ecc3eb682126262e036a46dc3352be1f5b0ba71e7d234402868
+  metadata.gz: 48326a10836bf940aea7ebf3b6eca91f60086eb69e51e5e94266db5012d47ad9
+  data.tar.gz: 9244e314ba69d85fd9652604014520f8cbc6a4ab2c6da046b28a7f9c540a402e
 SHA512:
-  metadata.gz: 6421b105cc63156671b119f8ce06fa94a5ce4fa5525f3f8eba96ac351b6da59f6cda1edb00acb03d607e9d7e9ca5074fb288cf6b3f8874468e67ad6ed5684d78
-  data.tar.gz: 8543aa8f59de9a40a35936927fcb6010e62a45221ebc071ad513ebd7a6c3d2c42243d57a18f5e520d20d6045fefce14d1db78f567e68941cec9690267724e480
+  metadata.gz: 866f2f2f296c7a254526691e02e6c182aade30274985de6ca69f8e715b9af4036b489437eb2742840bf9fe1a582a0eaafae3ad0605342da4acde3dc6ee4d752a
+  data.tar.gz: f59a2b3dcfd170f048f96751f870cc238333fc576fbf200668ef040db9a88b97de8b1a0f60cf8c6490c3ee3f8c4ee1941318571d39d644921e0f04e2a2ae29c8

data/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 All notable changes to this project will be documented in this file.
 
+## [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
+- Added explicit `require "logger"` to prevent Rails initialization issues
+- Made Rails.logger access safer with fallback to STDOUT logger
+- Changed initializer to run after `:initialize_logger` to ensure proper load order
+- Fixed potential NameError with ActiveSupport::LoggerThreadSafeLevel::Logger
+
 ## [0.4.0] - 2025-01-04
 
 ### Added

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,12 @@ 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
 
       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 +45,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
         ]
@@ -83,6 +84,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,78 @@
+# 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)
+
+            # Initialize de-dup set
+            $reported_errors ||= Set.new
+
+            # Generate a unique key for this error
+            error_key = "#{exception.class.name}:#{exception.message}:#{exception.backtrace&.first}"
+
+            # Only report if we haven't seen this error before and not deduped in short window
+            unless $reported_errors.include?(error_key)
+              $reported_errors.add(error_key)
+
+              dedupe_context = { request_id: (context && (context[:request_id] || context[:request]&.[](:request_id))) }
+              unless ActiveRabbit::Client::Dedupe.seen_recently?(exception, dedupe_context)
+                enriched = build_enriched_context(exception, handled: handled, severity: severity, context: context)
+                ActiveRabbit::Client.track_exception(exception, handled: handled, context: enriched)
+              end
+            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