bullet_instructure 4.0.2

data/lib/bullet/active_record4.rb

@@ -0,0 +1,128 @@
+module Bullet
+  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::NPlusOneQuery.add_possible_objects(records)
+            Bullet::Detector::CounterCache.add_possible_objects(records)
+          elsif records.size == 1
+            Bullet::Detector::NPlusOneQuery.add_impossible_object(records.first)
+            Bullet::Detector::CounterCache.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_scope = nil)
+          origin_initialize(records, associations, preload_scope)
+          records = [records].flatten.compact.uniq
+          return if records.empty?
+          records.each do |record|
+            Bullet::Detector::Association.add_object_associations(record, associations)
+          end
+          Bullet::Detector::UnusedEagerLoading.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)
+          end
+          Bullet::Detector::UnusedEagerLoading.add_eager_loadings(records, associations)
+          records
+        end
+      end
+
+      ::ActiveRecord::Associations::JoinDependency.class_eval do
+        alias_method :origin_instantiate, :instantiate
+        alias_method :origin_construct_association, :construct_association
+
+        def instantiate(rows)
+          @bullet_eager_loadings = {}
+          records = origin_instantiate(rows)
+
+          @bullet_eager_loadings.each do |klazz, eager_loadings_hash|
+            objects = eager_loadings_hash.keys
+            Bullet::Detector::UnusedEagerLoading.add_eager_loadings(objects, eager_loadings_hash[objects.first].to_a)
+          end
+          records
+        end
+
+        # call join associations
+        def construct_association(record, join, row)
+          result = origin_construct_association(record, join, row)
+
+          associations = join.reflection.name
+          Bullet::Detector::Association.add_object_associations(record, associations)
+          Bullet::Detector::NPlusOneQuery.call_association(record, associations)
+          @bullet_eager_loadings[record.class] ||= {}
+          @bullet_eager_loadings[record.class][record] ||= Set.new
+          @bullet_eager_loadings[record.class][record] << associations
+
+          result
+        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
+
+        alias_method :origin_empty?, :empty?
+        def empty?
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name)
+          origin_empty?
+        end
+      end
+
+      ::ActiveRecord::Associations::SingularAssociation.class_eval do
+        # call has_one and belongs_to associations
+        alias_method :origin_reader, :reader
+        def reader(force_reload = false)
+          result = origin_reader(force_reload)
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name)
+          Bullet::Detector::NPlusOneQuery.add_possible_objects(result)
+          result
+        end
+      end
+
+      ::ActiveRecord::Associations::Association.class_eval do
+        alias_method :origin_set_inverse_instance, :set_inverse_instance
+        def set_inverse_instance(record)
+          if record && invertible_for?(record)
+            Bullet::Detector::NPlusOneQuery.add_impossible_object(record)
+          end
+          origin_set_inverse_instance(record)
+        end
+      end
+
+      ::ActiveRecord::Associations::HasManyAssociation.class_eval do
+        alias_method :origin_has_cached_counter?, :has_cached_counter?
+
+        def has_cached_counter?(reflection = reflection())
+          result = origin_has_cached_counter?(reflection)
+          Bullet::Detector::CounterCache.add_counter_cache(owner, reflection.name) unless result
+          result
+        end
+      end
+    end
+  end
+end

data/lib/bullet/active_record41.rb

