and_one 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ee084901a4915dba0065a11cf14a6996f277d6ca5fba2efd388b27ddc2f349a
-  data.tar.gz: 05d02c49d473359e70ba9b300711e6d15f52d391ab48e22ca1ddb8651e3eb7bc
+  metadata.gz: 51b6c654539d7d462eee3fa1f498e12c67d083032532f70e9068357aaf720813
+  data.tar.gz: 9fbd318564ff10362c9e7f24bed9f05654a4db1cb19b2b6f80e76fe7748ec380
 SHA512:
-  metadata.gz: 5f59a82aac0fc38ef5f9d2d11b633a1b881378124834d8d8ec0dd4ecb85e887d16aec5feee30225205df60ab90cb1577eb02ebca0306685736231faad0e53799
-  data.tar.gz: '0663708679e397440e6e1fe26bee567e868e1909e1138cfb94d3da085cabdc4da8808005f72a610aa6f99fde5f262ffead6ff57bd4bc21e0b685c9c07195df0b'
+  metadata.gz: e616668cf8527dd81bdf5d31ab89974ba651a8cdb587f8ff33e5a71fbdae9077474d28da036fc4689ab01fe10a4b7814006c54f25026356606245733c75fab95
+  data.tar.gz: e4efa724ed029637706a90007a8e4f16005e15c4278c79fb7d6e1dec4a2c2d8bdab03c6b21ae3da9378b53795e7e4aaa39704bdab878880506e021ecfc075edb

data/.githooks/pre-commit

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -e
+
+# Get staged Ruby files
+STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep '\.rb$' || true)
+
+if [ -n "$STAGED_FILES" ]; then
+  echo "Running RuboCop on staged files..."
+  bundle exec rubocop --force-exclusion $STAGED_FILES
+fi

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 ## [Unreleased]
 
+## [0.3.0] - 2026-03-05
+
+### Removed
+
+- **`aggregate_mode` configuration option** — Deduplication and aggregate tracking are now always-on when AndOne is enabled. The dev toast and dashboard both depend on the aggregate, so having it off was a bug in disguise (detections would show in the toast but never appear on the dashboard). If you had `AndOne.aggregate_mode = true` in an initializer, simply remove the line.
+
+### Fixed
+
+- N+1 detections now always appear on the `/__and_one` dashboard. Previously, detections would show in the toast notification but not on the dashboard unless `aggregate_mode` was explicitly enabled.
+
+## [0.2.0] - 2026-03-02
+
+### Added
+
+- **Dev toast notifications** — When an N+1 is detected during a request, a toast notification is injected into the bottom-right corner of the page showing which tables were affected with a link to the `/__and_one` dashboard. Enabled by default in development. Auto-dismisses after 8 seconds; hover to keep open. Only appears on HTML 200 responses. Disable with `AndOne.dev_toast = false`.
+- New `dev_toast` configuration option
+- "Development UI" section in README documenting both the toast and dashboard features
+
 ## [0.1.0] - 2026-02-27
 
 - Initial release

data/README.md

@@ -14,8 +14,9 @@ AndOne stays completely invisible until it detects an N+1 query — then it tell
 - **Auto-raises in test** — N+1s fail your test suite by default
 - **Background job support** — ActiveJob (`around_perform`) and Sidekiq server middleware, with double-scan protection
 - **Ignore file** — `.and_one_ignore` with `gem:`, `path:`, `query:`, and `fingerprint:` rules
-- **Aggregate mode** — report each unique N+1 once per server session with occurrence counts
+- **Automatic deduplication** — each unique N+1 is reported once per server session with occurrence counts
 - **Test matchers** — Minitest (`assert_no_n_plus_one`) and RSpec (`expect { }.not_to cause_n_plus_one`)
+- **Dev toast notifications** — in-page toast on every page that triggers an N+1, with a link to the dashboard
 - **Dev UI dashboard** — browse `/__and_one` in development for a live N+1 overview
 - **Rails console integration** — auto-scans in `rails console` and prints warnings inline
 - **Structured JSON logging** — JSON output mode for Datadog, Splunk, and other log aggregation services
@@ -131,14 +132,9 @@ This is especially useful for **N+1s coming from gems** where you can't add `.in
 | `query:some_table` | A specific query pattern should always be ignored |
 | `fingerprint:abc123` | You want to silence one specific detection (shown in output) |
 
-## Aggregate Mode
+## Deduplication
 
