activerabbit-ai 0.1.0

data/lib/active_rabbit/client/exception_tracker.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module ActiveRabbit
+  module Client
+    class ExceptionTracker
+      attr_reader :configuration, :http_client
+
+      def initialize(configuration, http_client)
+        @configuration = configuration
+        @http_client = http_client
+      end
+
+      def track_exception(exception:, context: {}, user_id: nil, tags: {})
+        return unless exception
+        return if should_ignore_exception?(exception)
+
+        exception_data = build_exception_data(
+          exception: exception,
+          context: context,
+          user_id: user_id,
+          tags: tags
+        )
+
+        # Apply before_send callback if configured
+        if configuration.before_send_exception
+          exception_data = configuration.before_send_exception.call(exception_data)
+          return unless exception_data # Callback can filter out exceptions by returning nil
+        end
+
+        http_client.post_exception(exception_data)
+      end
+
+      def flush
+        # Exception tracker sends immediately, no batching needed
+      end
+
+      private
+
+      def build_exception_data(exception:, context:, user_id:, tags:)
+        backtrace = parse_backtrace(exception.backtrace || [])
+
+        data = {
+          type: exception.class.name,
+          message: exception.message,
+          backtrace: backtrace,
+          fingerprint: generate_fingerprint(exception),
+          timestamp: Time.now.iso8601(3),
+          environment: configuration.environment,
+          release: 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
+
+        # Add runtime context
+        data[:runtime_context] = build_runtime_context
+
+        # Add request context if available
+        if defined?(Thread) && Thread.current[:active_rabbit_request_context]
+          data[:request_context] = Thread.current[:active_rabbit_request_context]
+        end
+
+        data
+      end
+
+      def parse_backtrace(backtrace)
+        backtrace.map do |line|
+          if match = line.match(/^(.+?):(\d+)(?::in `(.+?)')?$/)
+            {
+              filename: match[1],
+              lineno: match[2].to_i,
+              method: match[3],
+              line: line
+            }
+          else
+            { line: line }
+          end
+        end
+      end
+
+      def generate_fingerprint(exception)
+        # Create a consistent fingerprint for grouping similar exceptions
+        parts = [
+          exception.class.name,
+          clean_message_for_fingerprint(exception.message),
+          extract_relevant_backtrace_for_fingerprint(exception.backtrace)
+        ].compact
+
+        Digest::SHA256.hexdigest(parts.join("|"))
+      end
+
+      def clean_message_for_fingerprint(message)
+        return "" unless message
+
+        # Remove dynamic content that would prevent proper grouping
+        message
+          .gsub(/\d+/, "N") # Replace numbers with N
+          .gsub(/0x[a-f0-9]+/i, "0xHEX") # Replace hex addresses
+          .gsub(/'[^']+'/, "'STRING'") # Replace quoted strings
+          .gsub(/"[^"]+"/, '"STRING"') # Replace double-quoted strings
+          .gsub(/\/[^\/\s]+\/[^\/\s]*/, "/PATH/") # Replace file paths
+      end
+
+      def extract_relevant_backtrace_for_fingerprint(backtrace)
+        return "" unless backtrace
+
+        # Take the first few frames from the application (not gems/stdlib)
+        app_frames = backtrace
+          .select { |line| line.include?(Dir.pwd) } # Only app files
+          .first(3) # First 3 frames
+          .map { |line| line.gsub(/:\d+/, ":LINE") } # Remove line numbers
+
+        app_frames.join("|")
+      end
+
+      def build_runtime_context
+        context = {
+          ruby_version: RUBY_VERSION,
+          ruby_platform: RUBY_PLATFORM,
+          gem_version: VERSION
+        }
+
+        # Add framework information
+        if defined?(Rails)
+          context[:rails_version] = Rails.version
+          context[:rails_env] = Rails.env if Rails.respond_to?(:env)
+        end
+
+        # Add memory usage if available
+        begin
+          if defined?(GC)
+            context[:gc_stats] = GC.stat
+          end
+        rescue
+          # Ignore if GC.stat is not available
+        end
+
+        context
+      end
+
+      def should_ignore_exception?(exception)
+        configuration.should_ignore_exception?(exception)
+      end
+
+      def scrub_pii(data)
+        return data unless configuration.enable_pii_scrubbing
+
+        PiiScrubber.new(configuration).scrub(data)
+      end
+    end
+  end
+end

data/lib/active_rabbit/client/http_client.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/retry"
+require "json"
+require "concurrent"
+
+module ActiveRabbit
+  module Client
+    class HttpClient
+      attr_reader :configuration
+
+      def initialize(configuration)
+        @configuration = configuration
+        @connection = build_connection
+        @request_queue = Concurrent::Array.new
+        @batch_timer = nil
+        @shutdown = false
+      end
+
+      def post_event(event_data)
+        enqueue_request(:post, "api/v1/events", event_data)
+      end
+
+      def post_exception(exception_data)
+        # Add event_type for batch processing
+        exception_data_with_type = exception_data.merge(event_type: 'error')
+        enqueue_request(:post, "api/v1/events/errors", exception_data_with_type)
+      end
+
+      def post_performance(performance_data)
+        # Add event_type for batch processing
+        performance_data_with_type = performance_data.merge(event_type: 'performance')
+        enqueue_request(:post, "api/v1/events/performance", performance_data_with_type)
+      end
+
+      def post_batch(batch_data)
+        make_request(:post, "api/v1/events/batch", { events: batch_data })
+      end
+
+      def flush
+        return if @request_queue.empty?
+
+        batch = @request_queue.shift(@request_queue.length)
+        return if batch.empty?
+
+        begin
+          post_batch(batch)
+        rescue => e
+          configuration.logger&.error("[ActiveRabbit] Failed to send batch: #{e.message}")
+          raise APIError, "Failed to send batch: #{e.message}"
+        end
+      end
+
+      def shutdown
+        @shutdown = true
+        @batch_timer&.shutdown
+        flush
+      end
+
+      private
+
+      def build_connection
+        Faraday.new(url: configuration.api_url) do |conn|
+          conn.request :json
+          conn.request :retry,
+            max: configuration.retry_count,
+            interval: configuration.retry_delay,
+            backoff_factor: 2,
+            retry_statuses: [429, 500, 502, 503, 504]
+
+          conn.response :json
+          conn.response :raise_error
+
+          conn.options.timeout = configuration.timeout
+          conn.options.open_timeout = configuration.open_timeout
+
+          conn.headers["User-Agent"] = "ActiveRabbit-Ruby/#{VERSION}"
+          conn.headers["X-Project-Token"] = configuration.api_key
+          conn.headers["Content-Type"] = "application/json"
+
+          if configuration.project_id
+            conn.headers["X-Project-ID"] = configuration.project_id
+          end
+        end
+      end
+
+      def enqueue_request(method, path, data)
+        return if @shutdown
+
+        @request_queue << {
+          method: method,
+          path: path,
+          data: data,
+          timestamp: Time.now.to_f
+        }
+
+        # Start batch timer if not already running
+        start_batch_timer if @batch_timer.nil? || @batch_timer.shutdown?
+
+        # Flush if queue is full
+        flush if @request_queue.length >= configuration.queue_size
+      end
+
+      def start_batch_timer
+        @batch_timer = Concurrent::TimerTask.new(
+          execution_interval: configuration.flush_interval,
+          timeout_interval: configuration.flush_interval + 5
+        ) do
+          flush unless @request_queue.empty?
+        end
+
+        @batch_timer.execute
+      end
+
+      def make_request(method, path, data)
+        response = @connection.public_send(method, path, data)
+
+        case response.status
+        when 200..299
+          response.body
+        when 429
+          raise RateLimitError, "Rate limit exceeded"
+        else
+          raise APIError, "API request failed with status #{response.status}: #{response.body}"
+        end
+      rescue Faraday::TimeoutError => e
+        raise APIError, "Request timeout: #{e.message}"
+      rescue Faraday::ConnectionFailed => e
+        raise APIError, "Connection failed: #{e.message}"
+      rescue Faraday::Error => e
+        raise APIError, "Request failed: #{e.message}"
+      end
+    end
+  end
+end
+

data/lib/active_rabbit/client/n_plus_one_detector.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module ActiveRabbit
+  module Client
+    class NPlusOneDetector
+      attr_reader :configuration
+
+      def initialize(configuration)
+        @configuration = configuration
+        @query_patterns = Concurrent::Hash.new { |h, k| h[k] = [] }
+        @request_queries = Concurrent::Hash.new { |h, k| h[k] = [] }
+      end
+
+      def track_query(sql, bindings = nil, name = nil, duration = nil)
+        return unless configuration.enable_n_plus_one_detection
+        return unless current_request_id
+
+        query_info = {
+          sql: normalize_sql(sql),
+          bindings: bindings,
+          name: name,
+          duration: duration,
+          timestamp: Time.now,
+          backtrace: caller(2, 10) # Skip this method and the AR method
+        }
+
+        @request_queries[current_request_id] << query_info
+      end
+
+      def analyze_request_queries(request_id = nil)
+        request_id ||= current_request_id
+        return unless request_id
+
+        queries = @request_queries.delete(request_id) || []
+        return if queries.empty?
+
+        n_plus_one_issues = detect_n_plus_one_patterns(queries)
+
+        n_plus_one_issues.each do |issue|
+          report_n_plus_one_issue(issue)
+        end
+      end
+
+      def start_request(request_id = nil)
+        request_id ||= SecureRandom.uuid
+        Thread.current[:active_rabbit_request_id] = request_id
+        @request_queries[request_id] = []
+        request_id
+      end
+
+      def finish_request(request_id = nil)
+        request_id ||= current_request_id
+        return unless request_id
+
+        analyze_request_queries(request_id)
+        Thread.current[:active_rabbit_request_id] = nil
+      end
+
+      private
+
+      def current_request_id
+        Thread.current[:active_rabbit_request_id]
+      end
+
+      def normalize_sql(sql)
+        return sql unless sql.is_a?(String)
+
+        # Remove specific values to group similar queries
+        normalized = sql.dup
+
+        # Replace string literals
+        normalized.gsub!(/'[^']*'/, '?')
+        normalized.gsub!(/"[^"]*"/, '?')
+
+        # Replace numbers
+        normalized.gsub(/\b\d+\b/, '?')
+
+        # Replace IN clauses with multiple values
+        normalized.gsub(/IN\s*\([^)]*\)/i, 'IN (?)')
+
+        # Normalize whitespace
+        normalized.gsub(/\s+/, ' ').strip
+      end
+
+      def detect_n_plus_one_patterns(queries)
+        issues = []
+
+        # Group queries by normalized SQL
+        grouped_queries = queries.group_by { |q| q[:sql] }
+
+        grouped_queries.each do |normalized_sql, query_group|
+          next if query_group.size < 3 # Need at least 3 similar queries to consider N+1
+
+          # Check if queries are executed in quick succession
+          if queries_in_quick_succession?(query_group)
+            issues << build_n_plus_one_issue(normalized_sql, query_group)
+          end
+        end
+
+        issues
+      end
+
+      def queries_in_quick_succession?(query_group)
+        return false if query_group.size < 2
+
+        # Check if queries are within a short time window (1 second)
+        first_query_time = query_group.first[:timestamp]
+        last_query_time = query_group.last[:timestamp]
+
+        (last_query_time - first_query_time) < 1.0
+      end
+
+      def build_n_plus_one_issue(normalized_sql, query_group)
+        # Find the most common backtrace pattern
+        backtrace_patterns = query_group.map { |q| extract_app_backtrace(q[:backtrace]) }
+        common_backtrace = find_most_common_backtrace(backtrace_patterns)
+
+        total_duration = query_group.sum { |q| q[:duration] || 0 }
+
+        {
+          type: "n_plus_one_query",
+          normalized_sql: normalized_sql,
+          query_count: query_group.size,
+          total_duration_ms: total_duration,
+          average_duration_ms: total_duration / query_group.size,
+          backtrace: common_backtrace,
+          first_query_time: query_group.first[:timestamp],
+          last_query_time: query_group.last[:timestamp],
+          sample_bindings: query_group.first(3).map { |q| q[:bindings] }.compact
+        }
+      end
+
+      def extract_app_backtrace(backtrace)
+        return [] unless backtrace
+
+        # Only include application code, not gems or stdlib
+        app_root = defined?(Rails) ? Rails.root.to_s : Dir.pwd
+
+        backtrace.select do |line|
+          line.start_with?(app_root) && !line.include?('/vendor/') && !line.include?('/gems/')
+        end.first(5) # Limit to first 5 app frames
+      end
+
+      def find_most_common_backtrace(backtrace_patterns)
+        return [] if backtrace_patterns.empty?
+
+        # Find the backtrace pattern that appears most frequently
+        backtrace_counts = backtrace_patterns.each_with_object(Hash.new(0)) do |backtrace, counts|
+          key = backtrace.join("|")
+          counts[key] += 1
+        end
+
+        most_common_key = backtrace_counts.max_by { |_, count| count }&.first
+        return [] unless most_common_key
+
+        most_common_key.split("|")
+      end
+
+      def report_n_plus_one_issue(issue)
+        # Create a structured exception for the N+1 issue
+        exception_data = {
+          type: "NPlusOneQueryIssue",
+          message: "N+1 query detected: #{issue[:query_count]} similar queries executed",
+          details: issue,
+          timestamp: Time.now.iso8601(3),
+          environment: configuration.environment,
+          release: configuration.release,
+          server_name: configuration.server_name
+        }
+
+        exception_data[:project_id] = configuration.project_id if configuration.project_id
+
+        # Send as a performance issue rather than an exception
+        Client.track_event(
+          "n_plus_one_detected",
+          {
+            normalized_sql: issue[:normalized_sql],
+            query_count: issue[:query_count],
+            total_duration_ms: issue[:total_duration_ms],
+            average_duration_ms: issue[:average_duration_ms]
+          }
+        )
+      end
+    end
+  end
+end

data/lib/active_rabbit/client/performance_monitor.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module ActiveRabbit
+  module Client
+    class PerformanceMonitor
+      attr_reader :configuration, :http_client
+
+      def initialize(configuration, http_client)
+        @configuration = configuration
+        @http_client = http_client
+        @active_transactions = Concurrent::Hash.new
+      end
+
+      def track_performance(name:, duration_ms:, metadata: {})
+        return unless configuration.enable_performance_monitoring
+
+        performance_data = build_performance_data(
+          name: name,
+          duration_ms: duration_ms,
+          metadata: metadata
+        )
+
+        http_client.post_performance(performance_data)
+      end
+
+      def start_transaction(name, metadata: {})
+        return unless configuration.enable_performance_monitoring
+
+        transaction_id = SecureRandom.uuid
+        @active_transactions[transaction_id] = {
+          name: name,
+          start_time: Time.now,
+          metadata: metadata
+        }
+
+        transaction_id
+      end
+
+      def finish_transaction(transaction_id, additional_metadata: {})
+        return unless configuration.enable_performance_monitoring
+        return unless @active_transactions.key?(transaction_id)
+
+        transaction = @active_transactions.delete(transaction_id)
+        duration_ms = ((Time.now - transaction[:start_time]) * 1000).round(2)
+
+        track_performance(
+          name: transaction[:name],
+          duration_ms: duration_ms,
+          metadata: transaction[:metadata].merge(additional_metadata)
+        )
+      end
+
+      def measure(name, metadata: {})
+        return yield unless configuration.enable_performance_monitoring
+
+        start_time = Time.now
+        result = yield
+        end_time = Time.now
+
+        duration_ms = ((end_time - start_time) * 1000).round(2)
+
+        track_performance(
+          name: name,
+          duration_ms: duration_ms,
+          metadata: metadata
+        )
+
+        result
+      end
+
+      def flush
+        # Performance monitor sends immediately, no batching needed
+      end
+
+      private
+
+      def build_performance_data(name:, duration_ms:, metadata:)
+        data = {
+          name: name.to_s,
+          duration_ms: duration_ms.to_f,
+          metadata: scrub_pii(metadata || {}),
+          timestamp: Time.now.iso8601(3),
+          environment: configuration.environment,
+          release: configuration.release,
+          server_name: configuration.server_name
+        }
+
+        data[:project_id] = configuration.project_id if configuration.project_id
+
+        # Add performance context
+        data[:performance_context] = build_performance_context
+
+        # Add request context if available
+        if defined?(Thread) && Thread.current[:active_rabbit_request_context]
+          data[:request_context] = Thread.current[:active_rabbit_request_context]
+        end
+
+        data
+      end
+
+      def build_performance_context
+        context = {}
+
+        # Memory usage
+        begin
+          if defined?(GC)
+            gc_stats = GC.stat
+            context[:memory] = {
+              heap_allocated_pages: gc_stats[:heap_allocated_pages],
+              heap_sorted_length: gc_stats[:heap_sorted_length],
+              heap_allocatable_pages: gc_stats[:heap_allocatable_pages],
+              heap_available_slots: gc_stats[:heap_available_slots],
+              heap_live_slots: gc_stats[:heap_live_slots],
+              heap_free_slots: gc_stats[:heap_free_slots],
+              total_allocated_pages: gc_stats[:total_allocated_pages]
+            }
+          end
+        rescue
+          # Ignore if GC stats are not available
+        end
+
+        # Process information
+        begin
+          context[:process] = {
+            pid: Process.pid
+          }
+        rescue
+          # Ignore if process info is not available
+        end
+
+        # Thread information
+        begin
+          context[:threading] = {
+            active_threads: Thread.list.size
+          }
+        rescue
+          # Ignore if thread info is not available
+        end
+
+        context
+      end
+
+      def scrub_pii(data)
+        return data unless configuration.enable_pii_scrubbing
+
+        PiiScrubber.new(configuration).scrub(data)
+      end
+    end
+  end
+end