bullet 2.0.0 → 2.1.0

data/bullet.gemspec

@@ -0,0 +1,24 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require "bullet/version"
+
+Gem::Specification.new do |s|
+  s.name        = "bullet"
+  s.version     = Bullet::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Richard Huang"]
+  s.email       = ["flyerhzm@gmail.com"]
+  s.homepage    = "http://github.com/flyerhzm/bullet"
+  s.summary     = "A rails plugin to kill N+1 queries and unused eager loading."
+  s.description = "A rails plugin to kill N+1 queries and unused eager loading."
+
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.add_dependency "uniform_notifier", "~> 1.0.0"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+end
+

data/lib/bullet/action_controller2.rb

@@ -3,7 +3,7 @@ module Bullet
     def self.enable
       require 'action_controller'
       case Rails.version
-      when /^2.3/  
+      when /^2.3/
         ::ActionController::Dispatcher.middleware.use Bullet::Rack
         ::ActionController::Dispatcher.class_eval do
           class <<self
@@ -22,20 +22,20 @@ module Bullet
             Bullet.clear
           end
         end
-        
+
         ::ActionController::Base.class_eval do
           alias_method :origin_process, :process
           def process(request, response, method = :perform_action, *arguments)
             Bullet.start_request
             response = origin_process(request, response, method = :perform_action, *arguments)
-            
+
             if Bullet.notification?
               if response.headers["type"] and response.headers["type"].include? 'text/html' and response.body =~ %r{<html.*</html>}m
                 response.body <<= Bullet.gather_inline_notifications
                 response.headers["Content-Length"] = response.body.length.to_s
               end
-            
-              Bullet.perform_bullet_out_of_channel_notifications
+
+              Bullet.perform_out_of_channel_notifications
             end
             Bullet.end_request
             response

data/lib/bullet/active_record2.rb

@@ -1,4 +1,5 @@
 module Bullet
+  LOAD_TARGET_RGX = /load_target/
   module ActiveRecord
     def self.enable
       require 'active_record'
@@ -81,7 +82,7 @@ module Bullet
         def load_target
           # avoid stack level too deep
           result = origin_load_target
-          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name) unless caller.to_s.include? 'load_target'
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name) unless caller.find {|c| c =~ LOAD_TARGET_RGX }
           Bullet::Detector::Association.add_possible_objects(result)
           result
         end

data/lib/bullet/active_record3.rb

@@ -1,4 +1,5 @@
 module Bullet
+  LOAD_TARGET_RGX = /load_target/
   module ActiveRecord
     def self.enable
       require 'active_record'
@@ -75,7 +76,7 @@ module Bullet
         def load_target
           # avoid stack level too deep
           result = origin_load_target
-          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name) unless caller.to_s.include? 'load_target'
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name) unless caller.find {|c| c =~ LOAD_TARGET_RGX }
           Bullet::Detector::Association.add_possible_objects(result)
           result
         end

data/lib/bullet/active_record31.rb