-In development, the same N+1 can fire on every request, flooding your logs. Aggregate mode reports each unique pattern only once per server session:
-
-```ruby
-# config/initializers/and_one.rb
-AndOne.aggregate_mode = true
-```
+In development, the same N+1 can fire on every request, flooding your logs. AndOne automatically deduplicates — each unique pattern is reported only once per server session. Subsequent occurrences are silently counted.
 
 You can check the session summary at any time:
 
@@ -148,6 +144,29 @@ AndOne.aggregate.size       # number of unique patterns
 AndOne.aggregate.reset!     # clear and start fresh
 ```
 
+## Development UI
+
+### In-page toast notifications
+
+When an N+1 is detected during a request, AndOne injects a small toast notification into the bottom-right corner of the page. The toast shows which tables were affected and links to the full dashboard for details.
+
+This is enabled by default in development — no configuration needed. The toast auto-dismisses after 8 seconds, but hovering over it keeps it open.
+
+To disable it:
+
+```ruby
+# config/initializers/and_one.rb
+AndOne.dev_toast = false
+```
+
+The toast only appears on HTML responses with a 200 status, so it won't interfere with API endpoints, redirects, or error pages.
+
+### Dashboard
+
+Browse `/__and_one` in development for a full overview of every unique N+1 detected in the current server session. The dashboard shows the query, origin, fix location, and suggested `.includes()` call for each detection.
+
+Both features work together: the toast gives you immediate feedback on the page you're looking at, and the dashboard link takes you to the full picture.
+
 ## Test Matchers
 
 ### Minitest
@@ -214,8 +233,8 @@ AndOne.configure do |config|
   # Minimum repeated queries to trigger (default: 2)
   config.min_n_queries = 3
 
-  # Aggregate mode — only report each unique N+1 once per session
-  config.aggregate_mode = true
+  # In-page toast notifications (default: true in development)
+  config.dev_toast = true
 
   # Path to ignore file (default: Rails.root/.and_one_ignore)
   config.ignore_file_path = Rails.root.join(".and_one_ignore").to_s

data/lib/and_one/active_job_hook.rb

@@ -18,8 +18,8 @@ module AndOne
 
     private
 
-    def and_one_scan
-      and_one_wrap { yield }
+    def and_one_scan(&)
+      and_one_wrap(&)
     end
   end
 end

data/lib/and_one/aggregate.rb

@@ -2,19 +2,16 @@
 
 module AndOne
   # Tracks unique N+1 detections across requests/jobs in a server session.
-  # In aggregate mode, each unique N+1 (by fingerprint) is only reported once.
+  # Each unique N+1 (by fingerprint) is only reported once.
   # Subsequent occurrences are silently counted.
   #
-  # Usage:
-  #   AndOne.aggregate_mode = true
-  #
   # The aggregate can be queried at any time:
   #   AndOne.aggregate.summary   # => formatted string
   #   AndOne.aggregate.detections # => { fingerprint => { detection:, count:, first_seen_at: } }
   #   AndOne.aggregate.reset!
   #
   class Aggregate
-    Entry = Struct.new(:detection, :occurrences, :first_seen_at, :last_seen_at, keyword_init: true)
+    Entry = Struct.new(:detection, :occurrences, :first_seen_at, :last_seen_at)
 
     def initialize
       @mutex = Mutex.new
@@ -65,19 +62,19 @@ module AndOne
 
         lines = []
         lines << ""
-        lines << "🏀 AndOne Session Summary: #{@entries.size} unique N+1 pattern#{'s' if @entries.size != 1}"
-        lines << "─" * 60
+        lines << "🏀 AndOne Session Summary: #{@entries.size} unique N+1 pattern#{"s" if @entries.size != 1}"
+        lines << ("─" * 60)
 
         @entries.each_with_index do |(fp, entry), i|
           det = entry.detection
-          lines << "  #{i + 1}) #{det.table_name || 'unknown'} — #{entry.occurrences} occurrence#{'s' if entry.occurrences != 1}"
+          lines << "  #{i + 1}) #{det.table_name || "unknown"} — #{entry.occurrences} occurrence#{"s" if entry.occurrences != 1}"
           lines << "     #{det.sample_query[0, 120]}"
           lines << "     origin: #{det.origin_frame}" if det.origin_frame
           lines << "     fingerprint: #{fp}"
           lines << ""
         end
 
-        lines << "─" * 60
+        lines << ("─" * 60)
         lines.join("\n")
       end
     end

data/lib/and_one/association_resolver.rb

@@ -50,7 +50,7 @@ module AndOne
 
         model = ActiveRecord::Base.descendants.detect do |klass|
           klass.table_name == table_name
-        rescue
+        rescue StandardError
           false
         end
 
@@ -82,11 +82,11 @@ module AndOne
 
         klass.reflect_on_all_associations.each do |assoc|
           matched = if effective_key
-            association_matches?(assoc, target_model, effective_key)
-          else
-            # For through associations, foreign key may not be directly visible
-            through_association_matches?(assoc, target_model)
-          end
+                      association_matches?(assoc, target_model, effective_key)
+                    else
+                      # For through associations, foreign key may not be directly visible
+                      through_association_matches?(assoc, target_model)
+                    end
 
           next unless matched
 
@@ -98,10 +98,10 @@ module AndOne
             fix_hint: build_fix_hint(klass, assoc.name),
             loading_strategy: strategy,
             is_through: assoc.is_a?(ActiveRecord::Reflection::ThroughReflection),
-            is_polymorphic: assoc.respond_to?(:options) && !!assoc.options[:as]
+            is_polymorphic: assoc.respond_to?(:options) && !assoc.options[:as].nil?
           }
         end
-      rescue
+      rescue StandardError
         next
       end
 
@@ -133,27 +133,25 @@ module AndOne
     end
 
     def association_matches?(assoc, target_model, foreign_key)
-      begin
-        case assoc
-        when ActiveRecord::Reflection::ThroughReflection
-          # has_many :through — check if the source association points to our target
-          assoc.klass == target_model
-        when ActiveRecord::Reflection::HasManyReflection,
-             ActiveRecord::Reflection::HasOneReflection
-          if assoc.options[:as]
-            # Polymorphic: has_many :comments, as: :commentable
-            # The foreign key is like "commentable_id" and there's a "commentable_type" column
-            poly_fk = "#{assoc.options[:as]}_id"
-            assoc.klass == target_model && poly_fk == foreign_key
-          else
-            assoc.klass == target_model && assoc.foreign_key.to_s == foreign_key
-          end
+      case assoc
+      when ActiveRecord::Reflection::ThroughReflection
+        # has_many :through — check if the source association points to our target
+        assoc.klass == target_model
+      when ActiveRecord::Reflection::HasManyReflection,
+           ActiveRecord::Reflection::HasOneReflection
+        if assoc.options[:as]
+          # Polymorphic: has_many :comments, as: :commentable
+          # The foreign key is like "commentable_id" and there's a "commentable_type" column
+          poly_fk = "#{assoc.options[:as]}_id"
+          assoc.klass == target_model && poly_fk == foreign_key
         else
-          false
+          assoc.klass == target_model && assoc.foreign_key.to_s == foreign_key
         end
-      rescue NameError
+      else
         false
       end
+    rescue NameError
+      false
     end
 
     def build_fix_hint(parent_model, association_name)
@@ -161,13 +159,10 @@ module AndOne
     end
 
     # Determine the optimal loading strategy based on query patterns
-    def loading_strategy(sql, association_name)
+    def loading_strategy(sql, _association_name)
       # If the query has WHERE conditions on the association table, eager_load
       # is better because it does a LEFT OUTER JOIN allowing WHERE filtering
-      if sql =~ /\bWHERE\b/i && sql =~ /\bJOIN\b/i
-        :eager_load
-      elsif sql =~ /\bWHERE\b.*\b(?:AND|OR)\b/i
-        # Complex WHERE — eager_load with JOIN is more efficient
+      if sql =~ /\bWHERE\b/i && (sql =~ /\bJOIN\b/i || sql =~ /\b(?:AND|OR)\b/i)
         :eager_load
       else
         # Default: preload is generally faster (separate queries, no JOIN overhead)
@@ -202,10 +197,10 @@ module AndOne
       return nil unless actionable? && @parent_model
 
       assoc_type = if @is_through
-        "has_many :#{@association_name}, through: ..."
-      else
-        "has_many :#{@association_name}"
-      end
+                     "has_many :#{@association_name}, through: ..."
+                   else
+                     "has_many :#{@association_name}"
+                   end
 
       "Or prevent at the model level: `#{assoc_type}, strict_loading: true` in #{@parent_model.name}"
     end
