activerabbit-ai 0.1.0

data/lib/active_rabbit/client/pii_scrubber.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module ActiveRabbit
+  module Client
+    class PiiScrubber
+      SCRUBBED_VALUE = "[FILTERED]"
+
+      attr_reader :configuration
+
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      def scrub(data)
+        case data
+        when Hash
+          scrub_hash(data)
+        when Array
+          scrub_array(data)
+        when String
+          scrub_string(data)
+        else
+          data
+        end
+      end
+
+      private
+
+      def scrub_hash(hash)
+        return hash unless hash.is_a?(Hash)
+
+        hash.each_with_object({}) do |(key, value), scrubbed|
+          if should_scrub_key?(key)
+            scrubbed[key] = SCRUBBED_VALUE
+          else
+            scrubbed[key] = scrub(value)
+          end
+        end
+      end
+
+      def scrub_array(array)
+        return array unless array.is_a?(Array)
+
+        array.map { |item| scrub(item) }
+      end
+
+      def scrub_string(string)
+        return string unless string.is_a?(String)
+
+        scrubbed = string.dup
+
+        # Scrub common PII patterns
+        scrubbed = scrub_email_addresses(scrubbed)
+        scrubbed = scrub_phone_numbers(scrubbed)
+        scrubbed = scrub_credit_cards(scrubbed)
+        scrubbed = scrub_social_security_numbers(scrubbed)
+        scrubbed = scrub_ip_addresses(scrubbed)
+
+        scrubbed
+      end
+
+      def should_scrub_key?(key)
+        return false unless key
+
+        key_str = key.to_s.downcase
+
+        configuration.pii_fields.any? do |pii_field|
+          case pii_field
+          when String
+            key_str.include?(pii_field.downcase)
+          when Regexp
+            key_str =~ pii_field
+          else
+            false
+          end
+        end
+      end
+
+      def scrub_email_addresses(string)
+        # Match email addresses
+        string.gsub(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/, SCRUBBED_VALUE)
+      end
+
+      def scrub_phone_numbers(string)
+        # Match various phone number formats
+        patterns = [
+          /\(\d{3}\)\s?\d{3}[-.]?\d{4}/, # (123) 456-7890, (123)456-7890
+          /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/, # 123-456-7890, 123.456.7890, 1234567890
+          /\b\+1[-.\s]?\d{3}[-.\s]?\d{3}[-.\s]?\d{4}\b/, # +1-123-456-7890
+          /\b\d{3}\s\d{3}\s\d{4}\b/ # 123 456 7890
+        ]
+
+        patterns.reduce(string) do |str, pattern|
+          str.gsub(pattern, SCRUBBED_VALUE)
+        end
+      end
+
+      def scrub_credit_cards(string)
+        # Match credit card patterns - be more permissive for testing
+        patterns = [
+          /\b\d{4}[-\s]\d{4}[-\s]\d{4}[-\s]\d{4}\b/, # 1234-5678-9012-3456
+          /\b\d{13,19}\b/ # 13-19 consecutive digits
+        ]
+
+        patterns.reduce(string) do |str, pattern|
+          str.gsub(pattern) do |match|
+            digits = match.gsub(/\D/, '')
+            # Only scrub if it looks like a credit card (passes basic Luhn check)
+            if digits.length >= 13 && digits.length <= 19 && luhn_valid?(digits)
+              SCRUBBED_VALUE
+            else
+              match
+            end
+          end
+        end
+      end
+
+      def scrub_social_security_numbers(string)
+        # Match SSN patterns
+        patterns = [
+          /\b\d{3}[-.\s]?\d{2}[-.\s]?\d{4}\b/, # 123-45-6789, 123.45.6789, 123 45 6789
+          /\b\d{9}\b/ # 123456789 (9 consecutive digits)
+        ]
+
+        patterns.reduce(string) do |str, pattern|
+          str.gsub(pattern) do |match|
+            # Only scrub 9-digit sequences that look like SSNs
+            digits = match.gsub(/\D/, '')
+            if digits.length == 9 && !digits.match(/^0{9}$|^1{9}$|^2{9}$|^3{9}$|^4{9}$|^5{9}$|^6{9}$|^7{9}$|^8{9}$|^9{9}$/)
+              SCRUBBED_VALUE
+            else
+              match
+            end
+          end
+        end
+      end
+
+      def scrub_ip_addresses(string)
+        # Match IPv4 addresses
+        string.gsub(/\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b/) do |match|
+          # Only scrub if it's a valid IP address
+          octets = match.split('.')
+          if octets.all? { |octet| octet.to_i <= 255 }
+            # Keep first octet for debugging purposes
+            "#{octets.first}.xxx.xxx.xxx"
+          else
+            match
+          end
+        end
+      end
+
+      def luhn_valid?(number)
+        # Basic Luhn algorithm check for credit card validation
+        digits = number.reverse.chars.map(&:to_i)
+
+        sum = digits.each_with_index.sum do |digit, index|
+          if index.odd?
+            doubled = digit * 2
+            doubled > 9 ? doubled - 9 : doubled
+          else
+            digit
+          end
+        end
+
+        sum % 10 == 0
+      end
+    end
+  end
+end

