rails_vitals 0.2.0

data/lib/rails_vitals/panel_renderer.rb

@@ -0,0 +1,233 @@
+# lib/rails_vitals/panel_renderer.rb
+module RailsVitals
+  class PanelRenderer
+    def self.render(collector, scorer)
+      new(collector, scorer).render
+    end
+
+    def initialize(collector, scorer)
+      @collector = collector
+      @scorer    = scorer
+    end
+
+    def render
+      <<~HTML
+        <div id="rails-vitals-panel" style="#{panel_styles}">
+          #{toggle_button}
+          #{collapsed_badge}
+          #{expanded_content}
+        </div>
+        #{inline_script}
+      HTML
+    end
+
+    private
+
+    # ─── PANEL WRAPPER ───────────────────────────────────────────
+
+    def panel_styles
+      "position:fixed;bottom:20px;right:20px;z-index:999999;font-family:monospace;font-size:12px;"
+    end
+
+    # ─── COLLAPSED STATE ─────────────────────────────────────────
+
+    def collapsed_badge
+      <<~HTML
+        <div id="rv-badge" style="
+          background:#{score_bg};
+          color:#fff;
+          padding:6px 12px;
+          border-radius:6px;
+          cursor:pointer;
+          display:flex;
+          align-items:center;
+          gap:8px;
+          box-shadow:0 2px 8px rgba(0,0,0,0.3);
+        " onclick="rvToggle()">
+          <span style="font-weight:bold;font-size:14px;">#{@scorer.score}</span>
+          <span style="opacity:0.85;">#{@scorer.label}</span>
+          <span style="opacity:0.6;font-size:10px;">▲</span>
+        </div>
+      HTML
+    end
+
+    def toggle_button; ""; end
+
+    # ─── EXPANDED STATE ───────────────────────────────────────────
+
+    def expanded_content
+      <<~HTML
+        <div id="rv-expanded" style="
+          display:none;
+          background:#1a1a2e;
+          color:#e2e8f0;
+          border-radius:8px;
+          padding:16px;
+          margin-bottom:8px;
+          width:380px;
+          box-shadow:0 4px 20px rgba(0,0,0,0.5);
+          border:1px solid #2d3748;
+        ">
+          #{header_section}
+          #{divider}
+          #{request_info_section}
+          #{divider}
+          #{query_summary_section}
+          #{divider}
+          #{slowest_queries_section}
+          #{divider}
+          #{admin_link_section}
+        </div>
+      HTML
+    end
+
+    # ─── SECTIONS ────────────────────────────────────────────────
+
+    def header_section
+      <<~HTML
+        <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:8px;">
+          <div>
+            <span style="font-size:28px;font-weight:bold;color:#{score_bg};">#{@scorer.score}</span>
+            <span style="font-size:13px;color:#a0aec0;margin-left:6px;">/ 100</span>
+          </div>
+          <div style="text-align:right;">
+            <div style="
+              background:#{score_bg};
+              color:#fff;
+              padding:3px 10px;
+              border-radius:4px;
+              font-size:11px;
+              font-weight:bold;
+            ">#{@scorer.label}</div>
+          </div>
+        </div>
+      HTML
+    end
+
+    def request_info_section
+      <<~HTML
+        <div style="margin-bottom:4px;">
+          #{label_row("Endpoint", "#{@collector.controller}##{@collector.action}")}
+          #{label_row("Method",   @collector.http_method.to_s.upcase)}
+          #{label_row("Status",   @collector.response_status.to_s)}
+          #{label_row("Duration", "#{@collector.duration_ms&.round(1)}ms")}
+        </div>
+      HTML
+    end
+
+    def query_summary_section
+      n_plus_one_count = n_plus_one_scorer.n_plus_one_patterns.size
+
+      <<~HTML
+        <div style="margin-bottom:4px;">
+          #{label_row("Queries",   @collector.total_query_count.to_s)}
+          #{label_row("DB Time",   "#{@collector.total_db_time_ms.round(1)}ms")}
+          #{label_row("N+1",       n_plus_one_badge(n_plus_one_count))}
+        </div>
+      HTML
+    end
+
+    def slowest_queries_section
+      queries = @collector.slowest_queries(5)
+      return "" if queries.empty?
+
+      rows = queries.map do |q|
+        sql     = truncate(q[:sql], 45)
+        time_ms = q[:duration_ms].round(1)
+        <<~HTML
+          <div style="margin-bottom:6px;">
+            <div style="color:#90cdf4;font-size:11px;">#{escape(sql)}</div>
+            <div style="color:#68d391;font-size:10px;">#{time_ms}ms</div>
+          </div>
+        HTML
+      end
+
+      <<~HTML
+        <div>
+          <div style="color:#a0aec0;font-size:10px;margin-bottom:6px;text-transform:uppercase;letter-spacing:0.05em;">
+            Slowest Queries
+          </div>
+          #{rows.join}
+        </div>
+      HTML
+    end
+
+    def admin_link_section
+      record = RailsVitals.store.all.last
+      return "" unless record
+
+      <<~HTML
+        <div style="text-align:right;margin-top:4px;">
+          <a href="/rails_vitals/requests/#{record.id}"
+            style="color:#90cdf4;font-size:11px;text-decoration:none;"
+            target="_blank">
+            View full report →
+          </a>
+        </div>
+      HTML
+    end
+
+    # ─── HELPERS ─────────────────────────────────────────────────
+
+    def divider
+      "<div style='border-top:1px solid #2d3748;margin:10px 0;'></div>"
+    end
+
+    def label_row(label, value)
+      <<~HTML
+        <div style="display:flex;justify-content:space-between;padding:2px 0;">
+          <span style="color:#a0aec0;">#{label}</span>
+          <span style="color:#e2e8f0;">#{value}</span>
+        </div>
+      HTML
+    end
+
+    def n_plus_one_badge(count)
+      return "<span style='color:#68d391;'>None</span>" if count.zero?
+
+      "<span style='background:#e53e3e;color:#fff;padding:1px 6px;border-radius:3px;font-size:10px;'>#{count} detected</span>"
+    end
+
+    def score_bg
+      case @scorer.color
+      when "green" then "#276749"
+      when "blue"  then "#2b6cb0"
+      when "amber" then "#b7791f"
+      else              "#c53030"
+      end
+    end
+
+    def n_plus_one_scorer
+      @n_plus_one_scorer ||= Scorers::NPlusOneScorer.new(@collector)
+    end
+
+    def truncate(str, length)
+      str.length > length ? "#{str[0, length]}…" : str
+    end
+
+    def escape(str)
+      str.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
+    end
+
+    # ─── JAVASCRIPT ──────────────────────────────────────────────
+
+    def inline_script
+      <<~HTML
+        <script>
+          function rvToggle() {
+            var expanded = document.getElementById('rv-expanded');
+            var badge    = document.getElementById('rv-badge');
+            var arrow    = badge.querySelector('span:last-child');
+            if (expanded.style.display === 'none') {
+              expanded.style.display = 'block';
+              arrow.textContent = '▼';
+            } else {
+              expanded.style.display = 'none';
+              arrow.textContent = '▲';
+            }
+          }
+        </script>
+      HTML
+    end
+  end
+end