@@ -219,8 +214,6 @@ module AndOne
         "Consider `.eager_load(:#{@association_name})` instead — your query filters on the association, so a JOIN is more efficient"
       when :preload
         "Consider `.preload(:#{@association_name})` — separate queries avoid JOIN overhead for simple loading"
-      else
-        nil # :includes is the default, no extra hint needed
       end
     end
   end

data/lib/and_one/console.rb

@@ -49,7 +49,7 @@ module AndOne
 
       def finish_scan
         AndOne.finish if AndOne.scanning?
-      rescue
+      rescue StandardError
         # Don't let cleanup errors interrupt the console
         nil
       end
@@ -79,9 +79,9 @@ module AndOne
 
         # IRB in Rails 7.1+ uses IRB::Context#evaluate with hooks
         # We hook into the SIGINT-safe eval output via an around_eval approach
-        if defined?(::IRB::Context)
-          ::IRB::Context.prepend(IrbContextPatch)
-        end
+        return unless defined?(::IRB::Context)
+
+        ::IRB::Context.prepend(IrbContextPatch)
       end
 
       def remove_irb_hook
@@ -94,15 +94,13 @@ module AndOne
 
         @pry_hook_installed = true
 
-        ::Pry.hooks.add_hook(:after_eval, :and_one_console) do |result, _pry|
+        ::Pry.hooks.add_hook(:after_eval, :and_one_console) do |_result, _pry|
           AndOne::Console.send(:cycle_scan) if AndOne::Console.active?
         end
       end
 
       def remove_pry_hook
