brainzlab-rails 0.1.1

data/lib/brainzlab/rails/analyzers/n_plus_one_detector.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Rails
+    module Analyzers
+      # Detects N+1 query patterns by tracking similar queries within a request
+      class NPlusOneDetector
+        THRESHOLD = 3 # Minimum repeated queries to flag as N+1
+
+        def initialize
+          @query_tracker = {}
+          @request_id = nil
+        end
+
+        def check(sql, name, unique_id)
+          # Reset tracker on new request
+          reset_if_new_request(unique_id)
+
+          # Skip non-SELECT queries
+          return nil unless sql.to_s.strip.upcase.start_with?('SELECT')
+
+          # Skip SCHEMA queries
+          return nil if name == 'SCHEMA'
+
+          # Normalize query for comparison (remove specific values)
+          normalized = normalize_query(sql)
+
+          # Track query occurrences
+          @query_tracker[normalized] ||= { count: 0, first_seen: Time.now, sql: sql }
+          @query_tracker[normalized][:count] += 1
+
+          # Check if threshold exceeded
+          count = @query_tracker[normalized][:count]
+          if count == THRESHOLD
+            {
+              query: truncate_sql(sql),
+              normalized: normalized,
+              count: count,
+              model: extract_model_from_query(sql),
+              location: extract_caller_location
+            }
+          else
+            nil
+          end
+        end
+
+        private
+
+        def reset_if_new_request(unique_id)
+          if @request_id != unique_id
+            @request_id = unique_id
+            @query_tracker = {}
+          end
+        end
+
+        def normalize_query(sql)
+          sql
+            .gsub(/\d+/, '?')                          # Replace numbers with ?
+            .gsub(/'[^']*'/, '?')                      # Replace strings with ?
+            .gsub(/"[^"]*"/, '?')                      # Replace quoted strings with ?
+            .gsub(/\s+/, ' ')                          # Normalize whitespace
+            .strip
+        end
+
+        def extract_model_from_query(sql)
+          # Try to extract table name from SELECT ... FROM table_name
+          match = sql.match(/FROM\s+["`']?(\w+)["`']?/i)
+          if match
+            table_name = match[1]
+            # Convert to likely model name
+            table_name.singularize.camelize rescue table_name
+          else
+            'Unknown'
+          end
+        end
+
+        def extract_caller_location
+          # Find the first application frame in the backtrace
+          caller.find do |frame|
+            frame.include?('/app/') && !frame.include?('/gems/')
+          end
+        end
+
+        def truncate_sql(sql, max_length = 200)
+          sql.length > max_length ? "#{sql[0, max_length]}..." : sql
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/rails/analyzers/slow_query_analyzer.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Rails
+    module Analyzers
+      # Analyzes slow queries and provides optimization suggestions
+      class SlowQueryAnalyzer
+        def initialize(configuration)
+          @configuration = configuration
+          @slow_queries = []
+        end
+
+        def analyze(sql, duration_ms, payload)
+          query_info = {
+            sql: truncate_sql(sql),
+            duration_ms: duration_ms,
+            name: payload[:name],
+            timestamp: Time.now.utc,
+            suggestions: generate_suggestions(sql, payload)
+          }
+
+          # Log slow query
+          log_slow_query(query_info)
+
+          # Track for reporting
+          @slow_queries << query_info
+
+          query_info
+        end
+
+        def recent_slow_queries(limit = 10)
+          @slow_queries.last(limit)
+        end
+
+        def clear!
+          @slow_queries = []
+        end
+
+        private
+
+        def generate_suggestions(sql, payload)
+          suggestions = []
+
+          # Check for missing index indicators
+          if sql.include?('WHERE') && !sql.include?('INDEX')
+            suggestions << 'Consider adding an index for the WHERE clause columns'
+          end
+
+          # Check for SELECT *
+          if sql.match?(/SELECT\s+\*/i)
+            suggestions << 'Avoid SELECT * - specify only needed columns'
+          end
+
+          # Check for large LIMIT
+          if sql.match?(/LIMIT\s+(\d+)/i) && Regexp.last_match(1).to_i > 1000
+            suggestions << 'Large LIMIT detected - consider pagination'
+          end
+
+          # Check for ORDER BY without LIMIT
+          if sql.include?('ORDER BY') && !sql.include?('LIMIT')
+            suggestions << 'ORDER BY without LIMIT may be slow on large tables'
+          end
+
+          # Check for multiple JOINs
+          join_count = sql.scan(/JOIN/i).size
+          if join_count > 3
+            suggestions << "#{join_count} JOINs detected - consider query optimization"
+          end
+
+          # Check for subqueries
+          if sql.scan(/SELECT/i).size > 1
+            suggestions << 'Subquery detected - consider using JOINs or CTEs'
+          end
+
+          # Check for LIKE with leading wildcard
+          if sql.match?(/LIKE\s+['"]%/i)
+            suggestions << 'Leading wildcard in LIKE prevents index usage'
+          end
+
+          # Check for OR in WHERE
+          if sql.match?(/WHERE.*\bOR\b/i)
+            suggestions << 'OR in WHERE clause may prevent index usage - consider UNION'
+          end
+
+          suggestions
+        end
+
+        def log_slow_query(query_info)
+          if BrainzLab.configuration&.recall_effectively_enabled?
+            BrainzLab::Recall.warn('Slow query detected', **{
+              sql: query_info[:sql],
+              duration_ms: query_info[:duration_ms],
+              name: query_info[:name],
+              suggestions: query_info[:suggestions]
+            })
+          end
+
+          if BrainzLab.configuration&.reflex_effectively_enabled?
+            BrainzLab::Reflex.add_breadcrumb(
+              "Slow query: #{query_info[:duration_ms]}ms",
+              category: 'db.slow_query',
+              level: :warning,
+              data: {
+                sql: query_info[:sql],
+                duration_ms: query_info[:duration_ms],
+                suggestions: query_info[:suggestions]
+              }
+            )
+          end
+        end
+
+        def truncate_sql(sql, max_length = 500)
+          sql.length > max_length ? "#{sql[0, max_length]}..." : sql
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/rails/collectors/action_cable.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Rails
+    module Collectors
+      # Collects Action Cable WebSocket events
+      # This is a KEY differentiator - most APM tools have weak WebSocket support
+      class ActionCable < Base
+        def process(event_data)
+          case event_data[:name]
+          when 'perform_action.action_cable'
+            handle_perform_action(event_data)
+          when 'transmit.action_cable'
+            handle_transmit(event_data)
+          when 'transmit_subscription_confirmation.action_cable'
+            handle_subscription_confirmation(event_data)
+          when 'transmit_subscription_rejection.action_cable'
+            handle_subscription_rejection(event_data)
+          when 'broadcast.action_cable'
+            handle_broadcast(event_data)
+          end
+        end
+
+        private
+
+        def handle_perform_action(event_data)
+          payload = event_data[:payload]
+          channel_class = payload[:channel_class]
+          action = payload[:action]
+          duration_ms = event_data[:duration_ms]
+
+          # === PULSE: WebSocket action span ===
+          send_to_pulse(event_data, {
+            name: "cable.#{channel_class}##{action}",
+            category: 'websocket.action',
+            attributes: {
+              channel: channel_class,
+              action: action,
+              data_size: payload[:data]&.to_json&.bytesize
+            }
+          })
+
+          # === FLUX: Metrics ===
+          tags = { channel: channel_class, action: action }
+          send_to_flux(:increment, 'rails.cable.actions', 1, tags)
+          send_to_flux(:timing, 'rails.cable.action_ms', duration_ms, tags)
+
+          # === RECALL: Log ===
+          send_to_recall(:info, "Cable action: #{channel_class}##{action}", {
+            channel: channel_class,
+            action: action,
+            duration_ms: duration_ms
+          })
+
+          # === REFLEX: Breadcrumb ===
+          add_breadcrumb(
+            "Cable action: #{channel_class}##{action}",
+            category: 'websocket.action',
+            level: :info,
+            data: {
+              channel: channel_class,
+              action: action,
+              duration_ms: duration_ms
+            }
+          )
+        end
+
+        def handle_transmit(event_data)
+          payload = event_data[:payload]
+          channel_class = payload[:channel_class]
+          via = payload[:via]
+          duration_ms = event_data[:duration_ms]
+
+          # Calculate data size for bandwidth tracking
+          data_size = payload[:data]&.to_json&.bytesize || 0
+
+          # === PULSE: Transmit span ===
+          send_to_pulse(event_data, {
+            name: "cable.transmit.#{channel_class}",
+            category: 'websocket.transmit',
+            attributes: {
+              channel: channel_class,
+              via: via,
+              data_size_bytes: data_size
+            }
+          })
+
+          # === FLUX: Metrics ===
+          send_to_flux(:increment, 'rails.cable.transmissions', 1, {
+            channel: channel_class
+          })
+          send_to_flux(:histogram, 'rails.cable.transmit_bytes', data_size, {
+            channel: channel_class
+          })
+          send_to_flux(:timing, 'rails.cable.transmit_ms', duration_ms, {
+            channel: channel_class
+          })
+
+          # === REFLEX: Breadcrumb ===
+          add_breadcrumb(
+            "Cable transmit: #{channel_class}",
+            category: 'websocket.transmit',
+            level: :debug,
+            data: {
+              channel: channel_class,
+              via: via,
+              data_size_bytes: data_size
+            }
+          )
+        end
+
+        def handle_subscription_confirmation(event_data)
+          payload = event_data[:payload]
+          channel_class = payload[:channel_class]
+
+          # === FLUX: Subscription metrics ===
+          send_to_flux(:increment, 'rails.cable.subscriptions', 1, {
+            channel: channel_class,
+            status: 'confirmed'
+          })
+
+          # === RECALL: Log ===
+          send_to_recall(:info, "Cable subscription confirmed", {
+            channel: channel_class
+          })
+
+          # === REFLEX: Breadcrumb ===
+          add_breadcrumb(
+            "Cable subscribed: #{channel_class}",
+            category: 'websocket.subscribe',
+            level: :info,
+            data: { channel: channel_class }
+          )
+        end
+
+        def handle_subscription_rejection(event_data)
+          payload = event_data[:payload]
+          channel_class = payload[:channel_class]
+
+          # === FLUX: Rejection metrics ===
+          send_to_flux(:increment, 'rails.cable.subscriptions', 1, {
+            channel: channel_class,
+            status: 'rejected'
+          })
+
+          # === RECALL: Log rejection (potential auth issue) ===
+          send_to_recall(:warn, "Cable subscription rejected", {
+            channel: channel_class
+          })
+
+          # === REFLEX: Breadcrumb ===
+          add_breadcrumb(
+            "Cable subscription rejected: #{channel_class}",
+            category: 'websocket.subscribe',
+            level: :warning,
+            data: { channel: channel_class }
+          )
+        end
+
+        def handle_broadcast(event_data)
+          payload = event_data[:payload]
+          broadcasting = payload[:broadcasting]
+          coder = payload[:coder]
+          duration_ms = event_data[:duration_ms]
+
+          # Calculate message size
+          message_size = payload[:message]&.to_json&.bytesize || 0
+
+          # === PULSE: Broadcast span ===
+          send_to_pulse(event_data, {
+            name: "cable.broadcast.#{broadcasting}",
+            category: 'websocket.broadcast',
+            attributes: {
+              broadcasting: broadcasting,
+              coder: coder.to_s,
+              message_size_bytes: message_size
+            }
+          })
+
+          # === FLUX: Broadcast metrics ===
+          send_to_flux(:increment, 'rails.cable.broadcasts', 1, {
+            broadcasting: broadcasting
+          })
+          send_to_flux(:histogram, 'rails.cable.broadcast_bytes', message_size, {
+            broadcasting: broadcasting
+          })
+          send_to_flux(:timing, 'rails.cable.broadcast_ms', duration_ms, {
+            broadcasting: broadcasting
+          })
+
+          # === RECALL: Log broadcast ===
+          send_to_recall(:info, "Cable broadcast", {
+            broadcasting: broadcasting,
+            message_size_bytes: message_size,
+            duration_ms: duration_ms
+          })
+
+          # === REFLEX: Breadcrumb ===
+          add_breadcrumb(
+            "Cable broadcast: #{broadcasting}",
+            category: 'websocket.broadcast',
+            level: :info,
+            data: {
+              broadcasting: broadcasting,
+              message_size_bytes: message_size
+            }
+          )
+        end
+      end
+    end
+  end
+end