data/lib/rails_vitals/request_record.rb

@@ -0,0 +1,51 @@
+module RailsVitals
+  class RequestRecord
+    attr_reader :id, :controller, :action, :http_method,
+                :response_status, :duration_ms, :score,
+                :label, :color, :queries, :n_plus_one_patterns,
+                :callbacks, :total_callback_time_ms, :recorded_at
+
+    def initialize(collector:, scorer:)
+      @id                  = SecureRandom.hex(8)
+      @controller          = collector.controller
+      @action              = collector.action
+      @http_method         = collector.http_method
+      @response_status     = collector.response_status
+      @duration_ms         = collector.duration_ms
+      @queries             = collector.queries
+      @callbacks           = collector.callbacks
+      @total_callback_time_ms = collector.total_callback_time_ms
+      @score               = scorer.score
+      @label               = scorer.label
+      @color               = scorer.color
+      @n_plus_one_patterns = build_n_plus_one_patterns(scorer)
+      @recorded_at         = Time.now
+    end
+
+    def endpoint
+      "#{@controller}##{@action}"
+    end
+
+    def total_query_count
+      @queries.size
+    end
+
+    def total_db_time_ms
+      @queries.sum { |q| q[:duration_ms] }
+    end
+
+    def slowest_queries(limit = 3)
+      @queries.sort_by { |q| -q[:duration_ms] }.first(limit)
+    end
+
+    private
+
+    def build_n_plus_one_patterns(scorer)
+      scorer_instance = scorer.is_a?(Scorers::CompositeScorer) ?
+        Scorers::NPlusOneScorer.new(scorer.instance_variable_get(:@collector)) :
+        nil
+
+      scorer_instance&.n_plus_one_patterns || {}
+    end
+  end
+end

data/lib/rails_vitals/scorers/base_scorer.rb

@@ -0,0 +1,25 @@
+module RailsVitals
+  module Scorers
+    class BaseScorer
+      HEALTHY    = (90..100)
+      ACCEPTABLE = (70..89)
+      WARNING    = (50..69)
+      CRITICAL   = (0..49)
+
+      def initialize(collector)
+        @collector = collector
+      end
+
+      # Returns a score between 0 and 100
+      def score
+        raise NotImplementedError, "#{self.class} must implement #score"
+      end
+
+      private
+
+      def clamp(value)
+        value.clamp(0, 100)
+      end
+    end
+  end
+end