@@ -0,0 +1,96 @@
+module Bullet
+  LOAD_TARGET_RGX = /load_target/
+  module ActiveRecord
+    def self.enable
+      require 'active_record'
+      ::ActiveRecord::Relation.class_eval do
+        alias_method :origin_to_a, :to_a
+        # if select a collection of objects, then these objects have possible to cause N+1 query.
+        # if select only one object, then the only one object has impossible to cause N+1 query.
+        def to_a
+          records = origin_to_a
+          if records.size > 1
+            Bullet::Detector::Association.add_possible_objects(records)
+            Bullet::Detector::Counter.add_possible_objects(records)
+          elsif records.size == 1
+            Bullet::Detector::Association.add_impossible_object(records.first)
+            Bullet::Detector::Counter.add_impossible_object(records.first)
+          end
+          records
+        end
+      end
+
+      ::ActiveRecord::Associations::Preloader.class_eval do
+        # include query for one to many associations.
+        # keep this eager loadings.
+        alias_method :origin_initialize, :initialize
+        def initialize(records, associations, preload_options = {})
+          origin_initialize(records, associations, preload_options)
+          records = [records].flatten.compact.uniq
+          return if records.empty?
+          records.each do |record|
+            Bullet::Detector::Association.add_object_associations(record, associations)
+          end
+          Bullet::Detector::Association.add_eager_loadings(records, associations)
+        end
+      end
+
+      ::ActiveRecord::FinderMethods.class_eval do
+        # add includes in scope
+        alias_method :origin_find_with_associations, :find_with_associations
+        def find_with_associations
+          records = origin_find_with_associations
+          associations = (@eager_load_values + @includes_values).uniq
+          records.each do |record|
+            Bullet::Detector::Association.add_object_associations(record, associations)
+            Bullet::Detector::NPlusOneQuery.call_association(record, associations)
+          end
+          Bullet::Detector::Association.add_eager_loadings(records, associations)
+          records
+        end
+      end
+
+      ::ActiveRecord::Associations::JoinDependency.class_eval do
+        alias_method :origin_construct_association, :construct_association
+        # call join associations
+        def construct_association(record, join, row)
+          associations = join.reflection.name
+          Bullet::Detector::Association.add_object_associations(record, associations)
+          Bullet::Detector::NPlusOneQuery.call_association(record, associations)
+          origin_construct_association(record, join, row)
+        end
+      end
+
+      ::ActiveRecord::Associations::CollectionAssociation.class_eval do
+        # call one to many associations
+        alias_method :origin_load_target, :load_target
+        def load_target
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name)
+          origin_load_target
+        end
+      end
+      
+      ::ActiveRecord::Associations::Association.class_eval do
+        # call has_one and belong_to association
+        alias_method :origin_load_target, :load_target
+        def load_target
+          # avoid stack level too deep
+          result = origin_load_target
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name) unless caller.find {|c| c =~ LOAD_TARGET_RGX }
+          Bullet::Detector::Association.add_possible_objects(result)
+          result
+        end
+      end
+
+      ::ActiveRecord::Associations::HasManyAssociation.class_eval do
+        alias_method :origin_has_cached_counter?, :has_cached_counter?
+
+        def has_cached_counter?
+          result = origin_has_cached_counter?
+          Bullet::Detector::Counter.add_counter_cache(@owner, @reflection.name) unless result
+          result
+        end
+      end
+    end
+  end
+end

data/lib/bullet/detector/association.rb

@@ -39,25 +39,35 @@ module Bullet
         def add_eager_loadings(objects, associations)
           objects = Array(objects)
 
+          to_add = nil
+          to_merge, to_delete = [], []
           eager_loadings.each do |k, v|
             key_objects_overlap = k & objects
 
             next if key_objects_overlap.empty?
 
             if key_objects_overlap == k
-              eager_loadings.add k, associations
+              to_add = [k, associations]
               break
 
             else
-              eager_loadings.merge key_objects_overlap, ( eager_loadings[k].dup  << associations )
+              to_merge << [key_objects_overlap, ( eager_loadings[k].dup  << associations )]
 
               keys_without_objects = k - objects
-              eager_loadings.merge keys_without_objects, eager_loadings[k] unless keys_without_objects.empty?
-
-              eager_loadings.delete(k)
+              to_merge << [keys_without_objects, eager_loadings[k]]
+              to_delete << k
               objects = objects - k
             end
           end
+          if to_add
+            eager_loadings.add *to_add
+          end
+          to_merge.each do |k,val|
+            eager_loadings.merge k, val
+          end
+          to_delete.each do |k|
+            eager_loadings.delete k
+          end
 
           eager_loadings.add objects, associations unless objects.empty?
         end
@@ -73,15 +83,14 @@ module Bullet
 
           # check if object => associations already exists in object_associations.
           def association?(object, associations)
-            object_associations.each do |key, value|
-              next unless key == object
-
+            value = object_associations[object]
+            if value
               value.each do |v|
                 result = v.is_a?(Hash) ? v.has_key?(associations) : v == associations
                 return true if result
               end
-
             end
+
             return false
           end
 

data/lib/bullet/detector/base.rb

@@ -7,13 +7,6 @@ module Bullet
       def self.end_request
         clear
       end
-
-      protected
-      def self.unique( array )
-        array.flatten!
-        array.uniq!
-      end
-
     end
   end
 end

data/lib/bullet/detector/unused_eager_association.rb

@@ -23,11 +23,13 @@ module Bullet
       end
 
       def self.call_object_association( object, association )
-        eager_loadings.similarly_associated( object, association ).
-                       collect { |related_object| call_object_associations[related_object] }.
-                       compact.
-                       flatten.
-                       uniq
+        all = Set.new
+        eager_loadings.similarly_associated( object, association ).each do |related_object|
+            coa = call_object_associations[related_object]
+            next if coa.nil?
+            all.merge coa
+        end
+        all.to_a
       end
 
       def self.diff_object_association( object, association )

data/lib/bullet/notification/base.rb

@@ -1,7 +1,7 @@
 module Bullet
   module Notification
     class Base