data/lib/active_rabbit/client/railtie.rb

@@ -0,0 +1,328 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+require "securerandom"
+
+module ActiveRabbit
+  module Client
+    class Railtie < Rails::Railtie
+      config.active_rabbit = ActiveSupport::OrderedOptions.new
+
+      initializer "active_rabbit.configure" do |app|
+        # Configure ActiveRabbit from Rails configuration
+        ActiveRabbit::Client.configure do |config|
+          config.environment = Rails.env
+          config.logger = Rails.logger
+          config.release = detect_release(app)
+        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?
+
+        # Subscribe to Action Controller events
+        subscribe_to_controller_events
+
+        # Subscribe to Active Record events
+        subscribe_to_active_record_events
+
+        # Subscribe to Action View events
+        subscribe_to_action_view_events
+
+        # Subscribe to Action Mailer events (if available)
+        subscribe_to_action_mailer_events if defined?(ActionMailer)
+
+        # Subscribe to exception notifications
+        subscribe_to_exception_notifications
+      end
+
+      initializer "active_rabbit.add_middleware" do |app|
+        next unless ActiveRabbit::Client.configured?
+
+        # Add request context middleware
+        app.middleware.insert_before ActionDispatch::ShowExceptions, RequestContextMiddleware
+
+        # Add exception catching middleware
+        app.middleware.insert_before ActionDispatch::ShowExceptions, ExceptionMiddleware
+      end
+
+      private
+
+      def setup_exception_tracking(app)
+        # Handle uncaught exceptions in development
+        if Rails.env.development? || Rails.env.test?
+          app.config.consider_all_requests_local = false if Rails.env.test?
+        end
+      end
+
+      def subscribe_to_controller_events
+        ActiveSupport::Notifications.subscribe "process_action.action_controller" do |name, started, finished, unique_id, payload|
+          begin
+            duration_ms = ((finished - started) * 1000).round(2)
+
+            ActiveRabbit::Client.track_performance(
+              "controller.action",
+              duration_ms,
+              metadata: {
+                controller: payload[:controller],
+                action: payload[:action],
+                format: payload[:format],
+                method: payload[:method],
+                path: payload[:path],
+                status: payload[:status],
+                view_runtime: payload[:view_runtime],
+                db_runtime: payload[:db_runtime]
+              }
+            )
+
+            # Track slow requests
+            if duration_ms > 1000 # Slower than 1 second
+              ActiveRabbit::Client.track_event(
+                "slow_request",
+                {
+                  controller: payload[:controller],
+                  action: payload[:action],
+                  duration_ms: duration_ms,
+                  method: payload[:method],
+                  path: payload[:path]
+                }
+              )
+            end
+          rescue => e
+            Rails.logger.error "[ActiveRabbit] Error tracking controller action: #{e.message}"
+          end
+        end
+      end
+
+      def subscribe_to_active_record_events
+        # Track database queries for N+1 detection
+        ActiveSupport::Notifications.subscribe "sql.active_record" do |name, started, finished, unique_id, payload|
+          begin
+            next if payload[:name] == "SCHEMA" || payload[:name] == "CACHE"
+
+            duration_ms = ((finished - started) * 1000).round(2)
+
+            # Track query for N+1 detection
+            if ActiveRabbit::Client.configuration.enable_n_plus_one_detection
+              n_plus_one_detector.track_query(
+                payload[:sql],
+                payload[:bindings],
+                payload[:name],
+                duration_ms
+              )
+            end
+
+            # Track slow queries
+            if duration_ms > 100 # Slower than 100ms
+              ActiveRabbit::Client.track_event(
+                "slow_query",
+                {
+                  sql: payload[:sql],
+                  duration_ms: duration_ms,
+                  name: payload[:name]
+                }
+              )
+            end
+          rescue => e
+            Rails.logger.error "[ActiveRabbit] Error tracking SQL query: #{e.message}"
+          end
+        end
+      end
+
+      def subscribe_to_action_view_events
+        ActiveSupport::Notifications.subscribe "render_template.action_view" do |name, started, finished, unique_id, payload|
+          begin
+            duration_ms = ((finished - started) * 1000).round(2)
+
+            # Track slow template renders
+            if duration_ms > 50 # Slower than 50ms
+              ActiveRabbit::Client.track_event(
+                "slow_template_render",
+                {
+                  template: payload[:identifier],
+                  duration_ms: duration_ms,
+                  layout: payload[:layout]
+                }
+              )
+            end
+          rescue => e
+            Rails.logger.error "[ActiveRabbit] Error tracking template render: #{e.message}"
+          end
+        end
+      end
+
+      def subscribe_to_action_mailer_events
+        ActiveSupport::Notifications.subscribe "deliver.action_mailer" do |name, started, finished, unique_id, payload|
+          begin
+            duration_ms = ((finished - started) * 1000).round(2)
+
+            ActiveRabbit::Client.track_event(
+              "email_sent",
+              {
+                mailer: payload[:mailer],
+                action: payload[:action],
+                duration_ms: duration_ms
+              }
+            )
+          rescue => e
+            Rails.logger.error "[ActiveRabbit] Error tracking email delivery: #{e.message}"
+          end
+        end
+      end
+
+            def subscribe_to_exception_notifications
+        # Subscribe to Rails exception notifications
+        ActiveSupport::Notifications.subscribe "process_action.action_controller" do |name, started, finished, unique_id, data|
+          next unless ActiveRabbit::Client.configured?
+          next unless data[:exception]
+
+          exception_class, exception_message = data[:exception]
+
+          puts "[ActiveRabbit] Exception notification received: #{exception_class}: #{exception_message}"
+          puts "[ActiveRabbit] Available data keys: #{data.keys.inspect}"
+
+          # Create exception with proper backtrace
+          exception = exception_class.constantize.new(exception_message)
+
+          # Try to get backtrace from the original exception if available
+          if data[:exception_object]
+            exception.set_backtrace(data[:exception_object].backtrace)
+          end
+
+          ActiveRabbit::Client.track_exception(
+            exception,
+            context: {
+              request: {
+                method: data[:method],
+                path: data[:path],
+                controller: data[:controller],
+                action: data[:action],
+                status: data[:status],
+                format: data[:format]
+              }
+            }
+          )
+        end
+      end
+
+      def detect_release(app)
+        # Try to detect release from various sources
+        ENV["HEROKU_SLUG_COMMIT"] ||
+          ENV["GITHUB_SHA"] ||
+          ENV["GITLAB_COMMIT_SHA"] ||
+          app.config.active_rabbit.release ||
+          detect_git_sha
+      end
+
+      def detect_git_sha
+        return unless Rails.root.join(".git").directory?
+
+        `git rev-parse HEAD 2>/dev/null`.chomp
+      rescue
+        nil
+      end
+
+      def n_plus_one_detector
+        @n_plus_one_detector ||= NPlusOneDetector.new(ActiveRabbit::Client.configuration)
+      end
+    end
+
+    # Middleware for adding request context
+    class RequestContextMiddleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        request = ActionDispatch::Request.new(env)
+
+        # Skip certain requests
+        return @app.call(env) if should_skip_request?(request)
+
+        # Set request context
+        request_context = build_request_context(request)
+        Thread.current[:active_rabbit_request_context] = request_context
+
+        # Start N+1 detection for this request
+        request_id = SecureRandom.uuid
+        n_plus_one_detector.start_request(request_id)
+
+        begin
+          @app.call(env)
+        ensure
+          # Clean up request context
+          Thread.current[:active_rabbit_request_context] = nil
+          n_plus_one_detector.finish_request(request_id)
+        end
+      end
+
+      private
+
+      def should_skip_request?(request)
+        # Skip requests from ignored user agents
+        user_agent = request.headers["User-Agent"]
+        return true if ActiveRabbit::Client.configuration.should_ignore_user_agent?(user_agent)
+
+        # Skip asset requests
+        return true if request.path.start_with?("/assets/")
+
+        # Skip health checks
+        return true if request.path.match?(/\/(health|ping|status)/)
+
+        false
+      end
+
+      def build_request_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,
+          request_id: request.headers["X-Request-ID"] || SecureRandom.uuid
+        }
+      end
+
+      def n_plus_one_detector
+        @n_plus_one_detector ||= NPlusOneDetector.new(ActiveRabbit::Client.configuration)
+      end
+    end
+
+    # Middleware for catching unhandled exceptions
+    class ExceptionMiddleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        puts "[ActiveRabbit] ExceptionMiddleware called for: #{env['REQUEST_METHOD']} #{env['PATH_INFO']}"
+        @app.call(env)
+      rescue Exception => exception
+        # Track the exception
+        puts "[ActiveRabbit] ExceptionMiddleware caught: #{exception.class}: #{exception.message}"
+        request = ActionDispatch::Request.new(env)
+
+        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
+            }
+          }
+        )
+
+        # Re-raise the exception so Rails can handle it normally
+        raise exception
+      end
+    end
+  end
+end