@@ -0,0 +1,121 @@
+module Bullet
+  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.first.class.name !~ /^HABTM_/
+            if records.size > 1
+              Bullet::Detector::NPlusOneQuery.add_possible_objects(records)
+              Bullet::Detector::CounterCache.add_possible_objects(records)
+            elsif records.size == 1
+              Bullet::Detector::NPlusOneQuery.add_impossible_object(records.first)
+              Bullet::Detector::CounterCache.add_impossible_object(records.first)
+            end
+          end
+          records
+        end
+      end
+
+      ::ActiveRecord::Associations::Preloader.class_eval do
+        alias_method :origin_preloaders_on, :preloaders_on
+
+        def preloaders_on(association, records, scope)
+          if records.first.class.name !~ /^HABTM_/
+            records.each do |record|
+              Bullet::Detector::Association.add_object_associations(record, association)
+            end
+            Bullet::Detector::UnusedEagerLoading.add_eager_loadings(records, association)
+          end
+          origin_preloaders_on(association, records, scope)
+        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)
+          end
+          Bullet::Detector::UnusedEagerLoading.add_eager_loadings(records, associations)
+          records
+        end
+      end
+
+      ::ActiveRecord::Associations::JoinDependency.class_eval do
+        alias_method :origin_instantiate, :instantiate
+        alias_method :origin_construct_model, :construct_model
+
+        def instantiate(result_set, aliases)
+          @bullet_eager_loadings = {}
+          records = origin_instantiate(result_set, aliases)
+
+          @bullet_eager_loadings.each do |klazz, eager_loadings_hash|
+            objects = eager_loadings_hash.keys
+            Bullet::Detector::UnusedEagerLoading.add_eager_loadings(objects, eager_loadings_hash[objects.first].to_a)
+          end
+          records
+        end
+
+        # call join associations
+        def construct_model(record, node, row, model_cache, id, aliases)
+          result = origin_construct_model(record, node, row, model_cache, id, aliases)
+
+          associations = node.reflection.name
+          Bullet::Detector::Association.add_object_associations(record, associations)
+          Bullet::Detector::NPlusOneQuery.call_association(record, associations)
+          @bullet_eager_loadings[record.class] ||= {}
+          @bullet_eager_loadings[record.class][record] ||= Set.new
+          @bullet_eager_loadings[record.class][record] << associations
+
+          result
+        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) unless @inversed
+          origin_load_target
+        end
+
+        alias_method :origin_empty?, :empty?
+        def empty?
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name)
+          origin_empty?
+        end
+      end
+
+      ::ActiveRecord::Associations::SingularAssociation.class_eval do
+        # call has_one and belongs_to associations
+        alias_method :origin_reader, :reader
+        def reader(force_reload = false)
+          result = origin_reader(force_reload)
+          if @owner.class.name !~ /^HABTM_/
+            Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name) unless @inversed
+            Bullet::Detector::NPlusOneQuery.add_possible_objects(result)
+          end
+          result
+        end
+      end
+
+      ::ActiveRecord::Associations::HasManyAssociation.class_eval do
+        alias_method :origin_has_cached_counter?, :has_cached_counter?
+
+        def has_cached_counter?(reflection = reflection())
+          result = origin_has_cached_counter?(reflection)
+          Bullet::Detector::CounterCache.add_counter_cache(owner, reflection.name) unless result
+          result
+        end
+      end
+    end
+  end
+end

data/lib/bullet/dependency.rb

@@ -0,0 +1,81 @@
+module Bullet
+  module Dependency
+    def mongoid?
+      @mongoid ||= defined? ::Mongoid
+    end
+
+    def active_record?
+      @active_record ||= defined? ::ActiveRecord
+    end
+
+    def rails?
+      @rails ||= defined? ::Rails
+    end
+
+    def active_record_version
+      @active_record_version ||= begin
+                                   if active_record30?
+                                     'active_record3'
+                                   elsif active_record31? || active_record32?
+                                     'active_record3x'
+                                   elsif active_record40?
+                                     'active_record4'
+                                   elsif active_record41?
+                                     'active_record41'
+                                   end
+                                 end
+    end
+
+    def mongoid_version
+      @mongoid_version ||= begin
+                             if mongoid2x?
+                               'mongoid2x'
+                             elsif mongoid3x?
+                               'mongoid3x'
+                             elsif mongoid4x?
+                               'mongoid4x'
+                             end
+                           end
+    end
+
+    def active_record3?
+      active_record? && ::ActiveRecord::VERSION::MAJOR == 3
+    end
+
+    def active_record4?
+      active_record? && ::ActiveRecord::VERSION::MAJOR == 4
+    end
+
+    def active_record30?
+      active_record3? && ::ActiveRecord::VERSION::MINOR == 0
+    end
+
+    def active_record31?
+      active_record3? && ::ActiveRecord::VERSION::MINOR == 1
+    end
+
+    def active_record32?
+      active_record3? && ::ActiveRecord::VERSION::MINOR == 2
+    end
+
+    def active_record40?
+      active_record4? && ::ActiveRecord::VERSION::MINOR == 0
+    end
+
+    def active_record41?
+      active_record4? && ::ActiveRecord::VERSION::MINOR == 1
+    end
+
+    def mongoid2x?
+      mongoid? && ::Mongoid::VERSION =~ /\A2\.[4-8]/
+    end
+
+    def mongoid3x?
+      mongoid? && ::Mongoid::VERSION =~ /\A3/
+    end
+
+    def mongoid4x?
+      mongoid? && ::Mongoid::VERSION =~ /\A4/
+    end
+  end
+end

data/lib/bullet/detector.rb

@@ -0,0 +1,9 @@
+module Bullet
+  module Detector
+    autoload :Base, 'bullet/detector/base'
+    autoload :Association, 'bullet/detector/association'
+    autoload :NPlusOneQuery, 'bullet/detector/n_plus_one_query'
+    autoload :UnusedEagerLoading, 'bullet/detector/unused_eager_loading'
+    autoload :CounterCache, 'bullet/detector/counter_cache'
+  end
+end

data/lib/bullet/detector/association.rb

