bullet_instructure 4.0.2

data/bullet_instructure.gemspec

@@ -0,0 +1,27 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require "bullet/version"
+
+Gem::Specification.new do |s|
+  s.name        = "bullet_instructure"
+  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     = "help to kill N+1 queries and unused eager loading, pretty formatter for Instructure."
+  s.description = "help to kill N+1 queries and unused eager loading, pretty formatter for Instructure."
+
+  s.license     = 'MIT'
+
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.add_runtime_dependency "activesupport", ">= 3.0.0"
+  s.add_runtime_dependency "uniform_notifier", ">= 1.6.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

@@ -0,0 +1,196 @@
+require "active_support/core_ext/module/delegation"
+require 'set'
+require 'uniform_notifier'
+require 'bullet/ext/object'
+require 'bullet/ext/string'
+require 'bullet/dependency'
+
+module Bullet
+  extend Dependency
+
+  autoload :ActiveRecord, "bullet/#{active_record_version}" if active_record?
+  autoload :Mongoid, "bullet/#{mongoid_version}" if mongoid?
+  autoload :Rack, 'bullet/rack'
+  autoload :Notification, 'bullet/notification'
+  autoload :Detector, 'bullet/detector'
+  autoload :Registry, 'bullet/registry'
+  autoload :NotificationCollector, 'bullet/notification_collector'
+
+  if defined? Rails::Railtie
+    class BulletRailtie < Rails::Railtie
+      initializer "bullet.configure_rails_initialization" do |app|
+        app.middleware.use Bullet::Rack
+      end
+    end
+  end
+
+  class << self
+    attr_writer :enable, :n_plus_one_query_enable, :unused_eager_loading_enable, :counter_cache_enable, :stacktrace_includes
+    attr_reader :notification_collector, :whitelist
+    attr_accessor :add_footer, :orm_pathches_applied
+
+    delegate :alert=, :console=, :growl=, :rails_logger=, :xmpp=, :airbrake=, :bugsnag=, :to => UniformNotifier
+
+    def raise=(should_raise)
+      UniformNotifier.raise=(should_raise ? Notification::UnoptimizedQueryError : false)
+    end
+
+    DETECTORS = [ Bullet::Detector::NPlusOneQuery,
+                  Bullet::Detector::UnusedEagerLoading,
+                  Bullet::Detector::CounterCache ]
+
+    def enable=(enable)
+      @enable = @n_plus_one_query_enable = @unused_eager_loading_enable = @counter_cache_enable = enable
+      if enable?
+        reset_whitelist
+        unless orm_pathches_applied
+          self.orm_pathches_applied = true
+          Bullet::Mongoid.enable if mongoid?
+          Bullet::ActiveRecord.enable if active_record?
+        end
+      end
+    end
+
+    def enable?
+      !!@enable
+    end
+
+    def n_plus_one_query_enable?
+      self.enable? && !!@n_plus_one_query_enable
+    end
+
+    def unused_eager_loading_enable?
+      self.enable? && !!@unused_eager_loading_enable
+    end
+
+    def counter_cache_enable?
+      self.enable? && !!@counter_cache_enable
+    end
+
+    def stacktrace_includes
+      @stacktrace_includes || []
+    end
+
+    def add_whitelist(options)
+      @whitelist[options[:type]][options[:class_name].classify] ||= []
+      @whitelist[options[:type]][options[:class_name].classify] << options[:association].to_sym
+    end
+
+    def get_whitelist_associations(type, class_name)
+      Array(@whitelist[type][class_name])
+    end
+
+    def reset_whitelist
+      @whitelist = {:n_plus_one_query => {}, :unused_eager_loading => {}, :counter_cache => {}}
+    end
+
+    def bullet_logger=(active)
+      if active
+        require 'fileutils'
+        root_path = "#{rails? ? Rails.root.to_s : Dir.pwd}"
+        FileUtils.mkdir_p(root_path + '/log')
+        bullet_log_file = File.open("#{root_path}/log/bullet.html", 'a+')
+        bullet_log_file.sync = true
+        UniformNotifier.customized_logger = bullet_log_file
+      end
+    end
+
+    def debug(title, message)
+      puts "[Bullet][#{title}] #{message}" if ENV['DEBUG'] == 'true'
+    end
+
+    def start_request
+      Thread.current[:bullet_start] = true
+      Thread.current[:bullet_notification_collector] = Bullet::NotificationCollector.new
+
+      Thread.current[:bullet_object_associations] = Bullet::Registry::Base.new
+      Thread.current[:bullet_call_object_associations] = Bullet::Registry::Base.new
+      Thread.current[:bullet_possible_objects] = Bullet::Registry::Object.new
+      Thread.current[:bullet_impossible_objects] = Bullet::Registry::Object.new
+      Thread.current[:bullet_eager_loadings] = Bullet::Registry::Association.new
+
+      Thread.current[:bullet_counter_possible_objects] ||= Bullet::Registry::Object.new
+      Thread.current[:bullet_counter_impossible_objects] ||= Bullet::Registry::Object.new
+    end
+
+    def end_request
+      Thread.current[:bullet_start] = nil
+      Thread.current[:bullet_notification_collector] = nil
+
+      Thread.current[:bullet_object_associations] = nil
+      Thread.current[:bullet_possible_objects] = nil
+      Thread.current[:bullet_impossible_objects] = nil
+      Thread.current[:bullet_call_object_associations] = nil
+      Thread.current[:bullet_eager_loadings] = nil
+
+      Thread.current[:bullet_counter_possible_objects] = nil
+      Thread.current[:bullet_counter_impossible_objects] = nil
+    end
+
+    def start?
+      Thread.current[:bullet_start]
+    end
+
+    def notification_collector
+      Thread.current[:bullet_notification_collector]
+    end
+
+    def notification?
+      Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+      notification_collector.notifications_present?
+    end
+
+    def gather_inline_notifications
+      responses = []
+      for_each_active_notifier_with_notification do |notification|
+        responses << notification.notify_inline
+      end
+      responses.join( "\n" )
+    end
+
+    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
+
+    def footer_info
+      info = []
+      for_each_active_notifier_with_notification do |notification|
+        info << notification.short_notice
+      end
+      info
+    end
+
+    def warnings
+      notification_collector.collection.inject({}) do |warnings, notification|
+        warning_type = notification.class.to_s.split(':').last.tableize
+        warnings[warning_type] ||= []
+        warnings[warning_type] << notification
+        warnings
+      end
+    end
+
+    def profile
+      Bullet.start_request if Bullet.enable?
+
+      yield
+
+      if Bullet.enable? && Bullet.notification?
+        Bullet.perform_out_of_channel_notifications
+      end
+      Bullet.end_request if Bullet.enable?
+    end
+
+    private
+      def for_each_active_notifier_with_notification
+        UniformNotifier.active_notifiers.each do |notifier|
+          notification_collector.collection.each do |notification|
+            notification.notifier = notifier
+            yield notification
+          end
+        end
+      end
+  end
+end

