rails_vitals 0.4.0 → 0.4.2

data/lib/rails_vitals/analyzers/explain_analyzer.rb

@@ -13,104 +13,104 @@ module RailsVitals
       # Node types and their risk/education metadata
       NODE_METADATA = {
         "Seq Scan" => {
-          risk:        :danger,
-          color:       COLOR_DANGER,
-          label:       "Sequential Scan",
+          risk: :danger,
+          color: COLOR_DANGER,
+          label: "Sequential Scan",
           explanation: "PostgreSQL read every row in the table to find matches. " \
                        "No index was used. This gets linearly slower as the table grows, " \
                        "at 1M rows it scans 1M rows for every query hit.",
-          fix_type:    :missing_index
+          fix_type: :missing_index
         },
         "Index Scan" => {
-          risk:        :healthy,
-          color:       COLOR_HEALTHY,
-          label:       "Index Scan",
+          risk: :healthy,
+          color: COLOR_HEALTHY,
+          label: "Index Scan",
           explanation: "PostgreSQL used an index to locate matching rows directly. " \
                        "Fast and consistent regardless of table size.",
-          fix_type:    nil
+          fix_type: nil
         },
         "Index Only Scan" => {
-          risk:        :healthy,
-          color:       COLOR_HEALTHY,
-          label:       "Index Only Scan",
+          risk: :healthy,
+          color: COLOR_HEALTHY,
+          label: "Index Only Scan",
           explanation: "PostgreSQL satisfied the query entirely from the index " \
                        "without touching the table. The most efficient scan type.",
-          fix_type:    nil
+          fix_type: nil
         },
         "Bitmap Heap Scan" => {
-          risk:        :neutral,
-          color:       COLOR_WARNING,
-          label:       "Bitmap Heap Scan",
+          risk: :neutral,
+          color: COLOR_WARNING,
+          label: "Bitmap Heap Scan",
           explanation: "PostgreSQL built a bitmap of matching index entries, then " \
                        "fetched the actual rows. Common with IN (...) conditions and " \
                        "multiple indexes. Generally acceptable.",
-          fix_type:    nil
+          fix_type: nil
         },
         "Bitmap Index Scan" => {
-          risk:        :neutral,
-          color:       COLOR_WARNING,
-          label:       "Bitmap Index Scan",
+          risk: :neutral,
+          color: COLOR_WARNING,
+          label: "Bitmap Index Scan",
           explanation: "Builds a bitmap of row locations from an index. " \
                        "Works in conjunction with Bitmap Heap Scan.",
-          fix_type:    nil
+          fix_type: nil
         },
         "Hash Join" => {
-          risk:        :neutral,
-          color:       COLOR_INFO,
-          label:       "Hash Join",
+          risk: :neutral,
+          color: COLOR_INFO,
+          label: "Hash Join",
           explanation: "Builds a hash table from one side of the JOIN, then probes " \
                        "it for each row from the other side. Common with includes() " \
                        "and eager_load(). Efficient for large datasets.",
-          fix_type:    nil
+          fix_type: nil
         },
         "Nested Loop" => {
-          risk:        :warning,
-          color:       COLOR_WARNING,
-          label:       "Nested Loop",
+          risk: :warning,
+          color: COLOR_WARNING,
+          label: "Nested Loop",
           explanation: "For each row on the outer side, scans the inner side. " \
                        "Fast when the inner side is small or uses an index. " \
                        "Dangerous when both sides are large, O(n²) complexity.",
-          fix_type:    :check_join_indexes
+          fix_type: :check_join_indexes
         },
         "Merge Join" => {
-          risk:        :neutral,
-          color:       COLOR_COOL,
-          label:       "Merge Join",
+          risk: :neutral,
+          color: COLOR_COOL,
+          label: "Merge Join",
           explanation: "Joins two pre-sorted datasets by merging them in order. " \
                        "Efficient when both sides are already sorted on the join key.",
-          fix_type:    nil
+          fix_type: nil
         },
         "Aggregate" => {
-          risk:        :neutral,
-          color:       COLOR_NEUTRAL,
-          label:       "Aggregate",
+          risk: :neutral,
+          color: COLOR_NEUTRAL,
+          label: "Aggregate",
           explanation: "Computes an aggregate function (COUNT, SUM, AVG, etc.) " \
                        "over a set of rows. Generated by .count, .sum, .average in Rails.",
-          fix_type:    nil
+          fix_type: nil
         },
         "Hash" => {
-          risk:        :neutral,
-          color:       COLOR_NEUTRAL,
-          label:       "Hash",
+          risk: :neutral,
+          color: COLOR_NEUTRAL,
+          label: "Hash",
           explanation: "Builds a hash table in memory for use by a Hash Join node above it.",
-          fix_type:    nil
+          fix_type: nil
         },
         "Sort" => {
-          risk:        :warning,
-          color:       COLOR_WARNING,
-          label:       "Sort",
+          risk: :warning,
+          color: COLOR_WARNING,
+          label: "Sort",
           explanation: "PostgreSQL sorted rows in memory (or on disk if large). " \
                        "Generated by ORDER BY on an unindexed column. " \
                        "An index on the sort column eliminates this node entirely.",
-          fix_type:    :index_sort_column
+          fix_type: :index_sort_column
         },
         "Limit" => {
-          risk:        :healthy,
-          color:       COLOR_HEALTHY,
-          label:       "Limit",
+          risk: :healthy,
+          color: COLOR_HEALTHY,
+          label: "Limit",
           explanation: "Stops fetching rows once the LIMIT is reached. " \
                        "Good, always paginate large result sets.",
-          fix_type:    nil
+          fix_type: nil
         }
       }.freeze
 
