rails-profiler 0.41.0 → 0.43.0

data/lib/profiler/mcp/tools/compare_profiles.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Profiler
+  module MCP
+    module Tools
+      class CompareProfiles
+        def self.call(params)
+          token_a = params["token_a"]
+          token_b = params["token_b"]
+
+          errors = []
+          errors << "Missing parameter: token_a" if token_a.nil? || token_a.empty?
+          errors << "Missing parameter: token_b" if token_b.nil? || token_b.empty?
+
+          if errors.any?
+            return [{ type: "text", text: "Error: #{errors.join(', ')}" }]
+          end
+
+          node_a = params["node_a"].to_s
+          node_b = params["node_b"].to_s
+
+          if token_a == token_b && node_a == node_b
+            return [{ type: "text", text: "Error: Cannot compare a profile with itself" }]
+          end
+
+          begin
+            diff = ProfileComparison.call(token_a, token_b, node_a: node_a, node_b: node_b)
+          rescue Profiler::Error => e
+            return [{ type: "text", text: e.message.start_with?("Profile not found") ? e.message : "Error: #{e.message}" }]
+          end
+
+          [{ type: "text", text: format_diff(diff) }]
+        end
+
+        def self.format_diff(diff)
+          pa = diff[:profile_a]
+          pb = diff[:profile_b]
+          m = diff[:metrics]
+
+          lines = []
+          lines << "# Profile Comparison\n"
+          lines << "**A:** `#{pa[:token]}` on #{pa[:node]}: #{pa[:method]} #{pa[:path]} (#{pa[:started_at]})"
+          lines << "**B:** `#{pb[:token]}` on #{pb[:node]}: #{pb[:method]} #{pb[:path]} (#{pb[:started_at]})\n"
+
+          unless diff[:same_endpoint]
+            lines << "⚠️ **Warning:** These profiles are from different endpoints - comparison may not be meaningful.\n"
+          end
+
+          lines << "## Scorecard\n"
+          lines << "| Metric | A | B | Delta | Status |"
+          lines << "|--------|---|---|-------|--------|"
+
+          append_metric(lines, "Duration (ms)", m[:duration])
+          append_metric(lines, "Allocated objects", m[:allocated_objects])
+          append_metric(lines, "DB Queries", m[:db_queries])
+          append_metric(lines, "DB Duration (ms)", m[:db_duration])
+          append_metric(lines, "Cache Hit Rate (%)", m[:cache_hit_rate])
+          append_metric(lines, "View Duration (ms)", m[:view_duration])
+          append_metric(lines, "HTTP Requests", m[:http_requests])
+          append_metric(lines, "HTTP Duration (ms)", m[:http_duration])
+
+          lines << ""
+          lines += format_sql(diff[:sql])
+          lines += format_database(diff[:collectors][:database])
+          lines += format_cache(diff[:collectors][:cache])
+          lines += format_views(diff[:collectors][:views])
+          lines += format_http(diff[:collectors][:http])
+
+          lines.join("\n")
+        end
+
+        def self.append_metric(lines, label, metric, formatter = nil)
+          return unless metric
+
+          fmt = formatter || ->(v) { v&.round(2)&.to_s || "-" }
+          val_a = fmt.call(metric[:value_a])
+          val_b = fmt.call(metric[:value_b])
+          delta = metric[:delta]
+          delta_pct = metric[:delta_pct]
+          sign = delta >= 0 ? "+" : ""
+          delta_str = "#{sign}#{delta.round(2)}"
+          delta_str += " (#{sign}#{delta_pct}%)" if delta_pct
+
+          icon = case metric[:status]
+                 when :improved then "✅"
+                 when :regression then "❌"
+                 else "➖"
+                 end
+
+          lines << "| #{label} | #{val_a} | #{val_b} | #{delta_str} | #{icon} |"
+        end
+
+        def self.markdown_table(title, guard_key, data, rows)
+          return [] unless data[guard_key]
+
+          lines = ["## #{title}\n", "| Metric | A | B |", "|--------|---|---|"]
+          rows.each { |label, a, b| lines << "| #{label} | #{a || '-'} | #{b || '-'} |" }
+          lines << ""
+          lines
+        end
+
+        def self.format_database(db)
+          markdown_table("Database", :total_queries_a, db, [
+            ["Total Queries",       db[:total_queries_a],                db[:total_queries_b]],
+            ["Total Duration (ms)", db[:total_duration_a]&.round(2),     db[:total_duration_b]&.round(2)],
+            ["Slow Queries",        db[:slow_queries_a],                 db[:slow_queries_b]],
+            ["Cached Queries",      db[:cached_queries_a],               db[:cached_queries_b]]
+          ])
+        end
+
+        def self.format_sql(sql)
+          lines = []
+          { new: "New queries (only in B)", gone: "Gone queries (only in A)", slower: "Slower queries" }.each do |key, title|
+            lines << "## #{title}\n"
+            if sql[key].empty?
+              lines << "None.\n"
+              next
+            end
+
+            lines << "| Query | Count A | Count B | Time A (ms) | Time B (ms) |"
+            lines << "|-------|---------|---------|-------------|-------------|"
+            sql[key].each do |q|
+              lines << "| `#{q[:fingerprint].to_s.gsub("|", "\\|").slice(0, 120)}` | #{q[:count_a]} | #{q[:count_b]} | " \
+                       "#{q[:total_duration_a]} | #{q[:total_duration_b]} |"
+            end
+            lines << ""
+          end
+          lines
+        end
+
+        def self.format_cache(cache)
+          markdown_table("Cache", :hit_rate_a, cache, [
+            ["Total Reads",  cache[:total_reads_a],  cache[:total_reads_b]],
+            ["Total Writes", cache[:total_writes_a], cache[:total_writes_b]],
+            ["Hit Rate (%)", cache[:hit_rate_a],     cache[:hit_rate_b]]
+          ])
+        end
+
+        def self.format_views(views)
+          markdown_table("Views", :total_duration_a, views, [
+            ["Templates",           views[:total_views_a],                views[:total_views_b]],
+            ["Partials",            views[:total_partials_a],             views[:total_partials_b]],
+            ["Total Duration (ms)", views[:total_duration_a]&.round(2),  views[:total_duration_b]&.round(2)]
+          ])
+        end
+
+        def self.format_http(http)
+          markdown_table("Outbound HTTP", :total_requests_a, http, [
+            ["Total Requests",      http[:total_requests_a],              http[:total_requests_b]],
+            ["Total Duration (ms)", http[:total_duration_a]&.round(2),   http[:total_duration_b]&.round(2)],
+            ["Slow Requests",       http[:slow_requests_a],               http[:slow_requests_b]],
+            ["Error Requests",      http[:error_requests_a],              http[:error_requests_b]]
+          ])
+        end
+      end
+    end
+  end
+end

