jit_preloader 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f7e698f4bfc6d6724f1b11f46b954995085525b7
+  data.tar.gz: 5e597f8c4289ac459d030d4f1c42f76bbf327d34
+SHA512:
+  metadata.gz: 2469c5a0361154980988d9c5bf0aae13842b583051d168656efadf9a21f7fc8379d68c842831cce6e1b4b4d37253fb294ddfe84618f3786f35262459590bf9df
+  data.tar.gz: 8127d7c2040f18b21664fc11a5062db501d87e378fdbf91b4d327f86819d2a8df36f6c760c3fab0e6dcf79dcc340c71d5f05db62fe01287a20cd6cf720d53fc3

data/.gitignore

@@ -0,0 +1,50 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in jit_preloader.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,61 @@
+PATH
+  remote: .
+  specs:
+    jit_preloader (0.0.1)
+      activerecord (~> 4.2)
+      activesupport
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.2.7.1)
+      activesupport (= 4.2.7.1)
+      builder (~> 3.1)
+    activerecord (4.2.7.1)
+      activemodel (= 4.2.7.1)
+      activesupport (= 4.2.7.1)
+      arel (~> 6.0)
+    activesupport (4.2.7.1)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    arel (6.0.3)
+    builder (3.2.2)
+    byebug (9.0.6)
+    database_cleaner (1.5.3)
+    diff-lcs (1.2.5)
+    i18n (0.7.0)
+    json (1.8.3)
+    minitest (5.9.1)
+    rake (10.5.0)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.4)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    sqlite3 (1.3.12)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.7)
+  byebug
+  database_cleaner
+  jit_preloader!
+  rake (~> 10.0)
+  rspec
+  sqlite3

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Kyle d'Oliveira
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,187 @@
+# JitPreloader
+
+N+1 queries are a silent killer for performance. Sometimes they can be noticeable; other times they're just a minor tax. We want a way to remove them.
+
+Imagine you have contacts that have many emails, phone numbers, and addresses. You might have code like this:
+
+```ruby
+def do_my_thing(contact)
+  contact.emails.each do |email|
+    # Do a thing with the email
+  end
+  contact.phone_numbers.each do |phone_number|
+    # Do a thing with the phone number
+  end
+end
+
+# This will generate two N+1 queries, one for emails and one for phone numbers.
+Contact.all.each do |contact|
+  do_my_thing(contact)
+end
+```
+
+Rails solves this with `includes` (or better, `preload`/`eager_load`, as they are what `includes` uses in the background). So to get around this problem in Rails you would do something like this:
+
+```ruby
+Contact.preload(:emails, :phone_numbers).each do |contact|
+  do_my_thing(contact)
+end
+```
+
+However this does have some limitations.
+
+1) When doing the `preload`, you have to understand what the code does in order to properly load the associations. When this is a brand new method or a simple method this may be simple, but sometimes it can be difficult or time-consuming to figure this out.
+
+2) Imagine we change the method to also use the `addresses` association:
+
+```ruby
+def do_my_thing(contact)
+  contact.emails.each do |email|
+    # Do a thing with the email
+  end
+  contact.phone_numbers.each do |phone_number|
+    # Do a thing with the phone number
+  end
+  contact.addresses.each do |address|
+    # Do a thing with the address
+  end
+end
+```
+
+All of a sudden we have an N+1 query again. So now you need to go hunt down all of the places were you were preloading and preload the new association.
+
+3) Imagine we change the method to do this:
+
+```ruby
+def do_my_thing(contact)
+  contact.emails.each do |email|
+    # Do a thing with the email
+  end
+end
+```
+
+We don't have an N+1 query here, but now we are preloading the `phone_numbers` association but not doing anything with it. This is still bad, especially when there are a lot of associations on the object.
+
+This gem provides a "magic bullet" that can remove most N+1 queries in the application.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'jit_preloader'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jit_preloader
+
+## Usage
+
+This gem provides three features:
+
+### N+1 query tracking
+
+This gem will publish an `n_plus_one_query` event via ActiveSupport::Notifications whenever it detects one. This lets you do a variety of useful things. Here are some examples:
+
+You could implement some basic tracking. This will let you measure the extent of the N+1 query problems in your app:
+```ruby
+ActiveSupport::Notifications.subscribe("n_plus_one_query") do |event, data|
+  statsd.increment "web.#{Rails.env}.n_plus_one_queries.global"
+end
+```
+
+You could log the N+1 queries. In your development environment, you could throw N+1 queries into the logs along with a stack trace:
+```ruby
+ActiveSupport::Notifications.subscribe("n_plus_one_query") do |event, data|
+  message = "N+1 Query detected: #{data[:association]} on #{data[:source].class}"
+  backtrace = caller.select{|r| r.starts_with?(Rails.root.to_s) }
+  Rails.logger.debug("\n\n#{message}\n#{backtrace.join("\n")}\n".red)
+end
+```
+
+If you use rspec, you could wrap your specs in an `around(:each)` that throws an exception if an N+1 query is detected. You could even provide a tag that allows tests that have known N+1 queries to still pass:
+```ruby
+config.around(:each) do |example|
+  callback = ->(event, data) do
+    unless example.metadata[:known_n_plus_one_query]
+      message = "N+1 Query detected: #{data[:source].class} on #{data[:association]}"
+      raise QueryError.new(message)
+    end
+  end
+  ActiveSupport::Notifications.subscribed(callback, "n_plus_one_query") do
+    example.run
+  end
+end
+```
+
+### Jit preloading on a case-by-case basis
+
+There is now a `jit_preload` and `jit_preload!` method on ActiveRecord::Relation objects. This means instead of using `includes`, `preload` or `eager_load` with the association you want to load, you can simply just use `jit_preload`
+
+```ruby
+# old
+Contact.preload(:addresses, :email_addresses).each do |contact|
+  contact.addresses.to_a
+  contact.email_addresses.to_a
+end
+
+# new
+Contact.jit_preload.each do |contact|
+  contact.addresses.to_a
+  contact.email_addresses.to_a
+end
+```
+
+### Jit preloading globally across your application
+
+The JitPreloader can be globally enabled, in which case most N+1 queries in your app should just disappear. It is off by default.
+
+```ruby
+# Can be true or false
+JitPreloader.globally_enabled = true
+
+# Can also be given anything that responds to `call`.
+# You could build a kill switch with Redis (or whatever you'd like)
+# so that you can turn it on or off dynamically.
+JitPreloader.globally_enabled = ->{ $redis.get('always_jit_preload') == 'on' }
+
+# When enabled globally, this would not generate an N+1 query.
+Contact.all.each do |contact|
+  contact.emails.each do |email|
+    # do something
+  end
+end
+```
+
+## What it doesn't solve
+
+This is mostly a magic bullet, but it doesn't solve all database-related problems. If you reload an association, or call a query or aggregate function on the association, it will not remove those extra queries. These problems cannot be solved by using Rails' `preload` so it cannot be solved with the Jit Preloader.
+
+```ruby
+Contact.all.each do |contact|
+  contact.emails.reload                         # Reloading the association
+  contact.phone_numbers.max("LENGTH(number)")   # Aggregate functions on the association
+  contact.addresses.where(billing: true).to_a   # Querying the association
+end
+```
+
+## Consequences
+
+1) This gem introduces more Magic. This is fine, but you should really understand what is going on under the hood. You should understand what makes an N+1 query happen and what this gem is doing to help address it.
+
+2) We may do more work than you require. If you have turned the preloader on globally but you only want to access a single record's association, it will load the association for the entire collection you were looking at.
+
+3) Each result set will have a JitPreloader setup on it, and the preloader will have a reference to all of the other objects in a result set. This means that so long as one object of that result set exists in memory, the others will not be cleaned up by the garbage collector. This shouldn't have much impact, but it's good to be aware of it.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/jit_preloader/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/jit_preloader.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jit_preloader/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jit_preloader"
+  spec.version       = JitPreloader::VERSION
+  spec.authors       = ["Kyle d'Oliveira"]
+  spec.email         = ["kyle.doliveira@clio.com"]
+  spec.summary       = %q{Tool to understand N+1 queries and to remove them}
+  spec.description   = %q{The JitPreloader has the ability to send notifications when N+1 queries occur to help guage how problematic they are for your code base and a way to remove all of the commons explicitly or automatically}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", "~> 4.2"
+  spec.add_dependency "activesupport"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "database_cleaner"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "byebug"
+end