@@ -147,18 +147,18 @@ module RailsVitals
         exec_time = plan_json.first["Execution Time"]&.round(2)
 
         root_node = build_node(root_plan)
-        warnings  = extract_warnings(root_node)
+        warnings = extract_warnings(root_node)
         suggestions = build_suggestions(warnings, root_node)
 
         result = Result.new(
-          sql:            safe_sql,
-          plan:           root_node,
-          warnings:       warnings,
-          suggestions:    suggestions,
-          total_cost:     root_plan["Total Cost"]&.round(2),
+          sql: safe_sql,
+          plan: root_node,
+          warnings: warnings,
+          suggestions: suggestions,
+          total_cost: root_plan["Total Cost"]&.round(2),
           actual_time_ms: exec_time,
-          rows_examined:  count_rows_examined(root_plan),
-          error:          nil
+          rows_examined: count_rows_examined(root_plan),
+          error: nil
         )
 
         result.interpretation = interpret(result)
@@ -186,6 +186,7 @@ module RailsVitals
           value = bind.is_a?(String) ? "'#{bind.gsub("'", "''")}'" : bind.to_s
           result = result.gsub("$#{i + 1}", value)
         end
+
         # Replace any remaining ? placeholders with NULL
         result.gsub("?", "NULL")
       end
@@ -263,7 +264,7 @@ module RailsVitals
               migration: fk ?
                 "add_index :#{w[:table]}, :#{fk}" :
                 "add_index :#{w[:table]}, :COLUMN_NAME",