@@ -0,0 +1,67 @@
+module Bullet
+  module Detector
+    class Association < Base
+      class <<self
+        def add_object_associations(object, associations)
+          return unless Bullet.start?
+          return if !Bullet.n_plus_one_query_enable? && !Bullet.unused_eager_loading_enable?
+          return unless object.id
+
+          Bullet.debug("Detector::Association#add_object_associations", "object: #{object.bullet_key}, associations: #{associations}")
+          object_associations.add(object.bullet_key, associations)
+        end
+
+        def add_call_object_associations(object, associations)
+          return unless Bullet.start?
+          return if !Bullet.n_plus_one_query_enable? && !Bullet.unused_eager_loading_enable?
+          return unless object.id
+
+          Bullet.debug("Detector::Association#add_call_object_associations", "object: #{object.bullet_key}, associations: #{associations}")
+          call_object_associations.add(object.bullet_key, associations)
+        end
+
+        private
+          # object_associations keep the object relationships
+          # that the object has many associations.
+          # e.g. { "Post:1" => [:comments] }
+          # the object_associations keep all associations that may be or may no be
+          # unpreload associations or unused preload associations.
+          def object_associations
+            Thread.current[:bullet_object_associations]
+          end
+
+          # call_object_associations keep the object relationships
+          # that object.associations is called.
+          # e.g. { "Post:1" => [:comments] }
+          # they are used to detect unused preload associations.
+          def call_object_associations
+            Thread.current[:bullet_call_object_associations]
+          end
+
+          # possible_objects keep the class to object relationships
+          # that the objects may cause N+1 query.
+          # e.g. { Post => ["Post:1", "Post:2"] }
+          def possible_objects
+            Thread.current[:bullet_possible_objects]
+          end
+
+          # impossible_objects keep the class to objects relationships
+          # that the objects may not cause N+1 query.
+          # e.g. { Post => ["Post:1", "Post:2"] }
+          # Notice: impossible_objects are not accurate,
+          # if find collection returns only one object, then the object is impossible object,
+          # impossible_objects are used to avoid treating 1+1 query to N+1 query.
+          def impossible_objects
+            Thread.current[:bullet_impossible_objects]
+          end
+
+          # eager_loadings keep the object relationships
+          # that the associations are preloaded by find :include.
+          # e.g. { ["Post:1", "Post:2"] => [:comments, :user] }
+          def eager_loadings
+            Thread.current[:bullet_eager_loadings]
+          end
+      end
+    end
+  end
+end

data/lib/bullet/detector/base.rb

@@ -0,0 +1,6 @@
+module Bullet
+  module Detector
+    class Base
+    end
+  end
+end

data/lib/bullet/detector/counter_cache.rb

@@ -0,0 +1,59 @@
+module Bullet
+  module Detector
+    class CounterCache < Base
+      class <<self
+        def add_counter_cache(object, associations)
+          return unless Bullet.start?
+          return unless Bullet.counter_cache_enable?
+          return unless object.id
+
+          Bullet.debug("Detector::CounterCache#add_counter_cache", "object: #{object.bullet_key}, associations: #{associations}")
+          if conditions_met?(object.bullet_key, associations)
+            create_notification object.class.to_s, associations
+          end
+        end
+
+        def add_possible_objects(object_or_objects)
+          return unless Bullet.start?
+          return unless Bullet.counter_cache_enable?
+          objects = Array(object_or_objects)
+          return if objects.map(&:id).compact.empty?
+
+          Bullet.debug("Detector::CounterCache#add_possible_objects", "objects: #{objects.map(&:bullet_key).join(', ')}")
+          objects.each { |object| possible_objects.add object.bullet_key }
+        end
+
+        def add_impossible_object(object)
+          return unless Bullet.start?
+          return unless Bullet.counter_cache_enable?
+          return unless object.id
+
+          Bullet.debug("Detector::CounterCache#add_impossible_object", "object: #{object.bullet_key}")
+          impossible_objects.add object.bullet_key
+        end
+
+        private
+          def create_notification(klazz, associations)
+            notify_associations = Array(associations) - Bullet.get_whitelist_associations(:counter_cache, klazz)
+
+            if notify_associations.present?
+              notice = Bullet::Notification::CounterCache.new klazz, notify_associations
+              Bullet.notification_collector.add notice
+            end
+          end
+
+          def possible_objects
+            Thread.current[:bullet_counter_possible_objects]
+          end
+
+          def impossible_objects
+            Thread.current[:bullet_counter_impossible_objects]
+          end
+
+          def conditions_met?(bullet_key, associations)
+            possible_objects.include?(bullet_key) && !impossible_objects.include?(bullet_key)
+          end
+      end
+    end
+  end
+end