data/lib/profiler/peers/peer_proxy.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+require_relative "../peers"
+require_relative "../storage/token"
+
+module Profiler
+  module Peers
+    # Reads one profile from a peer listed in config.peers, through its /_profiler/api. The only
+    # target is the URL of the configuration entry found by name: no URL is ever taken as an argument.
+    class PeerProxy
+      # Same budget as Cluster::SlaveProxy: a slow peer must not hold the request thread for long.
+      OPEN_TIMEOUT = 5  # seconds
+      READ_TIMEOUT = 10 # seconds
+
+      attr_reader :name
+
+      def initialize(node, open_timeout: nil, read_timeout: nil)
+        peer = Peers.find!(node)
+        if (problem = Peers.token_problem)
+          raise Profiler::Error, "#{problem}: requests to peer #{peer.name.inspect} are refused"
+        end
+
+        @name = peer.name
+        @base_url = peer.url.to_s.chomp("/")
+        @open_timeout = open_timeout || OPEN_TIMEOUT
+        @read_timeout = read_timeout || READ_TIMEOUT
+      end
+
+      # nil when the peer has no such profile. A token the gem could not have issued is not
+      # asked for.
+      def load(token)
+        return nil unless Storage::Token.valid?(token)
+
+        data = get_json("/_profiler/api/profiles/#{Cluster::Security.escape_segment(token)}")
+        return nil if data.nil?
+        raise Profiler::Error, "Peer #{@name.inspect} sent an unexpected answer" unless data.is_a?(Hash) && data["token"]
+
+        require_relative "../models/profile"
+        Profiler::Models::Profile.from_hash(data.transform_keys(&:to_sym))
+      end
+
+      private
+
+      def get_json(path)
+        if (reason = Cluster::Security.api_path_denial(path))
+          raise Profiler::Error, "Refusing to send a request to peer #{@name.inspect}: #{reason}"
+        end
+
+        uri = URI("#{@base_url}#{path}")
+        req = Net::HTTP::Get.new(uri)
+        req[Profiler::FORGERY_PROTECTION_HEADER] = "1"
+        Peers.outgoing_headers.each { |header, value| req[header] = value }
+        # The profiler's own call, never recorded in the profile of the request that makes it.
+        resp = Profiler.untracked_http do
+          Net::HTTP.start(uri.hostname, uri.port, open_timeout: @open_timeout, read_timeout: @read_timeout,
+                                                  use_ssl: uri.scheme == "https") { |http| http.request(req) }
+        end
+        interpret(resp)
+      rescue SocketError, SystemCallError, Net::OpenTimeout, Net::ReadTimeout, OpenSSL::SSL::SSLError, IOError => e
+        raise Profiler::Error, "Peer #{@name.inspect} is unreachable (#{e.class}: #{e.message})"
+      end
+
+      # Net::HTTP never follows a redirect: a 3xx is reported rather than read as an answer.
+      def interpret(resp)
+        code = resp.code.to_s
+        return nil if code == "404"
+        raise Profiler::Error, "Peer #{@name.inspect} answered #{code} (redirect not followed)" if code.start_with?("3")
+        if %w[401 403].include?(code)
+          raise Profiler::Error, "Peer #{@name.inspect} refused the request (#{code}): check that both instances " \
+                                 "share the same config.peer_token"
+        end
+        raise Profiler::Error, "Peer #{@name.inspect} answered #{code}" unless code == "200"
+
+        JSON.parse(resp.body.to_s)
+      rescue JSON::ParserError
+        raise Profiler::Error, "Peer #{@name.inspect} answered something that is not JSON"
+      end
+    end
+  end
+end