data/lib/jit_preloader/active_record/associations/collection_association.rb

@@ -0,0 +1,30 @@
+class ActiveRecord::Associations::CollectionAssociation
+
+  def load_target_with_jit
+    was_loaded = loaded?
+
+    if !loaded? && owner.persisted? && owner.jit_preloader
+      owner.jit_preloader.jit_preload(reflection.name)
+    end
+
+    jit_loaded = loaded?
+
+    load_target_without_jit.tap do |records|
+      # We should not act on non-persisted objects, or ones that are already loaded.
+      if owner.persisted? && !was_loaded
+        # If we went through a JIT preload, then we will have attached another JitPreloader elsewhere.
+        JitPreloader::Preloader.attach(records) if records.any? && !jit_loaded && JitPreloader.globally_enabled?
+
+        # If the records were not pre_loaded
+        records.each{ |record| record.jit_n_plus_one_tracking = true }
+
+        if !jit_loaded && owner.jit_n_plus_one_tracking
+          ActiveSupport::Notifications.publish("n_plus_one_query",
+                                               source: owner, association: reflection.name)
+        end
+      end
+    end
+  end
+  alias_method_chain :load_target, :jit
+
+end

data/lib/jit_preloader/active_record/associations/preloader/collection_association.rb

@@ -0,0 +1,34 @@
+class ActiveRecord::Associations::Preloader::CollectionAssociation
+  private
+  # A monkey patch to ActiveRecord. The old method looked like the snippet
+  # below. Our changes here are that we remove records that are already
+  # part of the target, then attach all of the records to a new jit preloader.
+  #
+  # def preload(preloader)
+  #   associated_records_by_owner(preloader).each do |owner, records|
+  #     association = owner.association(reflection.name)
+  #     association.loaded!
+  #     association.target.concat(records)
+  #     records.each { |record| association.set_inverse_instance(record) }
+  #   end
+  # end
+
+  def preload(preloader)
+    return unless reflection.scope.nil? || reflection.scope.arity == 0
+    all_records = []
+    associated_records_by_owner(preloader).each do |owner, records|
+      association = owner.association(reflection.name)
+      association.loaded!
+      # It is possible that some of the records are loaded already.
+      # We don't want to duplicate them, but we also want to preserve
+      # the original copy so that we don't blow away in-memory changes.
+      new_records = association.target.any? ? records - association.target : records
+
+      association.target.concat(new_records)
+      new_records.each { |record| association.set_inverse_instance(record) }
+
+      all_records.concat(records) if owner.jit_preloader || JitPreloader.globally_enabled?
+    end
+    JitPreloader::Preloader.attach(all_records) if all_records.any?
+  end
+end

