bullet 4.0.0 → 4.13.1

data/lib/bullet/detector/n_plus_one_query.rb

@@ -1,48 +1,89 @@
 module Bullet
   module Detector
     class NPlusOneQuery < Association
+      extend Dependency
+
       class <<self
         # executed when object.assocations is called.
         # first, it keeps this method call for object.association.
         # then, it checks if this associations call is unpreload.
         #   if it is, keeps this unpreload associations and caller.
         def call_association(object, associations)
-          @@checked = true
+          return unless Bullet.start?
+          return unless object.primary_key_value
+          return if inversed_objects.include?(object.bullet_key, associations)
           add_call_object_associations(object, associations)
 
-          if conditions_met?(object.bullet_ar_key, associations)
+          Bullet.debug("Detector::NPlusOneQuery#call_association", "object: #{object.bullet_key}, associations: #{associations}")
+          if conditions_met?(object.bullet_key, associations)
+            Bullet.debug("detect n + 1 query", "object: #{object.bullet_key}, associations: #{associations}")
             create_notification caller_in_project, object.class.to_s, associations
           end
         end
 
+        def add_possible_objects(object_or_objects)
+          return unless Bullet.start?
+          return unless Bullet.n_plus_one_query_enable?
+          objects = Array(object_or_objects)
+          return if objects.map(&:primary_key_value).compact.empty?
+
+          Bullet.debug("Detector::NPlusOneQuery#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.n_plus_one_query_enable?
+          return unless object.primary_key_value
+
+          Bullet.debug("Detector::NPlusOneQuery#add_impossible_object", "object: #{object.bullet_key}")
+          impossible_objects.add object.bullet_key
+        end
+
+        def add_inversed_object(object, association)
+          return unless Bullet.start?
+          return unless Bullet.n_plus_one_query_enable?
+          return unless object.primary_key_value
+
+          Bullet.debug("Detector::NPlusOneQuery#add_inversed_object", "object: #{object.bullet_key}, association: #{association}")
+          inversed_objects.add object.bullet_key, association
+        end
+
         private
           def create_notification(callers, klazz, associations)
-            notice = Bullet::Notification::NPlusOneQuery.new(callers, klazz, associations)
-            Bullet.notification_collector.add(notice)
+            notify_associations = Array(associations) - Bullet.get_whitelist_associations(:n_plus_one_query, klazz)
+
+            if notify_associations.present?
+              notice = Bullet::Notification::NPlusOneQuery.new(callers, klazz, notify_associations)
+              Bullet.notification_collector.add(notice)
+            end
           end
 
           # decide whether the object.associations is unpreloaded or not.
-          def conditions_met?(bullet_ar_key, associations)
-            possible?(bullet_ar_key) && !impossible?(bullet_ar_key) && !association?(bullet_ar_key, associations)
+          def conditions_met?(bullet_key, associations)
+            possible?(bullet_key) && !impossible?(bullet_key) && !association?(bullet_key, associations)
           end
 
           def caller_in_project
-            rails_root = Rails.root.to_s
-            vendor_root = rails_root + "/vendor"
-            caller.select { |c| c.include?(rails_root) && !c.include?(vendor_root) }
+            app_root = rails? ? Rails.root.to_s : Dir.pwd
+            vendor_root = app_root + "/vendor"
+            caller.select do |c|
+              c.include?(app_root) && !c.include?(vendor_root) ||
+              Bullet.stacktrace_includes.any? { |include| c.include?(include) }
+            end
           end
 
-          def possible?(bullet_ar_key)
-            possible_objects.include? bullet_ar_key
+          def possible?(bullet_key)
+            possible_objects.include? bullet_key
           end
 
-          def impossible?(bullet_ar_key)
-            impossible_objects.include? bullet_ar_key
+          def impossible?(bullet_key)
+            impossible_objects.include? bullet_key
           end
 
           # check if object => associations already exists in object_associations.
-          def association?(bullet_ar_key, associations)
-            value = object_associations[bullet_ar_key]
+          def association?(bullet_key, associations)
+            value = object_associations[bullet_key]
             if value
               value.each do |v|
                 result = v.is_a?(Hash) ? v.has_key?(associations) : v == associations

data/lib/bullet/detector/unused_eager_loading.rb

@@ -0,0 +1,84 @@
+module Bullet
+  module Detector
+    class UnusedEagerLoading < Association
+      class <<self
+        # check if there are unused preload associations.
+        #   get related_objects from eager_loadings associated with object and associations
+        #   get call_object_association from associations of call_object_associations whose object is in related_objects
+        #   if association not in call_object_association, then the object => association - call_object_association is ununsed preload assocations
+        def check_unused_preload_associations
+          return unless Bullet.start?
+          return unless Bullet.unused_eager_loading_enable?
+
+          object_associations.each do |bullet_key, associations|
+            object_association_diff = diff_object_associations bullet_key, associations
+            next if object_association_diff.empty?
+
+            Bullet.debug("detect unused preload", "object: #{bullet_key}, associations: #{object_association_diff}")
+            create_notification bullet_key.bullet_class_name, object_association_diff
+          end
+        end
+
+        def add_eager_loadings(objects, associations)
+          return unless Bullet.start?
+          return unless Bullet.unused_eager_loading_enable?
+          return if objects.map(&:primary_key_value).compact.empty?
+
+          Bullet.debug("Detector::UnusedEagerLoading#add_eager_loadings", "objects: #{objects.map(&:bullet_key).join(', ')}, associations: #{associations}")
+          bullet_keys = objects.map(&:bullet_key)
+
+          to_add = nil
+          to_merge, to_delete = [], []
+          eager_loadings.each do |k, v|
+            key_objects_overlap = k & bullet_keys
+
+            next if key_objects_overlap.empty?
+
+            if key_objects_overlap == k
+              to_add = [k, associations]
+              break
+            else
+              to_merge << [key_objects_overlap, ( eager_loadings[k].dup  << associations )]
+
+              keys_without_objects = k - bullet_keys
+              to_merge << [keys_without_objects, eager_loadings[k]]
+              to_delete << k
+              bullet_keys = bullet_keys - k
+            end
+          end
+
+          eager_loadings.add *to_add if to_add
+          to_merge.each { |k,val| eager_loadings.merge k, val }
+          to_delete.each { |k| eager_loadings.delete k }
+
+          eager_loadings.add bullet_keys, associations unless bullet_keys.empty?
+        end
+
+        private
+          def create_notification(klazz, associations)
+            notify_associations = Array(associations) - Bullet.get_whitelist_associations(:unused_eager_loading, klazz)
+
+            if notify_associations.present?
+              notice = Bullet::Notification::UnusedEagerLoading.new(klazz, notify_associations)
+              Bullet.notification_collector.add(notice)
+            end
+          end
+
+          def call_associations(bullet_key, associations)
+            all = Set.new
+            eager_loadings.similarly_associated(bullet_key, associations).each do |related_bullet_key|
+              coa = call_object_associations[related_bullet_key]
+              next if coa.nil?
+              all.merge coa
+            end
+            all.to_a
+          end
+
+          def diff_object_associations(bullet_key, associations)
+            potential_associations = associations - call_associations(bullet_key, associations)
+            potential_associations.reject { |a| a.is_a?(Hash) }
+          end
+      end
+    end
+  end
+end

data/lib/bullet/detector.rb

@@ -3,7 +3,7 @@ module Bullet
     autoload :Base, 'bullet/detector/base'
     autoload :Association, 'bullet/detector/association'
     autoload :NPlusOneQuery, 'bullet/detector/n_plus_one_query'
-    autoload :UnusedEagerAssociation, 'bullet/detector/unused_eager_association'
-    autoload :Counter, 'bullet/detector/counter'
+    autoload :UnusedEagerLoading, 'bullet/detector/unused_eager_loading'
+    autoload :CounterCache, 'bullet/detector/counter_cache'
   end
 end

data/lib/bullet/ext/object.rb

@@ -1,5 +1,13 @@
 class Object
-  def bullet_ar_key
-    "#{self.class}:#{self.id}"
+  def bullet_key
+    [self.class, self.primary_key_value].join(':')
+  end
+
+  def primary_key_value
+    if self.class.respond_to?(:primary_key) && self.class.primary_key
+      self.send self.class.primary_key
+    else
+      self.id
+    end
   end
 end

data/lib/bullet/{mongoid.rb → mongoid2x.rb}

@@ -2,55 +2,55 @@ module Bullet
   module Mongoid
     def self.enable
       require 'mongoid'
+
       ::Mongoid::Contexts::Mongo.class_eval do
         alias_method :origin_first, :first
         alias_method :origin_last, :last
         alias_method :origin_iterate, :iterate
+        alias_method :origin_eager_load, :eager_load
 
         def first
           result = origin_first
-          Bullet::Detector::Association.add_impossible_object(result)
+          Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
           result
         end
 
         def last
           result = origin_last
-          Bullet::Detector::Association.add_impossible_object(result)
+          Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
           result
         end
 
         def iterate(&block)
           records = execute.to_a
           if records.size > 1
-            Bullet::Detector::Association.add_possible_objects(records)
+            Bullet::Detector::NPlusOneQuery.add_possible_objects(records)
           elsif records.size == 1
-            Bullet::Detector::Association.add_impossible_object(records.first)
+            Bullet::Detector::NPlusOneQuery.add_impossible_object(records.first)
           end
           origin_iterate(&block)
         end
-      end
-
-      ::Mongoid::Relations::Accessors.class_eval do
-        alias_method :origin_set_relation, :set_relation
-
-        def set_relation(name, relation)
-          Bullet::Detector::NPlusOneQuery.call_association(self, name)
-          origin_set_relation(name, relation)
-        end
-      end
-
-      ::Mongoid::Contexts::Mongo.class_eval do
-        alias_method :origin_eager_load, :eager_load
 
         def eager_load(docs)
           associations = criteria.inclusions.map(&:name)
           docs.each do |doc|
             Bullet::Detector::Association.add_object_associations(doc, associations)
           end
-          Bullet::Detector::Association.add_eager_loadings(docs, associations)
+          Bullet::Detector::UnusedEagerLoading.add_eager_loadings(docs, associations)
           origin_eager_load(docs)
         end
       end
+
+      ::Mongoid::Relations::Accessors.class_eval do
+        alias_method :origin_set_relation, :set_relation
+
+        def set_relation(name, relation)
+          if relation && relation.metadata.macro !~ /embed/
+            Bullet::Detector::NPlusOneQuery.call_association(self, name)
+          end
+          origin_set_relation(name, relation)
+        end
+      end
     end
   end
 end

data/lib/bullet/mongoid3x.rb

@@ -0,0 +1,56 @@
+module Bullet
+  module Mongoid
+    def self.enable
+      require 'mongoid'
+      ::Mongoid::Contextual::Mongo.class_eval do
+        alias_method :origin_first, :first
+        alias_method :origin_last, :last
+        alias_method :origin_each, :each
+        alias_method :origin_eager_load, :eager_load
+
+        def first
+          result = origin_first
+          Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
+          result
+        end
+
+        def last
+          result = origin_last
+          Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
+          result
+        end
+
+        def each(&block)
+          records = query.map{ |doc| ::Mongoid::Factory.from_db(klass, doc) }
+          if records.length > 1
+            Bullet::Detector::NPlusOneQuery.add_possible_objects(records)
+          elsif records.size == 1
+            Bullet::Detector::NPlusOneQuery.add_impossible_object(records.first)
+          end
+          origin_each(&block)
+        end
+
+        def eager_load(docs)
+          associations = criteria.inclusions.map(&:name)
+          docs.each do |doc|
+            Bullet::Detector::NPlusOneQuery.add_object_associations(doc, associations)
+          end
+          Bullet::Detector::UnusedEagerLoading.add_eager_loadings(docs, associations)
+          origin_eager_load(docs)
+        end
+      end
+
+      ::Mongoid::Relations::Accessors.class_eval do
+        alias_method :origin_get_relation, :get_relation
+
+        def get_relation(name, metadata, reload = false)
+          result = origin_get_relation(name, metadata, reload)
+          if metadata.macro !~ /embed/
+            Bullet::Detector::NPlusOneQuery.call_association(self, name)
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/bullet/mongoid4x.rb

@@ -0,0 +1,56 @@
+module Bullet
+  module Mongoid
+    def self.enable
+      require 'mongoid'
+      ::Mongoid::Contextual::Mongo.class_eval do
+        alias_method :origin_first, :first
+        alias_method :origin_last, :last
+        alias_method :origin_each, :each
+        alias_method :origin_eager_load, :eager_load
+
+        def first
+          result = origin_first
+          Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
+          result
+        end
+
+        def last
+          result = origin_last
+          Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
+          result
+        end
+
+        def each(&block)
+          records = query.map{ |doc| ::Mongoid::Factory.from_db(klass, doc) }
+          if records.length > 1
+            Bullet::Detector::NPlusOneQuery.add_possible_objects(records)
+          elsif records.size == 1
+            Bullet::Detector::NPlusOneQuery.add_impossible_object(records.first)
+          end
+          origin_each(&block)
+        end
+
+        def eager_load(docs)
+          associations = criteria.inclusions.map(&:name)
+          docs.each do |doc|
+            Bullet::Detector::NPlusOneQuery.add_object_associations(doc, associations)
+          end
+          Bullet::Detector::UnusedEagerLoading.add_eager_loadings(docs, associations)
+          origin_eager_load(docs)
+        end
+      end
+
+      ::Mongoid::Relations::Accessors.class_eval do
+        alias_method :origin_get_relation, :get_relation
+
+        def get_relation(name, metadata, object, reload = false)
+          result = origin_get_relation(name, metadata, object, reload)
+          if metadata.macro !~ /embed/
+            Bullet::Detector::NPlusOneQuery.call_association(self, name)
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/bullet/notification/base.rb

@@ -19,7 +19,12 @@ module Bullet
       end
 
       def whoami
-        "user: " << `whoami`.chomp
+        @user ||= ENV['USER'].presence || (`whoami`.chomp rescue "")
+        if @user.present?
+          "user: #{@user}"
+        else
+          ""
+        end
       end
 
       def body_with_caller
@@ -31,15 +36,28 @@ module Bullet
       end
 
       def full_notice
-        [whoami, url, title, body_with_caller].compact.join("\n")
+        [whoami.presence, url, title, body_with_caller].compact.join("\n")
       end
 
       def notify_inline
-        self.notifier.inline_notify(self.full_notice)
+        self.notifier.inline_notify(notification_data)
       end
 
       def notify_out_of_channel
-        self.notifier.out_of_channel_notify(self.full_notice)
+        self.notifier.out_of_channel_notify(notification_data)
+      end
+
+      def short_notice
+        [whoami.presence, url, title, body].compact.join("\n")
+      end
+
+      def notification_data
+        {
+          :user => whoami,
+          :url => url,
+          :title => title,
+          :body => body_with_caller,
+        }
       end
 
       def eql?(other)

data/lib/bullet/notification/n_plus_one_query.rb

@@ -21,7 +21,7 @@ module Bullet
 
       protected
         def call_stack_messages
-          @callers.unshift('N+1 Query method call stack').join( "\n  " )
+          (['N+1 Query method call stack'] + @callers).join( "\n  " )
         end
     end
   end

data/lib/bullet/notification.rb

@@ -4,5 +4,7 @@ module Bullet
     autoload :UnusedEagerLoading, 'bullet/notification/unused_eager_loading'
     autoload :NPlusOneQuery, 'bullet/notification/n_plus_one_query'
     autoload :CounterCache, 'bullet/notification/counter_cache'
+
+    class UnoptimizedQueryError < StandardError; end
   end
 end

data/lib/bullet/rack.rb

@@ -1,47 +1,81 @@
 module Bullet
   class Rack
+    include Dependency
+
     def initialize(app)
       @app = app
     end
 
     def call(env)
       return @app.call(env) unless Bullet.enable?
-
       Bullet.start_request
       status, headers, response = @app.call(env)
-      return [status, headers, response] if empty?(response)
+      return [status, headers, response] if file?(headers) || sse?(response) || empty?(response)
 
       response_body = nil
       if Bullet.notification?
-        if status == 200 && !response.body.frozen? && html_request?(headers, response)
-          response_body = response.body << Bullet.gather_inline_notifications
-          headers['Content-Length'] = response_body.length.to_s
+        if status == 200 && !response_body(response).frozen? && html_request?(headers, response)
+          response_body = response_body(response) << Bullet.gather_inline_notifications
+          add_footer_note(response_body) if Bullet.add_footer
+          headers['Content-Length'] = response_body.bytesize.to_s
         end
+      end
+      if Bullet.enable? && Bullet.notification?
         Bullet.perform_out_of_channel_notifications(env)
       end
-      Bullet.end_request
-      no_browser_cache(headers) if Bullet.disable_browser_cache
       [status, headers, response_body ? [response_body] : response]
+    ensure
+      Bullet.end_request
     end
 
     # fix issue if response's body is a Proc
     def empty?(response)
       # response may be ["Not Found"], ["Move Permanently"], etc.
-      (response.is_a?(Array) && response.size <= 1) ||
-      !response.body.is_a?(String) || response.body.empty?
+      if rails?
+        (response.is_a?(Array) && response.size <= 1) ||
+          !response.respond_to?(:body) ||
+          !response_body(response).respond_to?(:empty?) ||
+          response_body(response).empty?
+      else
+        body = response_body(response)
+        body.nil? || body.empty?
+      end
+    end
+
+    def add_footer_note(response_body)
+      response_body << "<div #{footer_div_style}>" + Bullet.footer_info.uniq.join("<br>") + "</div>"
+    end
+
+    def file?(headers)
+      headers["Content-Transfer-Encoding"] == "binary"
+    end
+
+    def sse?(response)
+      response.respond_to?(:stream) && response.stream.is_a?(ActionController::Live::Buffer)
     end
 
     def html_request?(headers, response)
-      headers['Content-Type'] &&
-        headers['Content-Type'].include?('text/html') &&
-        response.body.include?("<html>") &&
-        response.body.include?("</html>")
+      headers['Content-Type'] && headers['Content-Type'].include?('text/html') && response_body(response).include?("<html")
     end
 
-    def no_browser_cache(headers)
-      headers["Cache-Control"] = "no-cache, no-store, max-age=0, must-revalidate"
-      headers["Pragma"] = "no-cache"
-      headers["Expires"] = "Wed, 09 Sep 2009 09:09:09 GMT"
+    def response_body(response)
+      if rails?
+        Array === response.body ? response.body.first : response.body
+      else
+        response.first
+      end
+    end
+
+    private
+    def footer_div_style
+<<EOF
+style="position: fixed; bottom: 0pt; left: 0pt; cursor: pointer; border-style: solid; border-color: rgb(153, 153, 153);
+ -moz-border-top-colors: none; -moz-border-right-colors: none; -moz-border-bottom-colors: none;
+ -moz-border-left-colors: none; -moz-border-image: none; border-width: 2pt 2pt 0px 0px;
+ padding: 5px; border-radius: 0pt 10pt 0pt 0px; background: none repeat scroll 0% 0% rgba(200, 200, 200, 0.8);
+ color: rgb(119, 119, 119); font-size: 18px; font-family: 'Arial', sans-serif; z-index:9999;"
+EOF
     end
   end
 end
+

data/lib/bullet/registry/base.rb

@@ -33,7 +33,7 @@ module Bullet
       end
 
       def include?(key, value)
-        @registry[key] && @registry[key].include?(value)
+        !@registry[key].nil? && @registry[key].include?(value)
       end
     end
   end

data/lib/bullet/registry/object.rb

@@ -1,12 +1,12 @@
 module Bullet
   module Registry
     class Object < Base
-      def add(bullet_ar_key)
-        super(bullet_ar_key.bullet_class_name, bullet_ar_key)
+      def add(bullet_key)
+        super(bullet_key.bullet_class_name, bullet_key)
       end
 
-      def include?(bullet_ar_key)
-        super(bullet_ar_key.bullet_class_name, bullet_ar_key)
+      def include?(bullet_key)
+        super(bullet_key.bullet_class_name, bullet_key)
       end
     end
   end

data/lib/bullet/version.rb

@@ -1,5 +1,4 @@
 # encoding: utf-8
 module Bullet
-  VERSION = "4.0.0"
+  VERSION = "4.13.1"
 end
-