-        if defined?(::Pry) && ::Pry.hooks
-          ::Pry.hooks.delete_hook(:after_eval, :and_one_console)
-        end
+        ::Pry.hooks.delete_hook(:after_eval, :and_one_console) if defined?(::Pry) && ::Pry.hooks
         @pry_hook_installed = false
       end
 
@@ -119,7 +117,7 @@ module AndOne
         result = super
         AndOne::Console.send(:cycle_scan) if AndOne::Console.active?
         result
-      rescue => e
+      rescue StandardError
         AndOne::Console.send(:cycle_scan) if AndOne::Console.active?
         raise
       end

data/lib/and_one/detection.rb

@@ -55,9 +55,9 @@ module AndOne
     private
 
     def extract_table_name(sql)
-      if sql =~ /\bFROM\s+["`]?(\w+)["`]?/i
-        $1
-      end
+      return unless sql =~ /\bFROM\s+["`]?(\w+)["`]?/i
+
+      ::Regexp.last_match(1)
     end
 
     def find_origin_frame

data/lib/and_one/detector.rb

@@ -5,8 +5,8 @@ module AndOne
   # Each instance tracks queries for a single request/block scope.
   class Detector
     DEFAULT_ALLOW_LIST = [
-      /active_record\/relation.*preload_associations/,
-      /active_record\/validations\/uniqueness/
+      %r{active_record/relation.*preload_associations},
+      %r{active_record/validations/uniqueness}
     ].freeze
 
     attr_reader :detections
@@ -58,7 +58,7 @@ module AndOne
         name = payload[:name]
 
         next if name == "SCHEMA"
-        next if !sql.include?("SELECT")
+        next unless sql.include?("SELECT")
         next if payload[:cached]
         next if current_detector.send(:ignored?, sql)
 
@@ -79,13 +79,13 @@ module AndOne
       @query_holder[location_key] << sql
 
       # Only store caller on the second occurrence to save memory
-      if @query_counter[location_key] >= 2
-        @query_callers[location_key] = locations
-        @query_metadata[location_key] ||= {
-          connection_adapter: adapter_name,
-          type_casted_binds: payload[:type_casted_binds]
-        }
-      end
+      return unless @query_counter[location_key] >= 2
+
+      @query_callers[location_key] = locations
+      @query_metadata[location_key] ||= {
+        connection_adapter: adapter_name,
+        type_casted_binds: payload[:type_casted_binds]
+      }
     end
 
     def location_fingerprint(locations)
@@ -99,7 +99,7 @@ module AndOne
 
     def adapter_name
       ActiveRecord::Base.connection_db_config.adapter
-    rescue
+    rescue StandardError
       "unknown"
     end
 
@@ -135,7 +135,7 @@ module AndOne
     end
 
     def ignored?(sql)
-      @ignore_queries.any? { |pattern| pattern === sql }
+      @ignore_queries.any? { |pattern| pattern.match?(sql) }
     end
   end
 end

data/lib/and_one/dev_toast.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module AndOne
+  # Injects a small toast notification into HTML responses when N+1 queries
+  # are detected during the request. Links to the DevUI dashboard for details.
+  #
+  # Activated automatically by the Railtie in development when `dev_toast` is on,
+  # or can be enabled manually:
+  #   AndOne.dev_toast = true
+  #
+  # The toast appears as a fixed-position badge in the bottom-right corner
+  # and auto-dismisses after 8 seconds (click to keep open).
+  module DevToast
+    module_function
+
+    # Injects toast HTML/JS/CSS before </body> in an HTML response.
+    # Returns the modified body string, or the original if not injectable.
+    def inject(body_string, detections)
+      return body_string if detections.nil? || detections.empty?
+      return body_string unless body_string.include?("</body>")
+
+      toast_html = render_toast(detections)
+      body_string.sub("</body>", "#{toast_html}\n</body>")
+    end
+
+    def render_toast(detections)
+      count = detections.size
+      label = "N+1 quer#{count == 1 ? "y" : "ies"}"
+
+      summaries = detections.map do |d|
+        table = escape(d.table_name || "unknown")
+        "#{d.count}x <code>#{table}</code>"
+      end.first(5)
+
+      extra = count > 5 ? "<div class=\"and-one-toast-extra\">...and #{count - 5} more</div>" : ""
+
+      <<~HTML
+        <div id="and-one-toast" class="and-one-toast" role="status" aria-live="polite">
+          <div class="and-one-toast-header">
+            <span class="and-one-toast-icon">🏀</span>
+            <strong>AndOne:</strong> #{count} #{label} detected
+            <button class="and-one-toast-close" onclick="document.getElementById('and-one-toast').remove()" aria-label="Dismiss">&times;</button>
+          </div>
+          <div class="and-one-toast-body">
+            #{summaries.join("<br>")}
+            #{extra}
+          </div>
+          <a class="and-one-toast-link" href="#{DevUI::MOUNT_PATH}">View Dashboard →</a>
+        </div>
+        <style>
+          .and-one-toast {
+            position: fixed;
+            bottom: 1rem;
+            right: 1rem;
+            z-index: 999999;
+            background: #1a1a2e;
+            color: #e0e0e0;
+            border: 2px solid #ff6b6b;
+            border-radius: 8px;
+            padding: 0;
+            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, monospace;
+            font-size: 13px;
+            max-width: 380px;
+            min-width: 260px;
+            box-shadow: 0 4px 24px rgba(0,0,0,0.4);
+            animation: and-one-slide-in 0.3s ease-out;
+            transition: opacity 0.3s ease;
+          }
+          .and-one-toast-header {
+            display: flex;
+            align-items: center;
+            gap: 0.4rem;
+            padding: 0.5rem 0.75rem;
+            background: #16213e;
+            border-radius: 6px 6px 0 0;
+            border-bottom: 1px solid #2a2a4a;
+            color: #ff6b6b;
+            font-size: 13px;
+          }
+          .and-one-toast-icon { font-size: 16px; }
+          .and-one-toast-close {
+            margin-left: auto;
+            background: none;
+            border: none;
+            color: #888;
+            font-size: 18px;
+            cursor: pointer;
+            padding: 0 0.25rem;
+            line-height: 1;
+          }
+          .and-one-toast-close:hover { color: #ff6b6b; }
+          .and-one-toast-body {
+            padding: 0.5rem 0.75rem;
+            line-height: 1.5;
+            color: #ccc;
+          }
+          .and-one-toast-body code {
+            background: #16213e;
+            padding: 0.1rem 0.3rem;
+            border-radius: 3px;
+            font-size: 12px;
+            color: #ffd93d;
+          }
+          .and-one-toast-extra {
+            color: #888;
+            font-size: 12px;
+            margin-top: 0.25rem;
+          }
+          .and-one-toast-link {
+            display: block;
+            padding: 0.5rem 0.75rem;
+            color: #a8d8ea;
+            text-decoration: none;
+            font-size: 12px;
+            border-top: 1px solid #2a2a4a;
+          }
+          .and-one-toast-link:hover {
+            background: #16213e;
+            border-radius: 0 0 6px 6px;
+            text-decoration: underline;
+          }
+          @keyframes and-one-slide-in {
+            from { transform: translateY(1rem); opacity: 0; }
+            to   { transform: translateY(0);    opacity: 1; }
+          }
+        </style>
+        <script>
+          (function() {
+            var toast = document.getElementById('and-one-toast');
+            if (!toast) return;
+            var timer = setTimeout(function() {
+              toast.style.opacity = '0';
+              setTimeout(function() { toast.remove(); }, 300);
+            }, 8000);
+            toast.addEventListener('mouseenter', function() { clearTimeout(timer); });
+          })();
+        </script>
+      HTML
+    end
+
+    def escape(text)
+      text.to_s
+          .gsub("&", "&amp;")
+          .gsub("<", "&lt;")
+          .gsub(">", "&gt;")
+          .gsub('"', "&quot;")
+    end
+  end
+end