data/lib/jit_preloader/active_record/associations/preloader/singular_association.rb

@@ -0,0 +1,29 @@
+class ActiveRecord::Associations::Preloader::SingularAssociation
+  private
+  # A monkey patch to ActiveRecord. The old method looked like the snippet
+  # below. Our changes here are that we don't assign the record if the
+  # target has already been set, and we attach all of the records to a new
+  # jit preloader.
+  #
+  # def preload(preloader)
+  #   associated_records_by_owner(preloader).each do |owner, associated_records|
+  #     record = associated_records.first
+  #     association = owner.association(reflection.name)
+  #     association.target = record
+  #   end
+  # end
+
+  def preload(preloader)
+    return unless reflection.scope.nil? || reflection.scope.arity == 0
+    all_records = []
+
+    associated_records_by_owner(preloader).each do |owner, associated_records|
+      record = associated_records.first
+
+      association = owner.association(reflection.name)
+      association.target ||= record
+      all_records.push(record) if record && (owner.jit_preloader || JitPreloader.globally_enabled?)
+    end
+    JitPreloader::Preloader.attach(all_records) if all_records.any?
+  end
+end

data/lib/jit_preloader/active_record/associations/singular_association.rb

@@ -0,0 +1,29 @@
+class ActiveRecord::Associations::SingularAssociation
+
+  def load_target_with_jit
+    was_loaded = loaded?
+
+    if !loaded? && owner.persisted? && owner.jit_preloader
+      owner.jit_preloader.jit_preload(reflection.name)
+    end
+
+    jit_loaded = loaded?
+
+    load_target_without_jit.tap do |record|
+      if owner.persisted? && !was_loaded
+        # If the owner doesn't track N+1 queries, then we don't need to worry about
+        # tracking it on the record. This is because you can do something like:
+        # model.foo.bar (where foo and bar are singular associations) and that isn't
+        # always an N+1 query.
+        record.jit_n_plus_one_tracking ||= owner.jit_n_plus_one_tracking if record
+
+        if !jit_loaded && owner.jit_n_plus_one_tracking
+          ActiveSupport::Notifications.publish("n_plus_one_query",
+                                               source: owner, association: reflection.name)
+        end
+      end
+    end
+  end
+  alias_method_chain :load_target, :jit
+
+end