data/lib/profiler/peers.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+require "uri"
+require "active_support/security_utils"
+require_relative "cluster/security"
+
+module Profiler
+  # Static, explicit list of other instances (config.peers) whose profiles can be read to be
+  # compared with the local ones. Deliberately separate from the master/slave cluster: nothing
+  # here is registered at runtime, and the URLs come from the operator's configuration only,
+  # never from a request, an API parameter or an MCP tool argument.
+  module Peers
+    TOKEN_HEADER = "X-Profiler-Peer-Token"
+    TOKEN_ENV_KEY = "HTTP_X_PROFILER_PEER_TOKEN"
+    MIN_TOKEN_LENGTH = 32
+    # The names that mean "this instance" in a node selector.
+    LOCAL_NODE = "local"
+
+    Peer = Struct.new(:name, :url)
+
+    class << self
+      # The validated peers, checked once per configured list (the list is static and trusted).
+      # Raises Profiler::Error naming the first invalid entry.
+      def all
+        list = Profiler.configuration.peers
+        return [] if list.nil? || list.empty?
+
+        cache = @validated
+        return cache[1] if cache && cache[0].equal?(list) && cache[2] == list.hash
+
+        peers = validate!(list)
+        @validated = [list, peers, list.hash]
+        peers
+      end
+
+      def names
+        all.map(&:name)
+      end
+
+      def local?(node)
+        node.nil? || node.to_s.strip.empty? || node.to_s == LOCAL_NODE
+      end
+
+      # The peer called node, or a Profiler::Error. Never builds a peer from anything but config.peers.
+      def find!(node)
+        peers = all
+        peer = peers.find { |p| p.name == node.to_s }
+        return peer if peer
+
+        known = peers.empty? ? "none configured (config.peers is empty)" : peers.map(&:name).join(", ")
+        raise Profiler::Error, "Unknown node #{node.to_s.inspect}: it is not in config.peers (known nodes: #{known})"
+      end
+
+      # Why the configured token cannot be used, or nil when it can.
+      def token_problem
+        token = Profiler.configuration.peer_token.to_s
+        return "No config.peer_token is configured" if token.strip.empty?
+        return nil if token.strip.length >= MIN_TOKEN_LENGTH
+
+        "config.peer_token is shorter than #{MIN_TOKEN_LENGTH} characters, so it is ignored as if none were configured"
+      end
+
+      def configured_token?
+        token_problem.nil?
+      end
+
+      def outgoing_headers
+        { TOKEN_HEADER => Profiler.configuration.peer_token.to_s }
+      end
+
+      # Constant-time comparison of the token a request carries; false when none is configured.
+      def valid_token?(presented)
+        return false unless configured_token?
+        return false if presented.to_s.empty?
+
+        ActiveSupport::SecurityUtils.secure_compare(presented.to_s, Profiler.configuration.peer_token.to_s)
+      end
+
+      def request_token_valid?(request)
+        valid_token?(request.get_header(TOKEN_ENV_KEY))
+      end
+
+      # Logged once at boot when peers are configured without a usable token: every call to a
+      # peer is then refused.
+      def warn_about_configuration(logger)
+        return if Profiler.configuration.peers.to_a.empty?
+        return unless (problem = token_problem)
+
+        Profiler.log_warn("Peers: #{problem}: comparing profiles across nodes is refused. Generate one with " \
+                          "`ruby -rsecurerandom -e 'puts SecureRandom.hex(32)'` and give the same value to " \
+                          "every instance.", logger: logger)
+      end
+
+      def reset!
+        @validated = nil
+      end
+
+      private
+
+      def validate!(list)
+        raise Profiler::Error, "config.peers must be an Array of { name:, url: }" unless list.is_a?(Array)
+
+        peers = list.each_with_index.map { |entry, index| build_peer(entry, index) }
+        duplicate = peers.map(&:name).tally.find { |_, count| count > 1 }
+        raise Profiler::Error, "config.peers: the name #{duplicate[0].inspect} is used twice" if duplicate
+
+        peers
+      end
+
+      def build_peer(entry, index)
+        unless entry.respond_to?(:to_h) && !entry.is_a?(Array)
+          raise Profiler::Error, "config.peers[#{index}] must be a Hash with :name and :url"
+        end
+
+        hash = entry.to_h.transform_keys(&:to_s)
+        name = hash["name"].to_s.strip
+        unless name.match?(/\A[A-Za-z0-9][A-Za-z0-9._-]{0,63}\z/) && name != LOCAL_NODE
+          raise Profiler::Error, "config.peers[#{index}]: name #{hash["name"].inspect} must be 1 to 64 letters, " \
+                                 "digits, dots, dashes or underscores, and cannot be #{LOCAL_NODE.inspect}"
+        end
+        if (reason = url_denial(hash["url"]))
+          raise Profiler::Error, "config.peers[#{index}] (#{name}): #{reason}"
+        end
+
+        Peer.new(name, Cluster::Security.normalized_url(hash["url"]).freeze)
+      end
+
+      # nil when the peer URL is acceptable: a plain http(s) URL, with HTTPS required unless the
+      # host is a loopback address or config.peer_allow_insecure_http is set.
+      def url_denial(url)
+        target = Cluster::Security.normalize(url)
+        return "#{url.inspect} is not a valid http(s) URL" unless target
+        return nil if target[:scheme] == "https" || Cluster::Security.loopback_host?(target[:host])
+        return nil if Profiler.configuration.peer_allow_insecure_http
+
+        "#{url} uses plain HTTP to a host that is not a loopback address: HTTPS is required " \
+          "(or set config.peer_allow_insecure_http = true)"
+      end
+    end
+  end
+end