data/lib/rails_vitals/scorers/composite_scorer.rb

@@ -0,0 +1,36 @@
+module RailsVitals
+  module Scorers
+    class CompositeScorer < BaseScorer
+      # Weights will grow as we add more scorers
+      WEIGHTS = {
+        query:      0.40,
+        n_plus_one: 0.60
+      }.freeze
+
+      def score
+        clamp(
+          (QueryScorer.new(@collector).score     * WEIGHTS[:query]).round +
+          (NPlusOneScorer.new(@collector).score  * WEIGHTS[:n_plus_one]).round
+        )
+      end
+
+      def label
+        case score
+        when BaseScorer::HEALTHY    then "Healthy"
+        when BaseScorer::ACCEPTABLE then "Acceptable"
+        when BaseScorer::WARNING    then "Warning"
+        else                             "Critical"
+        end
+      end
+
+      def color
+        case score
+        when BaseScorer::HEALTHY    then "green"
+        when BaseScorer::ACCEPTABLE then "blue"
+        when BaseScorer::WARNING    then "amber"
+        else                             "red"
+        end
+      end
+    end
+  end
+end

data/lib/rails_vitals/scorers/n_plus_one_scorer.rb

@@ -0,0 +1,43 @@
+module RailsVitals
+  module Scorers
+    class NPlusOneScorer < BaseScorer
+      # Minimum times the same query must repeat to be flagged
+      REPEAT_THRESHOLD = 3
+
+      def score
+        return 100 if n_plus_one_count.zero?
+
+        # Each N+1 pattern costs 25 points, floored at 0
+        clamp(100 - (n_plus_one_count * 25))
+      end
+
+      def n_plus_one_patterns
+        query_fingerprints
+          .select { |_fingerprint, count| count >= REPEAT_THRESHOLD }
+      end
+
+      private
+
+      def n_plus_one_count
+        n_plus_one_patterns.size
+      end
+
+      def query_fingerprints
+        @collector.queries
+          .select { |q| q.is_a?(Hash) && q[:sql].is_a?(String) }
+          .map { |q| normalize(q[:sql]) }
+          .tally
+      end
+
+      # Strip values to compare query structure, not data
+      def normalize(sql)
+        sql
+          .gsub(/\d+/, "?")
+          .gsub(/'[^']*'/, "?")
+          .gsub(/\s+/, " ")
+          .strip
+          .downcase
+      end
+    end
+  end
+end

data/lib/rails_vitals/scorers/query_scorer.rb

@@ -0,0 +1,42 @@
+module RailsVitals
+  module Scorers
+    class QueryScorer < BaseScorer
+      def score
+        clamp(count_score + time_score)
+      end
+
+      private
+
+      def count_score
+        count = @collector.total_query_count
+        warn_threshold     = RailsVitals.config.query_warn_threshold
+        critical_threshold = RailsVitals.config.query_critical_threshold
+
+        if count <= warn_threshold
+          50  # full points
+        elsif count <= critical_threshold
+          # linear decay between warn and critical
+          ratio = (count - warn_threshold).to_f / (critical_threshold - warn_threshold)
+          (50 * (1 - ratio)).round
+        else
+          0
+        end
+      end
+
+      def time_score
+        time_ms    = @collector.total_db_time_ms
+        warn_ms    = RailsVitals.config.db_time_warn_ms
+        critical_ms = RailsVitals.config.db_time_critical_ms
+
+        if time_ms <= warn_ms
+          50
+        elsif time_ms <= critical_ms
+          ratio = (time_ms - warn_ms).to_f / (critical_ms - warn_ms)
+          (50 * (1 - ratio)).round
+        else
+          0
+        end
+      end
+    end
+  end
+end

data/lib/rails_vitals/store.rb

@@ -0,0 +1,34 @@
+module RailsVitals
+  class Store
+    def initialize(size)
+      @size    = size
+      @records = []
+      @mutex   = Mutex.new
+    end
+
+    def push(record)
+      @mutex.synchronize do
+        @records.push(record)
+        @records.shift if @records.size > @size
+      end
+    end
+
+    def all
+      @mutex.synchronize { @records.dup }
+    end
+
+    def find(id)
+      @mutex.synchronize do
+        @records.find { |r| r.id == id }
+      end
+    end
+
+    def clear
+      @mutex.synchronize { @records.clear }
+    end
+
+    def size
+      @mutex.synchronize { @records.size }
+    end
+  end
+end