data/lib/jit_preloader/active_record/base.rb

@@ -0,0 +1,15 @@
+module JitPreloadExtension
+
+  extend ActiveSupport::Concern
+
+  included do
+    attr_accessor :jit_preloader
+    attr_accessor :jit_n_plus_one_tracking
+  end
+
+  class_methods do
+    delegate :jit_preload, to: :all
+  end
+end
+
+ActiveRecord::Base.send(:include, JitPreloadExtension)

data/lib/jit_preloader/active_record/query_methods.rb

@@ -0,0 +1,16 @@
+module ActiveRecord::QueryMethods
+
+  def jit_preload(*args)
+    spawn.jit_preload!(*args)
+  end
+
+  def jit_preload!(*args)
+    @jit_preload = true
+    self
+  end
+
+  def jit_preload?
+    @jit_preload
+  end
+
+end

data/lib/jit_preloader/active_record/relation.rb

@@ -0,0 +1,26 @@
+class ActiveRecord::Relation
+
+  def calculate_with_jit(*args)
+    if respond_to?(:proxy_association) && proxy_association.owner && proxy_association.owner.jit_n_plus_one_tracking
+      ActiveSupport::Notifications.publish("n_plus_one_query",
+                                           source: proxy_association.owner,
+                                           association: "#{proxy_association.reflection.name}.#{args.first}")
+    end
+    calculate_without_jit(*args)
+  end
+
+  alias_method_chain :calculate, :jit
+
+  def exec_queries_with_jit
+    exec_queries_without_jit.tap do |records|
+      if limit_value != 1
+        records.each{ |record| record.jit_n_plus_one_tracking = true }
+        if jit_preload? || JitPreloader.globally_enabled?
+          JitPreloader::Preloader.attach(records)
+        end
+      end
+    end
+  end
+  alias_method_chain :exec_queries, :jit
+
+end

data/lib/jit_preloader/preloader.rb

@@ -0,0 +1,23 @@
+module JitPreloader
+  class Preloader < ActiveRecord::Associations::Preloader
+
+    attr_accessor :records
+
+    def self.attach(records)
+      new.tap do |loader|
+        loader.records = records
+        records.each do |record|
+          record.jit_preloader = loader
+        end
+      end
+    end
+
+    def jit_preload(association)
+      # It is possible that the records array has multiple different classes (think single table inheritance).
+      # Thus, it is possible that some of the records don't have an association.
+      records_with_association = records.reject{|r| r.class.reflect_on_association(association).nil? }
+      preload records_with_association, association
+    end
+
+  end
+end

data/lib/jit_preloader/version.rb

@@ -0,0 +1,3 @@
+module JitPreloader
+  VERSION = "0.0.1"
+end

data/lib/jit_preloader.rb

@@ -0,0 +1,30 @@
+require 'active_support/concern'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/notifications'
+require 'active_record'
+
+require "jit_preloader/version"
+require 'jit_preloader/active_record/base'
+require 'jit_preloader/active_record/query_methods'
+require 'jit_preloader/active_record/relation'
+require 'jit_preloader/active_record/associations/collection_association'
+require 'jit_preloader/active_record/associations/singular_association'
+require 'jit_preloader/active_record/associations/preloader/collection_association'
+require 'jit_preloader/active_record/associations/preloader/singular_association'
+require 'jit_preloader/preloader'
+
+module JitPreloader
+
+  def self.globally_enabled=(value)
+    @enabled = value
+  end
+
+  def self.globally_enabled?
+    if @enabled && @enabled.respond_to?(:call)
+      @enabled.call
+    else
+      @enabled
+    end
+  end
+
+end