data/lib/profiler/profile_comparison.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "peers"
+require_relative "peers/peer_proxy"
+require_relative "profile_diff"
+
+module Profiler
+  # Loads two profiles, each from this instance or from a peer of config.peers, and diffs them.
+  # The node is a name in config.peers (or blank / "local"); it is never a URL.
+  module ProfileComparison
+    NotFound = Class.new(Profiler::Error)
+
+    class << self
+      # Both nodes are resolved before any profile is read, so an unknown node fails
+      # without a single outgoing call.
+      def call(token_a, token_b, node_a: nil, node_b: nil)
+        sources = [node_a, node_b].map { |node| source_for(node) }
+        profile_a = sources[0].load(token_a)
+        profile_b = sources[1].load(token_b)
+
+        missing = []
+        missing << "Profile not found: #{token_a}#{on_node(node_a)}" unless profile_a
+        missing << "Profile not found: #{token_b}#{on_node(node_b)}" unless profile_b
+        raise NotFound, missing.join("\n") if missing.any?
+
+        ProfileDiff.new(profile_a, profile_b, node_a: label(node_a), node_b: label(node_b)).compute
+      end
+
+      private
+
+      def source_for(node)
+        Peers.local?(node) ? Profiler.storage : Peers::PeerProxy.new(node)
+      end
+
+      def label(node)
+        Peers.local?(node) ? Peers::LOCAL_NODE : node.to_s
+      end
+
+      def on_node(node)
+        Peers.local?(node) ? "" : " (node #{node})"
+      end
+    end
+  end
+end

