bullet 2.0.1 → 2.1.0

data/Rakefile

@@ -0,0 +1,45 @@
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "bundler"
+Bundler.setup
+
+require "rake"
+require "rdoc/task"
+require "rspec"
+require "rspec/core/rake_task"
+
+require "bullet/version"
+
+task :build do
+  system "gem build bullet.gemspec"
+end
+
+task :install => :build do
+  system "sudo gem install bullet-#{Bullet::VERSION}.gem"
+end
+
+task :release => :build do
+  puts "Tagging #{Bullet::VERSION}..."
+  system "git tag -a #{Bullet::VERSION} -m 'Tagging #{Bullet::VERSION}'"
+  puts "Pushing to Github..."
+  system "git push --tags"
+  puts "Pushing to rubygems.org..."
+  system "gem push bullet-#{Bullet::VERSION}.gem"
+end
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = "spec/**/*_spec.rb"
+end
+
+RSpec::Core::RakeTask.new('spec:progress') do |spec|
+  spec.rspec_opts = %w(--format progress)
+  spec.pattern = "spec/**/*_spec.rb"
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title = "bullet #{Bullet::VERSION}"
+  rdoc.rdoc_files.include("README*")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+task :default => :spec

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.rb

@@ -2,10 +2,10 @@ 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'
@@ -18,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
@@ -88,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/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.1"
+  VERSION = "2.1.0"
 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)
+