data/lib/bullet/active_record3.rb

@@ -0,0 +1,148 @@
+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::AssociationPreload::ClassMethods.class_eval do
+        alias_method :origin_preload_associations, :preload_associations
+        # include query for one to many associations.
+        # keep this eager loadings.
+        def preload_associations(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::UnusedEagerLoading.add_eager_loadings(records, associations)
+          origin_preload_associations(records, associations, preload_options={})
+        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::ClassMethods::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::AssociationCollection.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_first, :first
+        def first(*args)
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name)
+          origin_first(*args)
+        end
+
+        alias_method :origin_last, :last
+        def last(*args)
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name)
+          origin_last(*args)
+        end
+
+        alias_method :origin_empty?, :empty?
+        def empty?
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name)
+          origin_empty?
+        end
+      end
+
+      ::ActiveRecord::Associations::AssociationProxy.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.any? { |c| c.include?("load_target") }
+          Bullet::Detector::NPlusOneQuery.add_possible_objects(result)
+          result
+        end
+
+        alias_method :origin_set_inverse_instance, :set_inverse_instance
+        def set_inverse_instance(record, instance)
+          if record && we_can_set_the_inverse_on_this?(record)
+            Bullet::Detector::NPlusOneQuery.add_impossible_object(record)
+          end
+          origin_set_inverse_instance(record, instance)
+        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::CounterCache.add_counter_cache(@owner, @reflection.name) unless result
+          result
+        end
+      end
+
+      ::ActiveRecord::Associations::HasManyThroughAssociation.class_eval do
+        alias_method :origin_has_cached_counter?, :has_cached_counter?
+        def has_cached_counter?
+          result = origin_has_cached_counter?
+          Bullet::Detector::CounterCache.add_counter_cache(@owner, @reflection.name) unless result
+          result
+        end
+      end
+    end
+  end
+end

data/lib/bullet/active_record3x.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