data/lib/profiler/profile_diff.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+require_relative "mcp/resources/n1_patterns"
+
+module Profiler
+  class ProfileDiff
+    # A query is "slower" when its total time per fingerprint grew by more than this share.
+    SLOWER_THRESHOLD_PCT = 20
+    MAX_QUERIES_PER_BLOCK = 25
+
+    attr_reader :profile_a, :profile_b
+
+    def initialize(profile_a, profile_b, node_a: nil, node_b: nil)
+      @profile_a = profile_a
+      @profile_b = profile_b
+      @node_a = node_a
+      @node_b = node_b
+    end
+
+    def same_endpoint?
+      profile_a.path == profile_b.path && profile_a.method == profile_b.method
+    end
+
+    def compute
+      {
+        profile_a: profile_summary(profile_a),
+        profile_b: profile_summary(profile_b),
+        same_endpoint: same_endpoint?,
+        metrics: compute_metrics,
+        sql: compare_sql,
+        collectors: {
+          database: compare_database,
+          cache: compare_cache,
+          views: compare_views,
+          http: compare_http
+        }
+      }
+    end
+
+    private
+
+    def compute_metrics
+      db_a = profile_a.collector_data("database") || {}
+      db_b = profile_b.collector_data("database") || {}
+      cache_a = profile_a.collector_data("cache") || {}
+      cache_b = profile_b.collector_data("cache") || {}
+      view_a = profile_a.collector_data("view") || {}
+      view_b = profile_b.collector_data("view") || {}
+      http_a = profile_a.collector_data("http") || {}
+      http_b = profile_b.collector_data("http") || {}
+
+      {
+        duration: metric_diff(
+          profile_a.duration, profile_b.duration, :lower,
+          threshold_pct: Profiler.configuration.regression_duration_threshold
+        ),
+        memory: metric_diff(
+          profile_a.memory, profile_b.memory, :lower,
+          threshold_pct: Profiler.configuration.regression_memory_threshold
+        ),
+        allocated_objects: metric_diff(
+          profile_a.allocated_objects, profile_b.allocated_objects, :lower,
+          threshold_pct: Profiler.configuration.regression_memory_threshold
+        ),
+        db_queries: metric_diff(
+          db_a["total_queries"], db_b["total_queries"], :lower,
+          threshold_pct: Profiler.configuration.regression_query_threshold
+        ),
+        db_duration: metric_diff(
+          db_a["total_duration"], db_b["total_duration"], :lower,
+          threshold_pct: Profiler.configuration.regression_duration_threshold
+        ),
+        cache_hit_rate: metric_diff(
+          cache_a["hit_rate"], cache_b["hit_rate"], :higher,
+          threshold_pct: Profiler.configuration.regression_cache_threshold
+        ),
+        view_duration: metric_diff(
+          view_a["total_duration"], view_b["total_duration"], :lower,
+          threshold_pct: Profiler.configuration.regression_duration_threshold
+        ),
+        http_requests: metric_diff(
+          http_a["total_requests"], http_b["total_requests"], :lower,
+          threshold_pct: 0
+        ),
+        http_duration: metric_diff(
+          http_a["total_duration"], http_b["total_duration"], :lower,
+          threshold_pct: Profiler.configuration.regression_duration_threshold
+        )
+      }
+    end
+
+    def metric_diff(val_a, val_b, direction, threshold_pct: 10)
+      return nil if val_a.nil? && val_b.nil?
+
+      a = val_a&.to_f
+      b = val_b&.to_f
+      delta = (b || 0) - (a || 0)
+      delta_pct = (a && a != 0) ? (delta / a * 100).round(1) : nil
+
+      status = compute_status(delta, delta_pct, direction, threshold_pct)
+
+      { value_a: val_a, value_b: val_b, delta: delta.round(4), delta_pct: delta_pct, status: status }
+    end
+
+    def compute_status(delta, delta_pct, direction, threshold_pct)
+      change_pct = delta_pct&.abs || 0
+
+      if delta == 0
+        :neutral
+      elsif change_pct <= threshold_pct
+        :neutral
+      elsif (direction == :lower && delta < 0) || (direction == :higher && delta > 0)
+        :improved
+      else
+        :regression
+      end
+    end
+
+    def profile_summary(profile)
+      {
+        token: profile.token,
+        node: node_for(profile),
+        path: profile.path,
+        method: profile.method,
+        status: profile.status,
+        duration: profile.duration,
+        memory: profile.memory,
+        allocated_objects: profile.allocated_objects,
+        started_at: profile.started_at,
+        profile_type: profile.profile_type
+      }
+    end
+
+    def node_for(profile)
+      profile.equal?(profile_a) ? @node_a : @node_b
+    end
+
+    # The queries of both profiles grouped by normalized statement: those only B runs (new),
+    # those only A ran (gone), and those whose total time grew past SLOWER_THRESHOLD_PCT.
+    def compare_sql
+      groups_a = sql_groups(profile_a)
+      groups_b = sql_groups(profile_b)
+
+      {
+        new: (groups_b.keys - groups_a.keys).map { |k| sql_entry(k, nil, groups_b[k]) }
+                                            .sort_by { |e| -e[:total_duration_b] }.first(MAX_QUERIES_PER_BLOCK),
+        gone: (groups_a.keys - groups_b.keys).map { |k| sql_entry(k, groups_a[k], nil) }
+                                             .sort_by { |e| -e[:total_duration_a] }.first(MAX_QUERIES_PER_BLOCK),
+        slower: slower_sql(groups_a, groups_b)
+      }
+    end
+
+    def slower_sql(groups_a, groups_b)
+      (groups_a.keys & groups_b.keys).filter_map do |key|
+        entry = sql_entry(key, groups_a[key], groups_b[key])
+        next unless entry[:total_duration_a].positive?
+
+        pct = ((entry[:total_duration_b] - entry[:total_duration_a]) / entry[:total_duration_a] * 100).round(1)
+        entry.merge(delta_pct: pct) if pct > SLOWER_THRESHOLD_PCT
+      end.sort_by { |e| -(e[:total_duration_b] - e[:total_duration_a]) }.first(MAX_QUERIES_PER_BLOCK)
+    end
+
+    def sql_groups(profile)
+      queries = (profile.collector_data("database") || {})["queries"] || []
+      queries.group_by { |q| MCP::Resources::N1Patterns.normalize_sql(q["sql"].to_s) }
+    end
+
+    def sql_entry(fingerprint, queries_a, queries_b)
+      {
+        fingerprint: fingerprint,
+        count_a: queries_a&.size || 0,
+        count_b: queries_b&.size || 0,
+        total_duration_a: sql_total(queries_a),
+        total_duration_b: sql_total(queries_b)
+      }
+    end
+
+    def sql_total(queries)
+      Array(queries).sum { |q| q["duration"].to_f }.round(2)
+    end
+
+    def compare_database
+      db_a = profile_a.collector_data("database") || {}
+      db_b = profile_b.collector_data("database") || {}
+
+      queries_a = db_a["queries"] || []
+      queries_b = db_b["queries"] || []
+
+      {
+        total_queries_a: db_a["total_queries"],
+        total_queries_b: db_b["total_queries"],
+        total_duration_a: db_a["total_duration"],
+        total_duration_b: db_b["total_duration"],
+        slow_queries_a: db_a["slow_queries"],
+        slow_queries_b: db_b["slow_queries"],
+        cached_queries_a: db_a["cached_queries"],
+        cached_queries_b: db_b["cached_queries"],
+        queries_a: queries_a.first(10),
+        queries_b: queries_b.first(10)
+      }
+    end
+
+    def compare_cache
+      cache_a = profile_a.collector_data("cache") || {}
+      cache_b = profile_b.collector_data("cache") || {}
+
+      {
+        total_reads_a: cache_a["total_reads"],
+        total_reads_b: cache_b["total_reads"],
+        total_writes_a: cache_a["total_writes"],
+        total_writes_b: cache_b["total_writes"],
+        hit_rate_a: cache_a["hit_rate"],
+        hit_rate_b: cache_b["hit_rate"]
+      }
+    end
+
+    def compare_views
+      view_a = profile_a.collector_data("view") || {}
+      view_b = profile_b.collector_data("view") || {}
+
+      {
+        total_views_a: view_a["total_views"],
+        total_views_b: view_b["total_views"],
+        views_a: rendered_templates(view_a),
+        views_b: rendered_templates(view_b),
+        total_partials_a: view_a["total_partials"],
+        total_partials_b: view_b["total_partials"],
+        total_duration_a: view_a["total_duration"],
+        total_duration_b: view_b["total_duration"]
+      }
+    end
+
+    def rendered_templates(view_data)
+      Array(view_data["views"]).map { |v| v["identifier"].to_s }.tally
+    end
+
+    def compare_http
+      http_a = profile_a.collector_data("http") || {}
+      http_b = profile_b.collector_data("http") || {}
+
+      {
+        total_requests_a: http_a["total_requests"],
+        total_requests_b: http_b["total_requests"],
+        total_duration_a: http_a["total_duration"],
+        total_duration_b: http_b["total_duration"],
+        slow_requests_a: http_a["slow_requests"],
+        slow_requests_b: http_b["slow_requests"],
+        error_requests_a: http_a["error_requests"],
+        error_requests_b: http_b["error_requests"]
+      }
+    end
+  end
+end

data/lib/profiler/railtie.rb

@@ -131,6 +131,8 @@ module Profiler
 
         require_relative "cluster/security"
         Profiler::Cluster::Security.warn_about_configuration(Rails.logger)
+        require_relative "peers"
+        Profiler::Peers.warn_about_configuration(Rails.logger)
         next unless Profiler.configuration.slave?
 
         require_relative "cluster/master_client"