query_owl 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45b067e5caa42b01df6cb84cce7541b77ee9bbee1f9f6d919ed554fb2386fd0e
-  data.tar.gz: 688d0b4f41edcf13e99bad7dbe6a4bdfe8ad40d458f908a06c2bc87b8ccbdbea
+  metadata.gz: 5db617fa85bce1a43d851809139bd43015afd92263bd203ac0114921dd94c525
+  data.tar.gz: 4ebf287c62f2779448c2277d416147d7b426332a2dd927f6a1a8485498c76638
 SHA512:
-  metadata.gz: 960d4332a40bd8531ccdda7b06d8e6a947b048c3c5f758fba374e62759668bbe43ae335e7d5dc4fc394785e2ea5fa6e13e1f7f8ca9c4e6f035f52b380815c982
-  data.tar.gz: 1764fbd57f9359a30866c2665a5698ede5bd4764fab90f10afa7984451086cc1d51fd8bf933828bfdff14a87631c753824b8cff7cd225a1474ca41b9efd5a0f3
+  metadata.gz: e3ec2642c611837a83dc96fdf8fc7eb669a99c6ae140fc3ad5bb1439a5b2db4349a9038a87a4af8e61fe1156e2d6fcbe43535641a2c51dd3bbcc41f9652ec88c
+  data.tar.gz: 2b2fe57db0a34c3289ef76a6170c4ea0d36d441eb733571ce87d8b506e1772b54d1e63841a8719d009a7ffd52a708b8ce5ad19c36e22839ceb3d33111700ae8b

data/README.md