-      attr_accessor :notifier
+      attr_accessor :notifier, :url
       attr_reader :base_class, :associations, :path
 
       def initialize( base_class, associations, path = nil )
@@ -15,6 +15,10 @@ module Bullet
 
       def body
       end
+      
+      def whoami
+        "user: " << `whoami`.chomp
+      end
 
       def body_with_caller
         body
@@ -25,7 +29,7 @@ module Bullet
       end
 
       def full_notice
-        @full_notice ||= title + "\n" + body_with_caller
+        [whoami, url, title, body_with_caller].compact.join("\n")
       end
 
       def notify_inline

data/lib/bullet/rack.rb

@@ -16,7 +16,7 @@ module Bullet
           response_body = response.body << Bullet.gather_inline_notifications
           headers['Content-Length'] = response_body.length.to_s
         end
-        Bullet.perform_out_of_channel_notifications
+        Bullet.perform_out_of_channel_notifications(env)
       end
       response_body ||= response.body
       Bullet.end_request

data/lib/bullet/registry/association.rb

@@ -3,13 +3,12 @@ module Bullet
     class Association < Base
       def merge( base, associations )
         @registry.merge!( { base => associations } )
-        unique( @registry[base] )
       end
 
       def similarly_associated( base, associations )
         @registry.select do |key, value|
           key.include?( base ) and value == associations
-        end.collect( &:first ).flatten!
+        end.collect( &:first ).flatten
       end
     end
   end

data/lib/bullet/registry/base.rb

@@ -24,16 +24,14 @@ module Bullet
       end
 
       def add( key, value )
-        @registry[key] ||= []
-        @registry[key] << value
-        unique( @registry[key] )
+        @registry[key] ||= Set.new
+        if value.is_a? Array
+          @registry[key] += value
+        else
+          @registry[key] << value
+        end
       end
 
-      private
-      def unique( array )
-        array.flatten!
-        array.uniq!
-      end
     end
   end
 end

data/lib/bullet/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 module Bullet
-  VERSION = "2.0.0"
+  VERSION = "2.1.0"
 end
 

data/lib/bullet.rb

@@ -1,10 +1,11 @@
 require 'set'
+require 'uniform_notifier'
 
 module Bullet
-  class NotificationError < StandardError; end
-
-  if Rails.version =~ /^3.0/
+  if Rails.version =~ /^3\.0/
     autoload :ActiveRecord, 'bullet/active_record3'
+  elsif Rails.version =~ /^3\.1/
+    autoload :ActiveRecord, 'bullet/active_record31'
   else
     autoload :ActiveRecord, 'bullet/active_record2'
     autoload :ActionController, 'bullet/action_controller2'
@@ -17,7 +18,6 @@ module Bullet
   autoload :NotificationCollector, 'bullet/notification_collector'
 
   if defined? Rails::Railtie
-    # compatible with rails 3.0.0.beta4
     class BulletRailtie < Rails::Railtie
       initializer "bullet.configure_rails_initialization" do |app|
         app.middleware.use Bullet::Rack
@@ -87,8 +87,9 @@ module Bullet
       responses.join( "\n" )
     end
 
-    def perform_out_of_channel_notifications
+    def perform_out_of_channel_notifications(env = {})
       for_each_active_notifier_with_notification do |notification|
+        notification.url = [env['HTTP_HOST'], env['REQUEST_URI']].compact.join
         notification.notify_out_of_channel
       end
     end

data/perf/benchmark.rb