data/lib/rails_vitals/version.rb

@@ -0,0 +1,3 @@
+module RailsVitals
+  VERSION = "0.2.0"
+end

data/lib/rails_vitals.rb

@@ -0,0 +1,33 @@
+require "rails_vitals/version"
+require "rails_vitals/configuration"
+require "rails_vitals/store"
+require "rails_vitals/collector"
+require "rails_vitals/request_record"
+require "rails_vitals/notifications/subscriber"
+require "rails_vitals/instrumentation/callback_instrumentation"
+require "rails_vitals/analyzers/n_plus_one_aggregator"
+require "rails_vitals/analyzers/sql_tokenizer"
+require "rails_vitals/analyzers/association_mapper"
+require "rails_vitals/scorers/base_scorer"
+require "rails_vitals/scorers/query_scorer"
+require "rails_vitals/scorers/n_plus_one_scorer"
+require "rails_vitals/scorers/composite_scorer"
+require "rails_vitals/panel_renderer"
+require "rails_vitals/middleware/panel_injector"
+require "rails_vitals/engine"
+
+module RailsVitals
+  class << self
+    def configure
+      yield config
+    end
+
+    def config
+      @config ||= Configuration.new
+    end
+
+    def store
+      @store ||= Store.new(config.store_size)
+    end
+  end
+end

data/lib/tasks/rails_vitals_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :rails_vitals do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: rails_vitals
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- David Sanchez
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.1.2
+description: RailsVitals is a lightweight Rails engine gem that makes the hidden runtime
+  behavior of a Rails application visible, measurable, and teachable. It provides
+  insights into the inner workings of a Rails app, helping developers understand and
+  optimize their code. With RailsVitals, you can easily identify performance bottlenecks,
+  track database queries, and gain a deeper understanding of how your application
+  operates under the hood.
+email:
+- sanchez.dav90@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/stylesheets/rails_vitals/application.css
+- app/controllers/rails_vitals/application_controller.rb
+- app/controllers/rails_vitals/associations_controller.rb
+- app/controllers/rails_vitals/dashboard_controller.rb
+- app/controllers/rails_vitals/heatmap_controller.rb
+- app/controllers/rails_vitals/models_controller.rb
+- app/controllers/rails_vitals/n_plus_ones_controller.rb
+- app/controllers/rails_vitals/requests_controller.rb
+- app/helpers/rails_vitals/application_helper.rb
+- app/jobs/rails_vitals/application_job.rb
+- app/mailers/rails_vitals/application_mailer.rb
+- app/models/rails_vitals/application_record.rb
+- app/views/layouts/rails_vitals/application.html.erb
+- app/views/rails_vitals/associations/index.html.erb
+- app/views/rails_vitals/dashboard/index.html.erb
+- app/views/rails_vitals/heatmap/index.html.erb
+- app/views/rails_vitals/models/index.html.erb
+- app/views/rails_vitals/n_plus_ones/index.html.erb
+- app/views/rails_vitals/n_plus_ones/show.html.erb
+- app/views/rails_vitals/requests/index.html.erb
+- app/views/rails_vitals/requests/show.html.erb
+- config/routes.rb
+- lib/rails_vitals.rb
+- lib/rails_vitals/analyzers/association_mapper.rb
+- lib/rails_vitals/analyzers/n_plus_one_aggregator.rb
+- lib/rails_vitals/analyzers/sql_tokenizer.rb
+- lib/rails_vitals/collector.rb
+- lib/rails_vitals/configuration.rb
+- lib/rails_vitals/engine.rb
+- lib/rails_vitals/instrumentation/callback_instrumentation.rb
+- lib/rails_vitals/middleware/panel_injector.rb
+- lib/rails_vitals/notifications/subscriber.rb
+- lib/rails_vitals/panel_renderer.rb
+- lib/rails_vitals/request_record.rb
+- lib/rails_vitals/scorers/base_scorer.rb
+- lib/rails_vitals/scorers/composite_scorer.rb
+- lib/rails_vitals/scorers/n_plus_one_scorer.rb
+- lib/rails_vitals/scorers/query_scorer.rb
+- lib/rails_vitals/store.rb
+- lib/rails_vitals/version.rb
+- lib/tasks/rails_vitals_tasks.rake
+homepage: https://github.com/Sanchezdav/rails_vitals
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Sanchezdav/rails_vitals
+  source_code_uri: https://github.com/Sanchezdav/rails_vitals/tree/main
+  changelog_uri: https://github.com/Sanchezdav/rails_vitals/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: RailsVitals is a lightweight Rails engine gem that makes the hidden runtime
+  behavior of a Rails application visible, measurable, and teachable.
+test_files: []