-              command:   "rails g migration Add#{fk&.camelize || 'Index'}To#{w[:table].camelize}"
+              command: "rails g migration Add#{fk&.camelize || 'Index'}To#{w[:table].camelize}"
             }
           when :sort_without_index
             suggestions << {
@@ -291,6 +292,7 @@ module RailsVitals
 
       def self.extract_fk_from_filter(filter)
         return nil unless filter
+
         match = filter.match(/\((\w+)\s*=\s*/i)
         match ? match[1] : nil
       end

data/lib/rails_vitals/analyzers/n_plus_one_aggregator.rb

@@ -4,11 +4,11 @@ module RailsVitals
       def self.aggregate(records)
         pattern_data = Hash.new do |h, k|
           h[k] = {
-            pattern:      k,
-            occurrences:  0,
-            endpoints:    Hash.new(0),
-            table:        nil,
-            foreign_key:  nil
+            pattern: k,
+            occurrences: 0,
+            endpoints: Hash.new(0),
+            table: nil,
+            foreign_key: nil
           }
         end
 
@@ -17,11 +17,11 @@ module RailsVitals
 
           record.n_plus_one_patterns.each do |sql, count|
             normalized = normalize(sql)
-            Rails.logger.debug "Processing SQL: #{sql} → normalized: #{normalized}"
+            Rails.logger.debug "#{self.name}: Processing SQL: #{sql} → normalized: #{normalized}"
 
             pattern_data[normalized][:occurrences] += count
             pattern_data[normalized][:endpoints][record.endpoint] += 1
-            pattern_data[normalized][:table]       ||= extract_table(sql)
+            pattern_data[normalized][:table] ||= extract_table(sql)
             pattern_data[normalized][:foreign_key] ||= extract_foreign_key(sql)
           end
         end
@@ -39,7 +39,7 @@ module RailsVitals
 
       def self.normalize(sql)
         sql
-          .gsub('\\"', '"')      # unescape stored escaped quotes
+          .gsub('\\"', '"') # unescape stored escaped quotes
           .gsub(/\b\d+\b/, "?")
           .gsub(/'[^']*'/, "?")
           .gsub(/\s+/, " ")
@@ -57,7 +57,7 @@ module RailsVitals
       end
 
       def self.build_suggestion(pattern)
-        table       = pattern[:table]
+        table = pattern[:table]
         foreign_key = pattern[:foreign_key]
 
         return generic_suggestion(table) unless table && foreign_key
@@ -68,9 +68,9 @@ module RailsVitals
 
         if owner_model && assoc_name
           {
-            code:        "#{owner_model}.includes(:#{assoc_name})",
+            code: "#{owner_model}.includes(:#{assoc_name})",
             description: "Eager load :#{assoc_name} on #{owner_model} to eliminate this N+1",
-            owner:       owner_model,
+            owner: owner_model,
             association: assoc_name
           }
         else
@@ -105,9 +105,9 @@ module RailsVitals
 
       def self.generic_suggestion(table)
         {
-          code:        "includes(:#{table&.singularize})",
+          code: "includes(:#{table&.singularize})",
           description: "Use includes(), eager_load(), or preload() to batch this query",
-          owner:       nil,
+          owner: nil,
           association: table&.singularize
         }
       end

data/lib/rails_vitals/analyzers/sql_tokenizer.rb

@@ -3,63 +3,63 @@ module RailsVitals
     class SqlTokenizer
       TOKEN_DEFINITIONS = [
         {
-          type:        :select_star,
-          pattern:     /\bSELECT\s+\*\b/i,
-          label:       "SELECT *",
-          color:       "#4299e1",
-          risk:        :warning,
+          type: :select_star,
+          pattern: /\bSELECT\s+\*\b/i,
+          label: "SELECT *",
+          color: "#4299e1",
+          risk: :warning,
           explanation: "Fetches all columns from the table. In Rails this is the default " \
                        "behavior of Model.all and most queries. Can be wasteful when you " \
                        "only need specific attributes. Use .select(:id, :name) to fetch " \
                        "only what you need, especially on wide tables."
         },
         {
-          type:        :select,
-          pattern:     /\bSELECT\b(?!\s+\*)/i,
-          label:       "SELECT",
-          color:       "#4299e1",
-          risk:        :healthy,
+          type: :select,
+          pattern: /\bSELECT\b(?!\s+\*)/i,
+          label: "SELECT",
+          color: "#4299e1",
+          risk: :healthy,
           explanation: "Fetches specific columns. More efficient than SELECT * when your " \
                        "table has many columns or large text/json fields you don't need."
         },
         {
-          type:        :count,
-          pattern:     /\bCOUNT\s*\(/i,
-          label:       "COUNT(*)",
-          color:       "#ed8936",
-          risk:        :warning,
+          type: :count,
+          pattern: /\bCOUNT\s*\(/i,
+          label: "COUNT(*)",
+          color: "#ed8936",
+          risk: :warning,
           explanation: "Counts rows matching the condition. When this appears in a loop " \
                        "(N+1 pattern), Rails fires one COUNT query per record. The fix is " \
                        "a counter cache column or loading the association and calling .size " \
                        "which uses the already-loaded records instead of hitting the DB."
         },
         {
-          type:        :aggregation,
-          pattern:     /\b(SUM|AVG|MIN|MAX)\s*\(/i,
-          label:       "AGGREGATE",
-          color:       "#ed8936",
-          risk:        :warning,
+          type: :aggregation,
+          pattern: /\b(SUM|AVG|MIN|MAX)\s*\(/i,
+          label: "AGGREGATE",
+          color: "#ed8936",
+          risk: :warning,
           explanation: "Aggregation function (SUM/AVG/MIN/MAX). Like COUNT, these are " \
                        "dangerous in loops. Each call fires a separate query. Consider " \
                        "loading the association once and using Ruby's .sum/.min/.max on " \
                        "the already-loaded collection instead."
         },
         {
-          type:        :from,
-          pattern:     /\bFROM\s+"?(\w+)"?/i,
-          label:       "FROM",
-          color:       "#68d391",
-          risk:        :healthy,
+          type: :from,
+          pattern: /\bFROM\s+"?(\w+)"?/i,
+          label: "FROM",
+          color: "#68d391",
+          risk: :healthy,
           explanation: "Identifies which table (and therefore which ActiveRecord model) " \
                        "is being queried. In an N+1, you'll see the same FROM table " \
                        "repeated many times, once per parent record."
         },
         {
-          type:        :where_fk,
-          pattern:     /\bWHERE\s+.*\w+_id\s*=/i,
-          label:       "WHERE fk =",
-          color:       "#fc8181",
-          risk:        :danger,
+          type: :where_fk,
+          pattern: /\bWHERE\s+.*\w+_id\s*=/i,
+          label: "WHERE fk =",
+          color: "#fc8181",
+          risk: :danger,
           explanation: "WHERE condition on a foreign key with a single value. This is " \
                        "the N+1 signature, loading one associated record at a time. " \
                        "When you see this pattern repeated, it means Rails is fetching " \
@@ -67,33 +67,33 @@ module RailsVitals
                        "which replaces this with a single WHERE fk IN (...) query."
         },
         {
-          type:        :where,
-          pattern:     /\bWHERE\b/i,
-          label:       "WHERE",
-          color:       "#f6ad55",
-          risk:        :neutral,
+          type: :where,
+          pattern: /\bWHERE\b/i,
+          label: "WHERE",
+          color: "#f6ad55",
+          risk: :neutral,
           explanation: "Filters rows by condition. Efficient when the condition column " \
                        "has an index. Slow when it doesn't. DB engine will scan every " \
                        "row in the table (Sequential Scan). Check the EXPLAIN output to " \
                        "verify an index is being used."
         },
         {
-          type:        :where_in,
-          pattern:     /\bIN\s*\(/i,
-          label:       "IN (...)",
-          color:       "#68d391",
-          risk:        :healthy,
+          type: :where_in,
+          pattern: /\bIN\s*\(/i,
+          label: "IN (...)",
+          color: "#68d391",
+          risk: :healthy,
           explanation: "Batch lookup fetches multiple records in one query using a list " \
                        "of values. This is what eager loading (includes/preload) generates " \
                        "instead of repeated WHERE fk = ? queries. Seeing IN (...) means " \
                        "your associations are being loaded efficiently."
         },
         {
-          type:        :inner_join,
-          pattern:     /\bINNER\s+JOIN\b/i,
-          label:       "INNER JOIN",
-          color:       "#9f7aea",
-          risk:        :neutral,
+          type: :inner_join,
+          pattern: /\bINNER\s+JOIN\b/i,
+          label: "INNER JOIN",
+          color: "#9f7aea",
+          risk: :neutral,
           explanation: "Combines rows from two tables where the join condition matches. " \
                        "In Rails this is what .joins() generates. Records without a " \
                        "matching association are excluded from results. Note: .joins() " \
@@ -101,22 +101,22 @@ module RailsVitals
                        "to access associated data."
         },
         {
-          type:        :left_join,
-          pattern:     /\bLEFT\s+(OUTER\s+)?JOIN\b/i,
-          label:       "LEFT JOIN",
-          color:       "#9f7aea",
-          risk:        :neutral,
+          type: :left_join,
+          pattern: /\bLEFT\s+(OUTER\s+)?JOIN\b/i,
+          label: "LEFT JOIN",
+          color: "#9f7aea",
+          risk: :neutral,
           explanation: "Like INNER JOIN but keeps all rows from the left table even " \
                        "when there's no matching row on the right. In Rails this is " \
                        "what .eager_load() and .left_joins() generate. Use when you " \
                        "need to include records that have no associated data."
         },
         {
-          type:        :order,
-          pattern:     /\bORDER\s+BY\b/i,
-          label:       "ORDER BY",
-          color:       "#76e4f7",
-          risk:        :warning,
+          type: :order,
+          pattern: /\bORDER\s+BY\b/i,
+          label: "ORDER BY",
+          color: "#76e4f7",
+          risk: :warning,
           explanation: "Sorts results by a column. Fast when sorting on an indexed " \
                        "column. Slow when sorting on an unindexed column. DB engine " \
                        "must sort all matching rows in memory. Default Rails scopes " \
@@ -124,22 +124,22 @@ module RailsVitals
                        "has an index if your table is large."
         },
         {
-          type:        :limit,
-          pattern:     /\bLIMIT\s+\d+/i,
-          label:       "LIMIT",
-          color:       "#a0aec0",
-          risk:        :healthy,
+          type: :limit,
+          pattern: /\bLIMIT\s+\d+/i,
+          label: "LIMIT",
+          color: "#a0aec0",
+          risk: :healthy,
           explanation: "Restricts the number of rows returned. Always use LIMIT in " \
                        "production feeds and lists, never load unbounded data. " \
                        "Note: LIMIT with OFFSET becomes slower as OFFSET grows " \
                        "because DB engine must scan and discard all preceding rows."
         },
         {
-          type:        :offset,
-          pattern:     /\bOFFSET\s+\d+/i,
-          label:       "OFFSET",
-          color:       "#fc8181",
-          risk:        :warning,
+          type: :offset,
+          pattern: /\bOFFSET\s+\d+/i,
+          label: "OFFSET",
+          color: "#fc8181",
+          risk: :warning,
           explanation: "Skips N rows before returning results. Common in pagination " \
                        "(page 2, page 3...). The hidden cost: DB engine must read " \
                        "and discard all rows before the offset, at page 100 with " \
@@ -147,11 +147,11 @@ module RailsVitals
                        "cursor-based pagination (WHERE id > last_id) for large datasets."
         },
         {
-          type:        :group_by,
-          pattern:     /\bGROUP\s+BY\b/i,
-          label:       "GROUP BY",
-          color:       "#76e4f7",
-          risk:        :neutral,
+          type: :group_by,
+          pattern: /\bGROUP\s+BY\b/i,
+          label: "GROUP BY",
+          color: "#76e4f7",
+          risk: :neutral,
           explanation: "Groups rows sharing a value and applies aggregate functions " \
                        "per group. Common with COUNT, SUM, AVG. Used in Rails with " \
                        ".group(:column). Consider a counter cache column if you're " \
@@ -162,11 +162,11 @@ module RailsVitals
 
       COMPLEXITY_RULES = [
         { tokens: [ :left_join, :inner_join ], points: 2 },
-        { tokens: [ :where_fk ],              points: 3 },
-        { tokens: [ :count, :aggregation ],   points: 2 },
-        { tokens: [ :offset ],                points: 2 },
-        { tokens: [ :group_by ],              points: 1 },
-        { tokens: [ :order ],                 points: 1 }
+        { tokens: [ :where_fk ], points: 3 },
+        { tokens: [ :count, :aggregation ], points: 2 },
+        { tokens: [ :offset ], points: 2 },
+        { tokens: [ :group_by ], points: 1 },
+        { tokens: [ :order ], points: 1 }
       ].freeze
 
       Result = Struct.new(:tokens, :complexity, :complexity_label,
@@ -181,12 +181,12 @@ module RailsVitals
         repetition = calculate_repetition(sql, all_queries)
 
         Result.new(
-          tokens:           matched,
-          complexity:       complexity,
+          tokens: matched,
+          complexity: complexity,
           complexity_label: complexity_label(complexity),
-          risk:             risk,
+          risk: risk,
           repetition_count: repetition,
-          repetition_bar:   repetition_bar(repetition, all_queries.size)
+          repetition_bar: repetition_bar(repetition, all_queries.size)
         )
       end
 
@@ -203,9 +203,9 @@ module RailsVitals
 
       def self.complexity_label(score)
         case score
-        when 1..2 then { label: "Simple",   color: "#68d391" }
+        when 1..2 then { label: "Simple", color: "#68d391" }
         when 3..5 then { label: "Moderate", color: "#f6ad55" }
-        else           { label: "Complex",  color: "#fc8181" }
+        else           { label: "Complex", color: "#fc8181" }
         end
       end
 

data/lib/rails_vitals/collector.rb

@@ -4,43 +4,43 @@ module RailsVitals
                 :response_status, :duration_ms, :started_at
 
     def initialize
-      @queries        = []
-      @callbacks      = []
-      @controller     = nil
-      @action         = nil
-      @http_method    = nil
+      @queries = []
+      @callbacks = []
+      @controller = nil
+      @action = nil
+      @http_method = nil
       @response_status = nil
-      @duration_ms    = nil
-      @started_at     = Time.now
+      @duration_ms = nil
+      @started_at = Time.now
     end
 
     # Called by the sql.active_record subscriber
     def add_query(sql:, duration_ms:, source:, binds: [])
       @queries << {
-        sql:         sql,
+        sql: sql,
         duration_ms: duration_ms,
-        source:      source,
-        binds:       binds,
-        called_at:   Time.now
+        source: source,
+        binds: binds,
+        called_at: Time.now
       }
     end
 
     def add_callback(model:, kind:, duration_ms:)
       @callbacks << {
-        model:       model,
-        kind:        kind,
+        model: model,
+        kind: kind,
         duration_ms: duration_ms,
-        called_at:   Time.now
+        called_at: Time.now
       }
     end
 
     # Called by the process_action.action_controller subscriber
     def finalize!(event)
-      @controller      = event.payload[:controller]
-      @action          = event.payload[:action]
-      @http_method     = event.payload[:method]
+      @controller = event.payload[:controller]
+      @action = event.payload[:action]
+      @http_method = event.payload[:method]
       @response_status = event.payload[:status]
-      @duration_ms     = event.duration
+      @duration_ms = event.duration
     end
 
     def total_query_count

data/lib/rails_vitals/instrumentation/callback_instrumentation.rb

@@ -13,13 +13,13 @@ module RailsVitals
           return super
         end
 
-        start  = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
         result = super
         duration = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start
 
         collector.add_callback(
-          model:       self.class.name,
-          kind:        kind,
+          model: self.class.name,
+          kind: kind,
           duration_ms: duration.round(2)
         )
 

data/lib/rails_vitals/notifications/subscriber.rb

@@ -28,10 +28,10 @@ module RailsVitals
           next if rails_vitals_request?
 
           collector.add_query(
-            sql:         event.payload[:sql],
+            sql: event.payload[:sql],
             duration_ms: event.duration,
-            source:      extract_source(event.payload[:binds]),
-            binds:       event.payload[:binds]&.map(&:value) || []
+            source: extract_source(event.payload[:binds]),
+            binds: event.payload[:binds]&.map(&:value) || []
           )
         end
       end