@@ -0,0 +1,106 @@
+$: << 'lib'
+require 'benchmark'
+require 'rails'
+require 'active_record'
+require 'activerecord-import'
+require 'bullet'
+
+begin
+  require 'perftools'
+rescue LoadError
+  puts "Could not load perftools.rb, profiling won't be possible"
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :user
+  has_many :comments
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :post
+end
+
+class User < ActiveRecord::Base
+  has_many :posts
+  has_many :comments
+end
+
+# create database bullet_benchmark;
+ActiveRecord::Base.establish_connection(:adapter => 'mysql', :database => 'bullet_benchmark', :server => '/tmp/mysql.socket', :username => 'root')
+
+ActiveRecord::Base.connection.tables.each do |table|
+  ActiveRecord::Base.connection.drop_table(table)
+end
+
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :posts do |t|
+    t.column :title, :string
+    t.column :body, :string
+    t.column :user_id, :integer
+  end
+
+  create_table :comments do |t|
+    t.column :body, :string
+    t.column :post_id, :integer
+    t.column :user_id, :integer
+  end
+
+  create_table :users do |t|
+    t.column :name, :string
+  end
+end
+
+users_size = 100
+posts_size = 1000
+comments_size = 10000
+users = []
+users_size.times do |i|
+  users << User.new(:name => "user#{i}")
+end
+User.import users
+users = User.all
+
+posts = []
+posts_size.times do |i|
+  posts << Post.new(:title => "Title #{i}", :body => "Body #{i}", :user => users[i%100])
+end
+Post.import posts
+posts = Post.all
+
+comments = []
+comments_size.times do |i|
+  comments << Comment.new(:body => "Comment #{i}", :post => posts[i%1000], :user => users[i%100])
+end
+Comment.import comments
+
+puts "Start benchmarking..."
+
+
+Bullet.enable = true
+
+PerfTools::CpuProfiler.start(ARGV[0]|| "benchmark_profile") if defined? PerfTools
+
+Benchmark.bm(70) do |bm|
+  bm.report("Querying & Iterating #{posts_size} Posts with #{comments_size} Comments and #{users_size} Users") do
+    Bullet.start_request
+    Post.select("SQL_NO_CACHE *").includes(:user, :comments => :user).each do |p|
+      p.title
+      p.user.name
+      p.comments.each do |c|
+        c.body
+        c.user.name
+      end
+    end
+    Bullet.end_request
+  end
+end
+
+PerfTools::CpuProfiler.stop if defined? PerfTools
+puts "End benchmarking..."
+
+
+# 2.0.1
+#                                                                             user     system      total        real
+# Querying & Iterating 100 Posts with 10000 Comments and 100 Users        2.290000   0.050000   2.340000 (  2.366174)
+

data/rails/init.rb

@@ -0,0 +1 @@
+require 'bullet'

data/spec/bullet/association_for_chris_spec.rb

@@ -0,0 +1,96 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+# This test is just used for http://github.com/flyerhzm/bullet/issues/#issue/14
+describe Bullet::Detector::Association do
+
+  describe "for chris" do
+    def setup_db
+      ActiveRecord::Schema.define(:version => 1) do
+        create_table :locations do |t|
+          t.column :name, :string
+        end
+
+        create_table :hotels do |t|
+          t.column :name, :string
+          t.column :location_id, :integer
+        end
+
+        create_table :deals do |t|
+          t.column :name, :string
+          t.column :hotel_id, :integer
+        end
+      end
+    end
+
+    def teardown_db
+      ActiveRecord::Base.connection.tables.each do |table|
+        ActiveRecord::Base.connection.drop_table(table)
+      end
+    end
+
+    class Location < ActiveRecord::Base
+      has_many :hotels
+    end
+  
+    class Hotel < ActiveRecord::Base
+      belongs_to :location
+      has_many :deals
+    end
+  
+    class Deal < ActiveRecord::Base
+      belongs_to :hotel
+      has_one :location, :through => :hotel
+    end
+
+    before(:all) do
+      setup_db
+    
+      location1 = Location.create(:name => "location1")
+      location2 = Location.create(:name => "location2")
+    
+      hotel1 = location1.hotels.create(:name => "hotel1")
+      hotel2 = location1.hotels.create(:name => "hotel2")
+      hotel3 = location2.hotels.create(:name => "hotel3")
+      hotel4 = location2.hotels.create(:name => "hotel4")
+    
+      deal1 = hotel1.deals.create(:name => "deal1")
+      deal2 = hotel2.deals.create(:name => "deal2")
+      deal3 = hotel3.deals.create(:name => "deal3")
+      deal4 = hotel4.deals.create(:name => "deal4")
+    end
+
+    after(:all) do
+      teardown_db
+    end
+
+    before(:each) do
+      Bullet.start_request
+    end
+
+    after(:each) do
+      Bullet.end_request
+    end
+  
+    it "should detect unpreload association from deal to hotel" do
+      Deal.all.each do |deal|
+        deal.hotel.location.name
+      end
+      Bullet::Detector::Association.should be_detecting_unpreloaded_association_for(Deal, :hotel)
+    end
+  
+    it "should detect unpreload association from hotel to location" do
+      Deal.includes(:hotel).each do |deal|
+        deal.hotel.location.name
+      end
+      Bullet::Detector::Association.should be_detecting_unpreloaded_association_for(Hotel, :location)
+    end
+  
+    it "should not detect unpreload association" do
+      Deal.includes({:hotel => :location}).each do |deal|
+        deal.hotel.location.name
+      end
+      Bullet::Detector::Association.should_not be_has_unused_preload_associations
+    end
+  end
+end