bullet_instructure 4.0.2

data/lib/bullet/detector/n_plus_one_query.rb

@@ -0,0 +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)
+          return unless Bullet.start?
+          return unless object.id
+          add_call_object_associations(object, 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(&:id).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.id
+
+          Bullet.debug("Detector::NPlusOneQuery#add_impossible_object", "object: #{object.bullet_key}")
+          impossible_objects.add object.bullet_key
+        end
+
+        private
+          def create_notification(callers, klazz, associations)
+            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_key, associations)
+            possible?(bullet_key) && !impossible?(bullet_key) && !association?(bullet_key, associations)
+          end
+
+          def caller_in_project
+            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_key)
+            possible_objects.include? bullet_key
+          end
+
+          def impossible?(bullet_key)
+            impossible_objects.include? bullet_key
+          end
+
+          # check if object => associations already exists in object_associations.
+          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
+                return true if result
+              end
+            end
+
+            return false
+          end
+      end
+    end
+  end
+end

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(&:id).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/ext/object.rb

@@ -0,0 +1,9 @@
+class Object
+  def bullet_key
+    if self.class.respond_to?(:primary_key) && self.class.primary_key
+      "#{self.class}:#{self.send self.class.primary_key}"
+    else
+      "#{self.class}:#{self.id}"
+    end
+  end
+end

data/lib/bullet/ext/string.rb

@@ -0,0 +1,5 @@
+class String
+  def bullet_class_name
+    self.sub(/:[^:]*?$/, "")
+  end
+end

data/lib/bullet/mongoid2x.rb

@@ -0,0 +1,56 @@
+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::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 iterate(&block)
+          records = execute.to_a
+          if records.size > 1
+            Bullet::Detector::NPlusOneQuery.add_possible_objects(records)
+          elsif records.size == 1
+            Bullet::Detector::NPlusOneQuery.add_impossible_object(records.first)
+          end
+          origin_iterate(&block)
+        end
+
+        def eager_load(docs)
+          associations = criteria.inclusions.map(&:name)
+          docs.each do |doc|
+            Bullet::Detector::Association.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_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.rb

@@ -0,0 +1,10 @@
+module Bullet
+  module Notification
+    autoload :Base, 'bullet/notification/base'
+    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/notification/base.rb

@@ -0,0 +1,97 @@
+module Bullet
+  module Notification
+    class Base
+      attr_accessor :notifier, :url
+      attr_reader :base_class, :associations, :path
+
+      def initialize(base_class, association_or_associations, path = nil)
+        @base_class = base_class
+        @associations = association_or_associations.is_a?(Array) ?  association_or_associations : [association_or_associations]
+        @path = path
+      end
+
+      def title
+        raise NoMethodError.new("no method title defined")
+      end
+
+      def body
+        raise NoMethodError.new("no method body defined")
+      end
+
+      def whoami
+        user = `whoami`
+        if user
+          "user: #{user.chomp}"
+        else
+          ""
+        end
+      end
+
+      def body_with_caller
+        body
+      end
+
+      def standard_notice
+        @standard_notifice ||= title + "\n" + body
+      end
+
+      def full_notice
+        [url, title, body_with_caller].compact.join("\n")
+      end
+
+      def notify_inline
+        self.notifier.inline_notify(notification_data)
+      end
+
+      def notify_out_of_channel
+        self.notifier.out_of_channel_notify(notification_data)
+      end
+
+      def short_notice
+        [url, title, body].compact.join("\n")
+      end
+
+      def notification_data
+        {
+          :url => url,
+          :title => title,
+          :body => body_with_caller,
+        }
+      end
+
+      def eql?(other)
+        klazz_associations_str == other.klazz_associations_str
+      end
+
+      def hash
+        klazz_associations_str.hash
+      end
+      
+      class HTMLwithPygments < Redcarpet::Render::HTML
+        def block_code(code, language)
+          Pygments.highlight(code, :lexer => language)
+        end
+      end
+
+      def markdown(text)
+        renderer = HTMLwithPygments.new(hard_wrap: true)
+        options = {
+          :no_intra_emphasis => true,
+          :fenced_code_blocks => true
+        }
+      # markdown = Redcarpet::Markdown.new(Redcarpet::Render::HTML, options)
+      # markdown.render(text).html_safe
+        Redcarpet::Markdown.new(renderer, options).render(text).html_safe
+      end
+      
+      protected
+        def klazz_associations_str
+          "  #{@base_class} => [#{@associations.map(&:inspect).join(', ')}]"
+        end
+
+        def associations_str
+          ":include => #{@associations.map{ |a| a.to_s.to_sym unless a.is_a? Hash }.inspect}"
+        end
+    end
+  end
+end