data/lib/active_rabbit/client/sidekiq_middleware.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module ActiveRabbit
+  module Client
+    class SidekiqMiddleware
+      def call(worker, job, queue)
+        start_time = Time.now
+        job_context = build_job_context(worker, job, queue)
+
+        # Set job context for the duration of the job
+        Thread.current[:active_rabbit_job_context] = job_context
+
+        begin
+          result = yield
+
+          # Track successful job completion
+          duration_ms = ((Time.now - start_time) * 1000).round(2)
+          track_job_performance(worker, job, queue, duration_ms, "completed")
+
+          result
+        rescue Exception => exception
+          # Track job failure
+          duration_ms = ((Time.now - start_time) * 1000).round(2)
+          track_job_performance(worker, job, queue, duration_ms, "failed")
+          track_job_exception(exception, worker, job, queue)
+
+          # Re-raise the exception so Sidekiq can handle it
+          raise exception
+        ensure
+          # Clean up job context
+          Thread.current[:active_rabbit_job_context] = nil
+        end
+      end
+
+      private
+
+      def build_job_context(worker, job, queue)
+        {
+          worker_class: worker.class.name,
+          job_id: job["jid"],
+          queue: queue,
+          args: scrub_job_args(job["args"]),
+          retry_count: job["retry_count"] || 0,
+          enqueued_at: job["enqueued_at"] ? Time.at(job["enqueued_at"]) : nil,
+          created_at: job["created_at"] ? Time.at(job["created_at"]) : nil
+        }
+      end
+
+      def track_job_performance(worker, job, queue, duration_ms, status)
+        return unless ActiveRabbit::Client.configured?
+
+        ActiveRabbit::Client.track_performance(
+          "sidekiq.job",
+          duration_ms,
+          metadata: {
+            worker_class: worker.class.name,
+            queue: queue,
+            status: status,
+            job_id: job["jid"],
+            retry_count: job["retry_count"] || 0,
+            args_count: job["args"]&.size || 0
+          }
+        )
+
+        # Track slow jobs
+        if duration_ms > 30_000 # Slower than 30 seconds
+          ActiveRabbit::Client.track_event(
+            "slow_sidekiq_job",
+            {
+              worker_class: worker.class.name,
+              queue: queue,
+              duration_ms: duration_ms,
+              job_id: job["jid"]
+            }
+          )
+        end
+
+        # Track job completion event
+        ActiveRabbit::Client.track_event(
+          "sidekiq_job_#{status}",
+          {
+            worker_class: worker.class.name,
+            queue: queue,
+            duration_ms: duration_ms,
+            retry_count: job["retry_count"] || 0
+          }
+        )
+      end
+
+      def track_job_exception(exception, worker, job, queue)
+        return unless ActiveRabbit::Client.configured?
+
+        ActiveRabbit::Client.track_exception(
+          exception,
+          context: {
+            job: {
+              worker_class: worker.class.name,
+              queue: queue,
+              job_id: job["jid"],
+              args: scrub_job_args(job["args"]),
+              retry_count: job["retry_count"] || 0,
+              enqueued_at: job["enqueued_at"] ? Time.at(job["enqueued_at"]) : nil
+            }
+          },
+          tags: {
+            component: "sidekiq",
+            queue: queue,
+            worker: worker.class.name
+          }
+        )
+      end
+
+      def scrub_job_args(args)
+        return args unless ActiveRabbit::Client.configuration.enable_pii_scrubbing
+        return args unless args.is_a?(Array)
+
+        PiiScrubber.new(ActiveRabbit::Client.configuration).scrub(args)
+      end
+    end
+
+    # Auto-register the middleware if Sidekiq is available
+    if defined?(Sidekiq)
+      Sidekiq.configure_server do |config|
+        config.server_middleware do |chain|
+          chain.add ActiveRabbit::Client::SidekiqMiddleware
+        end
+      end
+    end
+  end
+end

data/lib/active_rabbit/client/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveRabbit
+  module Client
+    VERSION = "0.1.0"
+  end
+end