data/spec/lib/jit_preloader/preloader_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+RSpec.describe JitPreloader::Preloader do
+
+  let!(:contact1) do
+    Contact.create(
+                   name: "Only Addresses", 
+                   addresses: [
+                               Address.new(street: "123 Fake st", country: canada), 
+                               Address.new(street: "21 Jump st", country: usa)
+                              ]
+                   )
+  end
+
+  let!(:contact2) do
+    Contact.create(
+                   name: "Only Emails",
+                   email_address: EmailAddress.new(address: "woot@woot.com"),
+                   )
+  end
+
+  let!(:contact3) do
+    Contact.create(
+                   name: "Both!", 
+                   addresses: [
+                               Address.new(street: "1 First st", country: canada), 
+                               Address.new(street: "10 Tenth Ave", country: usa)
+                              ],
+                   email_address: EmailAddress.new(address: "woot@woot.com"),
+                   )
+  end
+
+  let(:canada) { Country.create(name: "Canada") }
+  let(:usa) { Country.create(name: "U.S.A") }
+
+  let(:source_map) { Hash.new{|h,k| h[k]= Array.new } }
+  let(:callback) do
+    ->(event, data){ source_map[data[:source]] << data[:association] }
+  end
+
+  context "when the preloader is globally enabled" do
+    around do |example|
+      JitPreloader.globally_enabled = true
+      example.run
+      JitPreloader.globally_enabled = false
+    end
+    context "when grabbing all of the address'es contries and email addresses" do
+      it "doesn't generate an N+1 query ntoification" do
+        ActiveSupport::Notifications.subscribed(callback, "n_plus_one_query") do
+          Contact.all.collect{|c| c.addresses.collect(&:country); c.email_address }
+        end
+        expect(source_map).to eql({})
+      end
+    end
+
+    context "when we perform aggregate functions on the data" do
+      it "generates N+1 query notifications for each one" do
+        ActiveSupport::Notifications.subscribed(callback, "n_plus_one_query") do
+          Contact.all.each{|c| c.addresses.count; c.addresses.sum(:id) }
+        end
+        contact_queries = [contact1,contact2, contact3].product([["addresses.count", "addresses.sum"]])
+        expect(source_map).to eql(Hash[contact_queries])
+      end      
+    end
+  end
+
+  context "when the preloader is not globally enabled" do
+    context "when we perform aggregate functions on the data" do
+      it "generates N+1 query notifications for each one" do
+        ActiveSupport::Notifications.subscribed(callback, "n_plus_one_query") do
+          Contact.all.each{|c| c.addresses.count; c.addresses.sum(:id) }
+        end
+        contact_queries = [contact1,contact2, contact3].product([["addresses.count", "addresses.sum"]])
+        expect(source_map).to eql(Hash[contact_queries])
+      end      
+    end
+
+    context "when explicitly finding a contact" do
+      it "generates N+1 query notifications for the country" do
+        ActiveSupport::Notifications.subscribed(callback, "n_plus_one_query") do
+          Contact.find(contact1.id).tap{|c| c.addresses.collect(&:country); c.email_address }
+        end
+        address_queries = Address.where(contact_id: 1).product([[:country]])
+        expect(source_map).to eql(Hash[address_queries])
+      end
+    end
+
+    context "when explicitly finding multiple contacts" do
+      it "generates N+1 query notifications for the country" do
+        ActiveSupport::Notifications.subscribed(callback, "n_plus_one_query") do
+          Contact.find(contact1.id, contact2.id).each{|c| c.addresses.collect(&:country); c.email_address }
+        end
+        contact_queries = [contact1,contact2].product([[:addresses, :email_address]])
+        address_queries = Address.where(contact_id: contact1.id).product([[:country]])
+
+        expect(source_map).to eql(Hash[address_queries.concat(contact_queries)])
+      end
+    end
+
+    context "when grabbing the email address and address's country of the first contact" do
+      it "generates N+1 query notifications for the country" do
+        ActiveSupport::Notifications.subscribed(callback, "n_plus_one_query") do
+          Contact.first.tap{|c| c.addresses.collect(&:country); c.email_address }
+        end
+
+        address_queries = Address.where(contact_id: contact1.id).product([[:country]])
+
+        expect(source_map).to eql(Hash[address_queries])
+      end
+    end
+
+    context "when grabbing all of the address'es contries and email addresses" do
+      it "generates an N+1 query for each association on the contacts" do
+        ActiveSupport::Notifications.subscribed(callback, "n_plus_one_query") do
+          Contact.all.each{|c| c.addresses.collect(&:country); c.email_address }
+        end
+        contact_queries = [contact1,contact2,contact3].product([[:addresses, :email_address]])
+        address_queries = Address.all.product([[:country]])
+        expect(source_map).to eql(Hash[address_queries.concat(contact_queries)])
+      end
+
+      context "and we use regular preload for addresses" do
+        it "generates an N+1 query for only the email addresses on the contacts" do
+          ActiveSupport::Notifications.subscribed(callback, "n_plus_one_query") do
+            Contact.preload(:addresses).each{|c| c.addresses.collect(&:country); c.email_address }
+          end
+          contact_queries = [contact1,contact2,contact3].product([[:email_address]])
+          address_queries = Address.all.product([[:country]])
+          expect(source_map).to eql(Hash[address_queries.concat(contact_queries)])
+        end        
+      end
+
+      context "and we use jit preload" do
+        it "generates no n+1 queries" do
+          ActiveSupport::Notifications.subscribed(callback, "n_plus_one_query") do
+            Contact.jit_preload.each{|c| c.addresses.collect(&:country); c.email_address }
+          end
+          expect(source_map).to eql({})
+        end
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,51 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'jit_preloader'
+require 'support/database'
+require 'support/models'
+require 'byebug'
+require 'database_cleaner'
+
+DatabaseCleaner.strategy = :transaction
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    Database.connect!
+    Database.build!
+  end
+  config.before do
+    DatabaseCleaner.start
+  end
+
+  config.after do
+    DatabaseCleaner.clean
+  end
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  config.disable_monkey_patching!
+
+  config.order = :random
+end