@@ -6,7 +6,7 @@
 [![Ruby](https://img.shields.io/badge/ruby-%3E%3D%203.3-ruby)](https://www.ruby-lang.org)
 [![codecov](https://codecov.io/gh/eclectic-coding/query_owl/branch/main/graph/badge.svg)](https://codecov.io/gh/eclectic-coding/query_owl)
 
-A leaner alternative to Bullet. QueryOwl detects N+1 queries and slow queries in development, logging structured warnings to your Rails logger — without the noise.
+A leaner alternative to Bullet. QueryOwl detects N+1 queries, slow queries, and unused eager loads in development, logging structured warnings to your Rails logger — without the noise.
 
 ## Table of Contents
 
@@ -14,6 +14,7 @@ A leaner alternative to Bullet. QueryOwl detects N+1 queries and slow queries in
 - [Installation](#installation)
 - [Configuration](#configuration)
 - [Log Output](#log-output)
+- [Dashboard Endpoint](#dashboard-endpoint)
 - [Manual Testing in the Dummy App](#manual-testing-in-the-dummy-app)
 - [Roadmap](#roadmap)
 - [Contributing](#contributing)
@@ -25,6 +26,9 @@ A leaner alternative to Bullet. QueryOwl detects N+1 queries and slow queries in
 
 - **N+1 detection** — flags when the same SQL pattern fires 2+ times in a single request
 - **Slow query detection** — flags queries exceeding a configurable threshold (default: 100ms)
+- **Unused eager load detection** — flags associations preloaded via `includes`/`eager_load` that are never accessed during the request
+- **Per-request summary** — single summary line at the end of each request with totals (e.g. `Request complete — 3 N+1s, 1 slow query`)
+- **CI-friendly raise mode** — set `raise_on_n_plus_one: true` to raise `QueryOwl::NPlusOneError` instead of logging, making N+1s fail fast in test suites
 - **Structured log output** — JSON-style warnings via `Rails.logger` with SQL, duration, count, and filtered backtrace
 - **Zero overhead in production** — auto-enabled in development only
 
@@ -61,6 +65,11 @@ QueryOwl.configure do |config|
   config.slow_query_threshold_ms = 100   # flag queries slower than this
   config.n_plus_one_threshold    = 2     # flag after this many repeated patterns
   config.log_level               = :warn # :warn | :info | :debug
+  config.backtrace_lines         = 5     # number of backtrace frames to capture
+  config.backtrace_filter        = ->(line) { line.start_with?("app/") } # optional custom filter
+  config.raise_on_n_plus_one     = false # set true in CI to raise instead of log
+  config.event_store_size        = 100   # ring buffer capacity
+  config.dashboard_enabled       = Rails.env.development? # HTML view on/off
 end
 ```
 
@@ -75,6 +84,47 @@ When a problem is detected, QueryOwl writes a structured line to `Rails.logger`:
 ```
 [QueryOwl] {"type":"n_plus_one","sql":"SELECT * FROM posts WHERE user_id = ?","count":10,"backtrace":["app/controllers/posts_controller.rb:12"]}
 [QueryOwl] {"type":"slow_query","sql":"SELECT * FROM reports WHERE ...","duration_ms":340}
+[QueryOwl] {"type":"unused_eager_load","model":"Widget","association":"tags"}
+[QueryOwl] Request complete — 10 N+1s, 1 slow query, 1 unused eager load
+```
+
+[↑ Back to top](#table-of-contents)
+
+---
+
+## Dashboard Endpoint
+
+Mount the engine in your host app's routes to enable the JSON endpoint:
+
+```ruby
+# config/routes.rb
+mount QueryOwl::Engine => "/rails"
+```
+
+Then browse the HTML dashboard or query JSON at `GET /rails/slow_queries`:
+
+```
+GET /rails/slow_queries              # HTML dashboard (browser)
+GET /rails/slow_queries.json         # JSON array
+GET /rails/slow_queries?type=n_plus_one
+GET /rails/slow_queries?type=slow_query
+GET /rails/slow_queries?type=unused_eager_load
+```
+
+The HTML view is enabled when `config.dashboard_enabled` is `true` (default in development); returns `403` otherwise. The JSON endpoint is always available.
+
+The JSON response is an array of event objects, newest first, up to `config.event_store_size` entries:
+
+```json
+[
+  {
+    "type": "n_plus_one",
+    "sql": "SELECT * FROM posts WHERE user_id = ?",
+    "count": 5,
+    "backtrace": ["app/controllers/posts_controller.rb:12"],
+    "recorded_at": "2026-06-15T18:00:00.000Z"
+  }
+]
 ```
 
 [↑ Back to top](#table-of-contents)
@@ -116,15 +166,30 @@ QueryOwl::Logger.log_events(events)
 # => [QueryOwl] {"type":"slow_query","sql":"SELECT ...","duration_ms":...}
 ```
 
+**Trigger unused eager load detection:**
+
+```ruby
+QueryOwl.config.enabled = true
+QueryOwl::EagerLoadTracker.start!
+Widget.includes(:tags).map(&:name)   # loads tags but never touches them
+eager_data = QueryOwl::EagerLoadTracker.stop!
+events = QueryOwl::Detector.detect_unused_eager_loads(eager_data)
+QueryOwl::Logger.log_events(events)
+# => [QueryOwl] {"type":"unused_eager_load","model":"Widget","association":"tags"}
+```
+
 **Full pipeline** (as it runs on every real HTTP request):
 
 ```ruby
 QueryOwl.config.slow_query_threshold_ms = 0
 QueryOwl::QueryTracker.start!
+QueryOwl::EagerLoadTracker.start!
 Widget.all.each { |w| Widget.find(w.id) }
-queries = QueryOwl::QueryTracker.stop!
-events  = QueryOwl::Detector.detect_n_plus_one(queries) +
-          QueryOwl::Detector.detect_slow_queries(queries)
+queries    = QueryOwl::QueryTracker.stop!
+eager_data = QueryOwl::EagerLoadTracker.stop!
+events     = QueryOwl::Detector.detect_n_plus_one(queries) +
+             QueryOwl::Detector.detect_slow_queries(queries) +
+             QueryOwl::Detector.detect_unused_eager_loads(eager_data)
 QueryOwl::Logger.log_events(events)
 ```
 

data/app/assets/stylesheets/query_owl/_01_base.css

@@ -0,0 +1,23 @@
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+:root {
+  --bg:      #f8f9fa;
+  --surface: #ffffff;
+  --border:  #dee2e6;
+  --text:    #212529;
+  --muted:   #6c757d;
+  --radius:  6px;
+  --shadow:  0 1px 3px rgba(0,0,0,.08);
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+  font-size: 14px;
+  line-height: 1.5;
+  color: var(--text);
+  background: var(--bg);
+  padding: 2rem;
+}
+
+.qo-monospace { font-family: ui-monospace, "SFMono-Regular", Menlo, monospace; font-size: 12px; }
+.qo-muted     { color: var(--muted); font-size: 12px; }

data/app/assets/stylesheets/query_owl/_02_layout.css

@@ -0,0 +1,5 @@
+.qo-header { margin-bottom: 1.5rem; }
+.qo-header h1 { font-size: 1.4rem; font-weight: 600; }
+.qo-header p  { color: var(--muted); margin-top: 0.2rem; }
+
+.qo-empty { color: var(--muted); font-style: italic; margin-top: 1rem; }

data/app/assets/stylesheets/query_owl/_03_table.css

@@ -0,0 +1,29 @@
+.qo-table {
+  width: 100%;
+  border-collapse: collapse;
+  background: var(--surface);
+  border-radius: var(--radius);
+  overflow: hidden;
+  box-shadow: var(--shadow);
+}
+
+.qo-table th {
+  text-align: left;
+  padding: 0.6rem 1rem;
+  background: #f0f0f0;
+  font-weight: 600;
+  font-size: 11px;
+  text-transform: uppercase;
+  letter-spacing: .04em;
+  color: var(--muted);
+  border-bottom: 1px solid var(--border);
+}
+
+.qo-table td {
+  padding: 0.6rem 1rem;
+  border-bottom: 1px solid #eee;
+  vertical-align: top;
+}
+
+.qo-table tr:last-child td { border-bottom: none; }
+.qo-table tr:hover td      { background: #fafafa; }

data/app/assets/stylesheets/query_owl/_04_badges.css

@@ -0,0 +1,13 @@
+.qo-badge {
+  display: inline-block;
+  padding: 2px 8px;
+  border-radius: 3px;
+  font-size: 11px;
+  font-weight: 600;
+  text-transform: uppercase;
+  white-space: nowrap;
+}
+
+.qo-badge--n_plus_one       { background: #fde8e8; color: #c0392b; }
+.qo-badge--slow_query       { background: #fef3e2; color: #e67e22; }
+.qo-badge--unused_eager_load { background: #e8f4fd; color: #2980b9; }

data/app/controllers/query_owl/slow_queries_controller.rb

@@ -0,0 +1,28 @@
+module QueryOwl
+  class SlowQueriesController < ActionController::Base
+    protect_from_forgery with: :null_session
+    layout "query_owl/application"
+    helper QueryOwl::ApplicationHelper
+
+    before_action :check_dashboard_enabled, if: -> { request.format.html? }
+
+    def index
+      filters = request.query_parameters
+      events  = EventStore.all
+      events  = events.select { |e| e[:type].to_s == filters["type"] }       if filters["type"].present?
+      events  = events.select { |e| e[:controller] == filters["controller"] } if filters["controller"].present?
+      events  = events.select { |e| e[:action] == filters["action"] }         if filters["action"].present?
+
+      respond_to do |format|
+        format.json { render json: events }
+        format.html { @events = events.reverse }
+      end
+    end
+
+    private
+
+    def check_dashboard_enabled
+      head :forbidden unless QueryOwl.config.dashboard_enabled
+    end
+  end
+end

data/app/helpers/query_owl/application_helper.rb

@@ -0,0 +1,9 @@
+module QueryOwl
+  module ApplicationHelper
+    def inline_styles
+      dir = QueryOwl::Engine.root.join("app/assets/stylesheets/query_owl")
+      css = dir.glob("_*.css").sort.map(&:read).join("\n")
+      content_tag(:style, css.html_safe)
+    end
+  end
+end

data/app/views/layouts/query_owl/application.html.erb

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>QueryOwl</title>
+  <link rel="icon" href="data:,">
+  <%= inline_styles %>
+</head>
+<body>
+  <%= yield %>
+</body>
+</html>

data/app/views/query_owl/slow_queries/index.html.erb

@@ -0,0 +1,34 @@
+<div class="qo-header">
+  <h1>QueryOwl</h1>
+  <p>Last <%= @events.length %> detected event<%= "s" unless @events.length == 1 %> (newest first)</p>
+</div>
+
+<% if @events.empty? %>
+  <p class="qo-empty">No events detected yet.</p>
+<% else %>
+  <table class="qo-table">
+    <thead>
+      <tr>
+        <th>Type</th>
+        <th>SQL / Details</th>
+        <th>Info</th>
+        <th>Recorded At</th>
+        <th>Backtrace</th>
+      </tr>
+    </thead>
+    <tbody>
+      <% @events.each do |event| %>
+        <tr>
+          <td><span class="qo-badge qo-badge--<%= event[:type] %>"><%= event[:type].to_s.tr("_", " ") %></span></td>
+          <td class="qo-monospace"><%= event[:sql] || "#{event[:model]}##{event[:association]}" %></td>
+          <td class="qo-muted">
+            <% if event[:count] %>count: <%= event[:count] %><% end %>
+            <% if event[:duration_ms] %><%= event[:duration_ms] %>ms<% end %>
+          </td>
+          <td class="qo-muted"><%= event[:recorded_at]&.strftime("%H:%M:%S") %></td>
+          <td class="qo-monospace qo-muted"><%= Array(event[:backtrace]).first %></td>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+<% end %>

data/config/routes.rb

@@ -1,2 +1,3 @@
 QueryOwl::Engine.routes.draw do
+  get "slow_queries", to: "slow_queries#index"
 end

data/lib/query_owl/configuration.rb

@@ -1,15 +1,22 @@
 module QueryOwl
   class Configuration
     VALID_LOG_LEVELS = %i[debug info warn].freeze
+    DEFAULT_BACKTRACE_FILTER = ->(line) { line !~ %r{/gems/|/rubygems/|/ruby/gems/|lib/query_owl/} }
 
-    attr_reader :log_level
-    attr_accessor :enabled, :slow_query_threshold_ms, :n_plus_one_threshold
+    attr_reader :log_level, :backtrace_filter
+    attr_accessor :enabled, :slow_query_threshold_ms, :n_plus_one_threshold, :backtrace_lines,
+                  :raise_on_n_plus_one, :event_store_size, :dashboard_enabled
 
     def initialize
-      @enabled                = Rails.env.development?
+      @enabled                 = Rails.env.development?
       @slow_query_threshold_ms = 100
-      @n_plus_one_threshold   = 2
-      @log_level              = :warn
+      @n_plus_one_threshold    = 2
+      @log_level               = :warn
+      @backtrace_lines         = 5
+      @backtrace_filter        = DEFAULT_BACKTRACE_FILTER
+      @raise_on_n_plus_one     = false
+      @event_store_size        = 100
+      @dashboard_enabled       = Rails.env.development?
     end
 
     def log_level=(level)
@@ -19,5 +26,11 @@ module QueryOwl
 
       @log_level = level
     end
+
+    def backtrace_filter=(filter)
+      raise ArgumentError, "backtrace_filter must respond to #call" unless filter.respond_to?(:call)
+
+      @backtrace_filter = filter
+    end
   end
 end

data/lib/query_owl/detector.rb

@@ -1,9 +1,13 @@
 module QueryOwl
   module Detector
-    # Matches numeric literals, single-quoted strings, and IN-list contents.
     NORMALIZE_PATTERNS = [
       [/'[^']*'/, "?"],
-      [/\b\d+\b/, "?"],
+      [/\b[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}\b/i, "?"],
+      [/\$\d+/, "?"],
+      [/\b\d+\.?\d*\b/, "?"],
+      [/\bIN\s*\(\s*\?(?:\s*,\s*\?)*\s*\)/i, "IN (?)"],
+      [/"([^"]+)"/, '\1'],
+      [/`([^`]+)`/, '\1'],
       [/\s+/, " "]
     ].freeze
 
@@ -42,6 +46,16 @@ module QueryOwl
         end
       end
 
+      def detect_unused_eager_loads(eager_data)
+        preloaded = eager_data[:preloaded] || []
+        accessed  = eager_data[:accessed]  || Set.new
+
+        preloaded
+          .uniq { |e| "#{e[:model]}##{e[:association]}" }
+          .reject { |e| accessed.include?("#{e[:model]}##{e[:association]}") }
+          .map { |e| { type: :unused_eager_load, model: e[:model], association: e[:association] } }
+      end
+
       def normalize(sql)
         NORMALIZE_PATTERNS
           .reduce(sql.to_s) { |s, (pattern, replacement)| s.gsub(pattern, replacement) }

data/lib/query_owl/eager_load_tracker.rb

@@ -0,0 +1,43 @@
+module QueryOwl
+  module EagerLoadTracker
+    class << self
+      def start!
+        Thread.current[:query_owl_preloaded] = []
+        Thread.current[:query_owl_el_accessed] = Set.new
+      end
+
+      def stop!
+        result = { preloaded: preloaded.dup, accessed: accessed.dup }
+        Thread.current[:query_owl_preloaded] = nil
+        Thread.current[:query_owl_el_accessed] = nil
+        result
+      end
+
+      def tracking?
+        !Thread.current[:query_owl_preloaded].nil?
+      end
+
+      def record_preload(model_name, association_name)
+        return unless tracking?
+
+        preloaded << { model: model_name.to_s, association: association_name.to_s }
+      end
+
+      def record_access(model_name, association_name)
+        return unless tracking?
+
+        accessed << "#{model_name}##{association_name}"
+      end
+
+      private
+
+      def preloaded
+        Thread.current[:query_owl_preloaded] ||= []
+      end
+
+      def accessed
+        Thread.current[:query_owl_el_accessed] ||= Set.new
+      end
+    end
+  end
+end

data/lib/query_owl/engine.rb

@@ -15,5 +15,35 @@ module QueryOwl
     initializer "query_owl.request_tracking" do |app|
       app.middleware.use(Middleware)
     end
+
+    config.after_initialize do
+      ActiveRecord::Associations::Preloader.prepend(Module.new do
+        def initialize(records:, associations:, **kwargs)
+          if QueryOwl::EagerLoadTracker.tracking? && records.any?
+            model_name = records.first.class.name
+            Array(associations).each do |assoc|
+              QueryOwl::EagerLoadTracker.record_preload(model_name, assoc)
+            end
+          end
+          super
+        end
+
+        def call
+          Thread.current[:query_owl_preloading] = true
+          super
+        ensure
+          Thread.current[:query_owl_preloading] = false
+        end
+      end)
+
+      ActiveRecord::Base.prepend(Module.new do
+        def association(name)
+          unless Thread.current[:query_owl_preloading]
+            QueryOwl::EagerLoadTracker.record_access(self.class.name, name)
+          end
+          super
+        end
+      end)
+    end
   end
 end

data/lib/query_owl/event_store.rb

@@ -0,0 +1,59 @@
+module QueryOwl
+  module EventStore
+    class << self
+      def push(event)
+        mutex.synchronize do
+          ensure_buffer_size
+          buffer[@write_pos] = event.merge(recorded_at: Time.now)
+          @write_pos = (@write_pos + 1) % capacity
+          @stored    = [@stored + 1, capacity].min
+        end
+      end
+
+      def all
+        mutex.synchronize do
+          stored = @stored || 0
+          return [] if stored.zero?
+
+          if stored < capacity
+            buffer.first(stored)
+          else
+            buffer[@write_pos..] + buffer[0...@write_pos]
+          end
+        end
+      end
+
+      def clear
+        mutex.synchronize { reset! }
+      end
+
+      def size
+        mutex.synchronize { @stored || 0 }
+      end
+
+      private
+
+      def mutex
+        @mutex ||= Mutex.new
+      end
+
+      def capacity
+        QueryOwl.config.event_store_size
+      end
+
+      def ensure_buffer_size
+        reset! if @write_pos.nil? || @buffer.nil? || @buffer.size != capacity
+      end
+
+      def buffer
+        @buffer ||= Array.new(capacity)
+      end
+
+      def reset!
+        @buffer    = Array.new(capacity)
+        @write_pos = 0
+        @stored    = 0
+      end
+    end
+  end
+end

data/lib/query_owl/logger.rb

@@ -11,6 +11,18 @@ module QueryOwl
         events.each { |event| write(event) }
       end
 
+      def log_summary(events)
+        return if events.empty?
+
+        counts = events.group_by { |e| e[:type] }.transform_values(&:count)
+        parts  = []
+        parts << "#{counts[:n_plus_one]} N+1#{"s" if counts[:n_plus_one] != 1}" if counts[:n_plus_one]
+        parts << "#{counts[:slow_query]} slow #{counts[:slow_query] == 1 ? "query" : "queries"}" if counts[:slow_query]
+        parts << "#{counts[:unused_eager_load]} unused eager load#{"s" if counts[:unused_eager_load] != 1}" if counts[:unused_eager_load]
+
+        Rails.logger.public_send(QueryOwl.config.log_level, "#{PREFIX} Request complete — #{parts.join(", ")}")
+      end
+
       private
 
       def write(event)

data/lib/query_owl/middleware.rb

@@ -4,15 +4,29 @@ module QueryOwl
       @app = app
     end
 
+    def raise_on_n_plus_one!(events)
+      event = events.find { |e| e[:type] == :n_plus_one }
+      return unless event
+
+      raise NPlusOneError, "N+1 detected: #{event[:sql]} (#{event[:count]} times) #{event[:backtrace].first}"
+    end
+
     def call(env)
       return @app.call(env) unless QueryOwl.config.enabled
 
       QueryTracker.start!
+      EagerLoadTracker.start!
       @app.call(env)
     ensure
-      queries = QueryTracker.stop!
-      events  = Detector.detect_n_plus_one(queries) + Detector.detect_slow_queries(queries)
+      queries     = QueryTracker.stop!
+      eager_data  = EagerLoadTracker.stop!
+      events      = Detector.detect_n_plus_one(queries) +
+                    Detector.detect_slow_queries(queries) +
+                    Detector.detect_unused_eager_loads(eager_data)
       Logger.log_events(events)
+      Logger.log_summary(events)
+      events.each { |e| EventStore.push(e) }
+      raise_on_n_plus_one!(events) if QueryOwl.config.raise_on_n_plus_one
     end
   end
 end

data/lib/query_owl/query_tracker.rb

@@ -37,7 +37,9 @@ module QueryOwl
       private
 
       def filtered_backtrace
-        caller.grep_v(%r{/gems/|/rubygems/|/ruby/gems/|lib/query_owl/}).first(5)
+        filter = QueryOwl.config.backtrace_filter
+        lines  = QueryOwl.config.backtrace_lines
+        caller.select { |line| filter.call(line) }.first(lines)
       end
     end
   end

data/lib/query_owl/version.rb

@@ -1,3 +1,3 @@
 module QueryOwl
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/query_owl.rb

@@ -1,12 +1,16 @@
 require "query_owl/version"
 require "query_owl/configuration"
 require "query_owl/query_tracker"
+require "query_owl/eager_load_tracker"
+require "query_owl/event_store"
 require "query_owl/detector"
 require "query_owl/logger"
 require "query_owl/middleware"
 require "query_owl/engine"
 
 module QueryOwl
+  class NPlusOneError < StandardError; end
+
   class << self
     def configure
       yield config

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: query_owl
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Chuck Smith
@@ -34,15 +34,25 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
+- app/assets/stylesheets/query_owl/_01_base.css
+- app/assets/stylesheets/query_owl/_02_layout.css
+- app/assets/stylesheets/query_owl/_03_table.css
+- app/assets/stylesheets/query_owl/_04_badges.css
 - app/controllers/query_owl/application_controller.rb
+- app/controllers/query_owl/slow_queries_controller.rb
+- app/helpers/query_owl/application_helper.rb
 - app/jobs/query_owl/application_job.rb
 - app/mailers/query_owl/application_mailer.rb
 - app/models/query_owl/application_record.rb
+- app/views/layouts/query_owl/application.html.erb
+- app/views/query_owl/slow_queries/index.html.erb
 - config/routes.rb
 - lib/query_owl.rb
 - lib/query_owl/configuration.rb
 - lib/query_owl/detector.rb
+- lib/query_owl/eager_load_tracker.rb
 - lib/query_owl/engine.rb
+- lib/query_owl/event_store.rb
 - lib/query_owl/logger.rb
 - lib/query_owl/middleware.rb
 - lib/query_owl/query_tracker.rb