data/spec/support/database.rb

@@ -0,0 +1,21 @@
+class Database
+  def self.tables
+    [
+      "CREATE TABLE contacts (id INTEGER NOT NULL PRIMARY KEY, name VARCHAR(255))",
+      "CREATE TABLE addresses (id INTEGER NOT NULL PRIMARY KEY, contact_id INTEGER NOT NULL, country_id INTEGER NOT NULL, street VARCHAR(255))",
+      "CREATE TABLE email_addresses (id INTEGER NOT NULL PRIMARY KEY, contact_id INTEGER NOT NULL, address VARCHAR(255))",
+      "CREATE TABLE countries (id INTEGER NOT NULL PRIMARY KEY, name VARCHAR(255))",
+    ]
+  end
+
+  def self.build!
+    tables.each do |table|
+      ActiveRecord::Base.connection.execute(table)
+    end
+  end
+
+  def self.connect!
+    ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ":memory:"
+  end
+
+end

data/spec/support/models.rb

@@ -0,0 +1,17 @@
+class Contact < ActiveRecord::Base
+  has_many :addresses
+  has_one :email_address
+end
+
+class Address < ActiveRecord::Base
+  belongs_to :contact
+  belongs_to :country
+end
+
+class EmailAddress < ActiveRecord::Base
+  belongs_to :contact
+end
+
+class Country < ActiveRecord::Base
+  has_many :addresses
+end

metadata

@@ -0,0 +1,184 @@
+--- !ruby/object:Gem::Specification
+name: jit_preloader
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Kyle d'Oliveira
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: The JitPreloader has the ability to send notifications when N+1 queries
+  occur to help guage how problematic they are for your code base and a way to remove
+  all of the commons explicitly or automatically
+email:
+- kyle.doliveira@clio.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- jit_preloader.gemspec
+- lib/jit_preloader.rb
+- lib/jit_preloader/active_record/associations/collection_association.rb
+- lib/jit_preloader/active_record/associations/preloader/collection_association.rb
+- lib/jit_preloader/active_record/associations/preloader/singular_association.rb
+- lib/jit_preloader/active_record/associations/singular_association.rb
+- lib/jit_preloader/active_record/base.rb
+- lib/jit_preloader/active_record/query_methods.rb
+- lib/jit_preloader/active_record/relation.rb
+- lib/jit_preloader/preloader.rb
+- lib/jit_preloader/version.rb
+- spec/lib/jit_preloader/preloader_spec.rb
+- spec/spec_helper.rb
+- spec/support/database.rb
+- spec/support/models.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: Tool to understand N+1 queries and to remove them
+test_files:
+- spec/lib/jit_preloader/preloader_spec.rb
+- spec/spec_helper.rb
+- spec/support/database.rb
+- spec/support/models.rb