bullet 4.13.1 → 5.5.0

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

@@ -2,11 +2,10 @@ module Bullet
   module Mongoid
     def self.enable
       require 'mongoid'
-
-      ::Mongoid::Contexts::Mongo.class_eval do
+      ::Mongoid::Contextual::Mongo.class_eval do
         alias_method :origin_first, :first
         alias_method :origin_last, :last
-        alias_method :origin_iterate, :iterate
+        alias_method :origin_each, :each
         alias_method :origin_eager_load, :eager_load
 
         def first
@@ -21,20 +20,20 @@ module Bullet
           result
         end
 
-        def iterate(&block)
-          records = execute.to_a
-          if records.size > 1
+        def each(&block)
+          records = view.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_iterate(&block)
+          origin_each(&block)
         end
 
         def eager_load(docs)
           associations = criteria.inclusions.map(&:name)
           docs.each do |doc|
-            Bullet::Detector::Association.add_object_associations(doc, associations)
+            Bullet::Detector::NPlusOneQuery.add_object_associations(doc, associations)
           end
           Bullet::Detector::UnusedEagerLoading.add_eager_loadings(docs, associations)
           origin_eager_load(docs)
@@ -42,13 +41,14 @@ module Bullet
       end
 
       ::Mongoid::Relations::Accessors.class_eval do
-        alias_method :origin_set_relation, :set_relation
+        alias_method :origin_get_relation, :get_relation
 
-        def set_relation(name, relation)
-          if relation && relation.metadata.macro !~ /embed/
+        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
-          origin_set_relation(name, relation)
+          result
         end
       end
     end

data/lib/bullet/notification/base.rb

@@ -18,6 +18,10 @@ module Bullet
         raise NoMethodError.new("no method body defined")
       end
 
+      def call_stack_messages
+        ""
+      end
+
       def whoami
         @user ||= ENV['USER'].presence || (`whoami`.chomp rescue "")
         if @user.present?
@@ -28,15 +32,7 @@ module Bullet
       end
 
       def body_with_caller
-        body
-      end
-
-      def standard_notice
-        @standard_notifice ||= title + "\n" + body
-      end
-
-      def full_notice
-        [whoami.presence, url, title, body_with_caller].compact.join("\n")
+        "#{body}\n#{call_stack_messages}\n"
       end
 
       def notify_inline
@@ -48,7 +44,7 @@ module Bullet
       end
 
       def short_notice
-        [whoami.presence, url, title, body].compact.join("\n")
+        [whoami.presence, url, title, body].compact.join("  ")
       end
 
       def notification_data
@@ -61,11 +57,11 @@ module Bullet
       end
 
       def eql?(other)
-        klazz_associations_str == other.klazz_associations_str
+        self.class == other.class && klazz_associations_str == other.klazz_associations_str
       end
 
       def hash
-        klazz_associations_str.hash
+        [self.class, klazz_associations_str].hash
       end
 
       protected
@@ -74,7 +70,7 @@ module Bullet
         end
 
         def associations_str
-          ":include => #{@associations.map{ |a| a.to_s.to_sym unless a.is_a? Hash }.inspect}"
+          ":includes => #{@associations.map{ |a| a.to_s.to_sym unless a.is_a? Hash }.inspect}"
         end
     end
   end

data/lib/bullet/notification/n_plus_one_query.rb

@@ -7,21 +7,23 @@ module Bullet
         @callers = callers
       end
 
-      def body_with_caller
-        "#{body}\n#{call_stack_messages}"
-      end
-
       def body
         "#{klazz_associations_str}\n  Add to your finder: #{associations_str}"
       end
 
       def title
-        "N+1 Query #{@path ? "in #{@path}" : 'detected'}"
+        "USE eager loading #{@path ? "in #{@path}" : 'detected'}"
+      end
+
+      def notification_data
+        super.merge(
+          :backtrace => []
+        )
       end
 
       protected
         def call_stack_messages
-          (['N+1 Query method call stack'] + @callers).join( "\n  " )
+          (['Call stack'] + @callers).join( "\n  " )
         end
     end
   end

data/lib/bullet/notification/unused_eager_loading.rb

@@ -1,13 +1,30 @@
 module Bullet
   module Notification
     class UnusedEagerLoading < Base
+      def initialize(callers, base_class, associations, path = nil)
+        super(base_class, associations, path)
+
+        @callers = callers
+      end
+
       def body
         "#{klazz_associations_str}\n  Remove from your finder: #{associations_str}"
       end
 
       def title
-        "Unused Eager Loading #{@path ? "in #{@path}" : 'detected'}"
+        "AVOID eager loading #{@path ? "in #{@path}" : 'detected'}"
       end
+
+      def notification_data
+        super.merge(
+            :backtrace => []
+        )
+      end
+
+      protected
+        def call_stack_messages
+          (['Call stack'] + @callers).join( "\n  " )
+        end
     end
   end
 end

data/lib/bullet/rack.rb

@@ -10,17 +10,16 @@ module Bullet
       return @app.call(env) unless Bullet.enable?
       Bullet.start_request
       status, headers, response = @app.call(env)
-      return [status, headers, response] if file?(headers) || sse?(response) || empty?(response)
 
       response_body = nil
       if Bullet.notification?
-        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
+        if !file?(headers) && !sse?(headers) && !empty?(response) &&
+            status == 200 && !response_body(response).frozen? && html_request?(headers, response)
+          response_body = response_body(response)
+          append_to_html_body(response_body, footer_note) if Bullet.add_footer
+          append_to_html_body(response_body, Bullet.gather_inline_notifications)
           headers['Content-Length'] = response_body.bytesize.to_s
         end
-      end
-      if Bullet.enable? && Bullet.notification?
         Bullet.perform_out_of_channel_notifications(env)
       end
       [status, headers, response_body ? [response_body] : response]
@@ -42,16 +41,25 @@ module Bullet
       end
     end
 
-    def add_footer_note(response_body)
-      response_body << "<div #{footer_div_style}>" + Bullet.footer_info.uniq.join("<br>") + "</div>"
+    def append_to_html_body(response_body, content)
+      if response_body.include?('</body>')
+        position = response_body.rindex('</body>')
+        response_body.insert(position, content)
+      else
+        response_body << content
+      end
+    end
+
+    def footer_note
+      "<div #{footer_div_attributes}>" + footer_close_button + 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)
+    def sse?(headers)
+      headers["Content-Type"] == "text/event-stream"
     end
 
     def html_request?(headers, response)
@@ -59,7 +67,7 @@ module Bullet
     end
 
     def response_body(response)
-      if rails?
+      if response.respond_to?(:body)
         Array === response.body ? response.body.first : response.body
       else
         response.first
@@ -67,15 +75,19 @@ module Bullet
     end
 
     private
-    def footer_div_style
+
+    def footer_div_attributes
 <<EOF
-style="position: fixed; bottom: 0pt; left: 0pt; cursor: pointer; border-style: solid; border-color: rgb(153, 153, 153);
+data-is-bullet-footer ondblclick="this.parentNode.removeChild(this);" 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;"
+ padding: 3px 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: 16px; font-family: 'Arial', sans-serif; z-index:9999;"
 EOF
     end
+
+    def footer_close_button
+      "<span onclick='this.parentNode.remove()' style='position:absolute; right: 10px; top: 0px; font-weight: bold; color: #333;'>&times;</span>"
+    end
   end
 end
-

data/lib/bullet/stack_trace_filter.rb

@@ -0,0 +1,34 @@
+module Bullet
+  module StackTraceFilter
+    VENDOR_PATH = "/vendor"
+
+    def caller_in_project
+      app_root = rails? ? Rails.root.to_s : Dir.pwd
+      vendor_root = app_root + VENDOR_PATH
+      caller.select do |caller_path|
+        caller_path.include?(app_root) && !caller_path.include?(vendor_root) ||
+          Bullet.stacktrace_includes.any? do |include_pattern|
+          case include_pattern
+          when String
+            caller_path.include?(include_pattern)
+          when Regexp
+            caller_path =~ include_pattern
+          end
+        end
+      end
+    end
+
+    def excluded_stacktrace_path?
+      Bullet.stacktrace_excludes.any? do |exclude_pattern|
+        caller_in_project.any? do |caller_path|
+          case exclude_pattern
+          when String
+            caller_path.include?(exclude_pattern)
+          when Regexp
+            caller_path =~ exclude_pattern
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bullet/version.rb

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

data/lib/bullet.rb

@@ -4,6 +4,7 @@ require 'uniform_notifier'
 require 'bullet/ext/object'
 require 'bullet/ext/string'
 require 'bullet/dependency'
+require 'bullet/stack_trace_filter'
 
 module Bullet
   extend Dependency
@@ -16,6 +17,9 @@ module Bullet
   autoload :Registry, 'bullet/registry'
   autoload :NotificationCollector, 'bullet/notification_collector'
 
+  BULLET_DEBUG = 'BULLET_DEBUG'.freeze
+  TRUE = 'true'.freeze
+
   if defined? Rails::Railtie
     class BulletRailtie < Rails::Railtie
       initializer "bullet.configure_rails_initialization" do |app|
@@ -25,11 +29,13 @@ module Bullet
   end
 
   class << self
-    attr_writer :enable, :n_plus_one_query_enable, :unused_eager_loading_enable, :counter_cache_enable, :stacktrace_includes
+    attr_writer :enable, :n_plus_one_query_enable, :unused_eager_loading_enable, :counter_cache_enable, :stacktrace_includes, :stacktrace_excludes
     attr_reader :notification_collector, :whitelist
     attr_accessor :add_footer, :orm_pathches_applied
 
-    delegate :alert=, :console=, :growl=, :rails_logger=, :xmpp=, :airbrake=, :bugsnag=, :to => UniformNotifier
+    available_notifiers = UniformNotifier::AVAILABLE_NOTIFIERS.map { |notifier| "#{notifier}=" }
+    available_notifiers << { :to => UniformNotifier }
+    delegate *available_notifiers
 
     def raise=(should_raise)
       UniformNotifier.raise=(should_raise ? Notification::UnoptimizedQueryError : false)
@@ -71,9 +77,14 @@ module Bullet
       @stacktrace_includes || []
     end
 
+    def stacktrace_excludes
+      @stacktrace_excludes || []
+    end
+
     def add_whitelist(options)
-      @whitelist[options[:type]][options[:class_name].classify] ||= []
-      @whitelist[options[:type]][options[:class_name].classify] << options[:association].to_sym
+      reset_whitelist
+      @whitelist[options[:type]][options[:class_name]] ||= []
+      @whitelist[options[:type]][options[:class_name]] << options[:association].to_sym
     end
 
     def get_whitelist_associations(type, class_name)
@@ -81,7 +92,11 @@ module Bullet
     end
 
     def reset_whitelist
-      @whitelist = {:n_plus_one_query => {}, :unused_eager_loading => {}, :counter_cache => {}}
+      @whitelist ||= {:n_plus_one_query => {}, :unused_eager_loading => {}, :counter_cache => {}}
+    end
+
+    def clear_whitelist
+      @whitelist = nil
     end
 
     def bullet_logger=(active)
@@ -96,7 +111,7 @@ module Bullet
     end
 
     def debug(title, message)
-      puts "[Bullet][#{title}] #{message}" if ENV['BULLET_DEBUG'] == 'true'
+      puts "[Bullet][#{title}] #{message}" if ENV[BULLET_DEBUG] == TRUE
     end
 
     def start_request
@@ -130,7 +145,7 @@ module Bullet
     end
 
     def start?
-      Thread.current[:bullet_start]
+      enable? && Thread.current[:bullet_start]
     end
 
     def notification_collector
@@ -152,15 +167,16 @@ module Bullet
     end
 
     def perform_out_of_channel_notifications(env = {})
+      request_uri = build_request_uri(env)
       for_each_active_notifier_with_notification do |notification|
-        notification.url = [env['HTTP_HOST'], env['REQUEST_URI']].compact.join
+        notification.url = request_uri
         notification.notify_out_of_channel
       end
     end
 
     def footer_info
       info = []
-      for_each_active_notifier_with_notification do |notification|
+      notification_collector.collection.each do |notification|
         info << notification.short_notice
       end
       info
@@ -176,14 +192,22 @@ module Bullet
     end
 
     def profile
-      Bullet.start_request if Bullet.enable?
+      return_value = nil
+      if Bullet.enable?
+        begin
+          Bullet.start_request
 
-      yield
+          return_value = yield
 
-      if Bullet.enable? && Bullet.notification?
-        Bullet.perform_out_of_channel_notifications
+          Bullet.perform_out_of_channel_notifications if Bullet.notification?
+        ensure
+          Bullet.end_request
+        end
+      else
+        return_value = yield
       end
-      Bullet.end_request if Bullet.enable?
+
+      return_value
     end
 
     private
@@ -195,5 +219,15 @@ module Bullet
           end
         end
       end
+
+      def build_request_uri(env)
+        return "#{env['REQUEST_METHOD']} #{env['REQUEST_URI']}" if env['REQUEST_URI']
+
+        if env['QUERY_STRING'].present?
+          "#{env['REQUEST_METHOD']} #{env['PATH_INFO']}?#{env['QUERY_STRING']}"
+        else
+          "#{env['REQUEST_METHOD']} #{env['PATH_INFO']}"
+        end
+      end
   end
 end

data/spec/bullet/detector/counter_cache_spec.rb

@@ -10,13 +10,13 @@ module Bullet
 
       context ".add_counter_cache" do
         it "should create notification if conditions met" do
-          expect(CounterCache).to receive(:conditions_met?).with(@post1.bullet_key, [:comments]).and_return(true)
+          expect(CounterCache).to receive(:conditions_met?).with(@post1, [:comments]).and_return(true)
           expect(CounterCache).to receive(:create_notification).with("Post", [:comments])
           CounterCache.add_counter_cache(@post1, [:comments])
         end
 
         it "should not create notification if conditions not met" do
-          expect(CounterCache).to receive(:conditions_met?).with(@post1.bullet_key, [:comments]).and_return(false)
+          expect(CounterCache).to receive(:conditions_met?).with(@post1, [:comments]).and_return(false)
           expect(CounterCache).to receive(:create_notification).never
           CounterCache.add_counter_cache(@post1, [:comments])
         end
@@ -25,30 +25,30 @@ module Bullet
       context ".add_possible_objects" do
         it "should add possible objects" do
           CounterCache.add_possible_objects([@post1, @post2])
-          expect(CounterCache.send(:possible_objects)).to be_include(@post1.bullet_key)
-          expect(CounterCache.send(:possible_objects)).to be_include(@post2.bullet_key)
+          expect(CounterCache.possible_objects).to be_include(@post1.bullet_key)
+          expect(CounterCache.possible_objects).to be_include(@post2.bullet_key)
         end
 
         it "should add impossible object" do
           CounterCache.add_impossible_object(@post1)
-          expect(CounterCache.send(:impossible_objects)).to be_include(@post1.bullet_key)
+          expect(CounterCache.impossible_objects).to be_include(@post1.bullet_key)
         end
       end
 
       context ".conditions_met?" do
         it "should be true when object is possible, not impossible" do
           CounterCache.add_possible_objects(@post1)
-          expect(CounterCache.send(:conditions_met?, @post1.bullet_key, :associations)).to eq true
+          expect(CounterCache.conditions_met?(@post1, :associations)).to eq true
         end
 
         it "should be false when object is not possible" do
-          expect(CounterCache.send(:conditions_met?, @post1.bullet_key, :associations)).to eq false
+          expect(CounterCache.conditions_met?(@post1, :associations)).to eq false
         end
 
         it "should be true when object is possible, and impossible" do
           CounterCache.add_possible_objects(@post1)
           CounterCache.add_impossible_object(@post1)
-          expect(CounterCache.send(:conditions_met?, @post1.bullet_key, :associations)).to eq false
+          expect(CounterCache.conditions_met?(@post1, :associations)).to eq false
         end
       end
     end

data/spec/bullet/detector/n_plus_one_query_spec.rb

@@ -18,73 +18,88 @@ module Bullet
       context ".possible?" do
         it "should be true if possible_objects contain" do
           NPlusOneQuery.add_possible_objects(@post)
-          expect(NPlusOneQuery.send(:possible?, @post.bullet_key)).to eq true
+          expect(NPlusOneQuery.possible?(@post)).to eq true
         end
       end
 
       context ".impossible?" do
         it "should be true if impossible_objects contain" do
           NPlusOneQuery.add_impossible_object(@post)
-          expect(NPlusOneQuery.send(:impossible?, @post.bullet_key)).to eq true
+          expect(NPlusOneQuery.impossible?(@post)).to eq true
         end
       end
 
       context ".association?" do
         it "should be true if object, associations pair is already existed" do
           NPlusOneQuery.add_object_associations(@post, :association)
-          expect(NPlusOneQuery.send(:association?, @post.bullet_key, :association)).to eq true
+          expect(NPlusOneQuery.association?(@post, :association)).to eq true
         end
 
         it "should be false if object, association pair is not existed" do
           NPlusOneQuery.add_object_associations(@post, :association1)
-          expect(NPlusOneQuery.send(:association?, @post.bullet_key, :associatio2)).to eq false
+          expect(NPlusOneQuery.association?(@post, :associatio2)).to eq false
         end
       end
 
       context ".conditions_met?" do
         it "should be true if object is possible, not impossible and object, associations pair is not already existed" do
-          allow(NPlusOneQuery).to receive(:possible?).with(@post.bullet_key).and_return(true)
-          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_key).and_return(false)
-          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_key, :associations).and_return(false)
-          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_key, :associations)).to eq true
+          allow(NPlusOneQuery).to receive(:possible?).with(@post).and_return(true)
+          allow(NPlusOneQuery).to receive(:impossible?).with(@post).and_return(false)
+          allow(NPlusOneQuery).to receive(:association?).with(@post, :associations).and_return(false)
+          expect(NPlusOneQuery.conditions_met?(@post, :associations)).to eq true
         end
 
         it "should be false if object is not possible, not impossible and object, associations pair is not already existed" do
-          allow(NPlusOneQuery).to receive(:possible?).with(@post.bullet_key).and_return(false)
-          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_key).and_return(false)
-          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_key, :associations).and_return(false)
-          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_key, :associations)).to eq false
+          allow(NPlusOneQuery).to receive(:possible?).with(@post).and_return(false)
+          allow(NPlusOneQuery).to receive(:impossible?).with(@post).and_return(false)
+          allow(NPlusOneQuery).to receive(:association?).with(@post, :associations).and_return(false)
+          expect(NPlusOneQuery.conditions_met?(@post, :associations)).to eq false
         end
 
         it "should be false if object is possible, but impossible and object, associations pair is not already existed" do
-          allow(NPlusOneQuery).to receive(:possible?).with(@post.bullet_key).and_return(true)
-          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_key).and_return(true)
-          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_key, :associations).and_return(false)
-          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_key, :associations)).to eq false
+          allow(NPlusOneQuery).to receive(:possible?).with(@post).and_return(true)
+          allow(NPlusOneQuery).to receive(:impossible?).with(@post).and_return(true)
+          allow(NPlusOneQuery).to receive(:association?).with(@post, :associations).and_return(false)
+          expect(NPlusOneQuery.conditions_met?(@post, :associations)).to eq false
         end
 
         it "should be false if object is possible, not impossible and object, associations pair is already existed" do
-          allow(NPlusOneQuery).to receive(:possible?).with(@post.bullet_key).and_return(true)
-          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_key).and_return(false)
-          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_key, :associations).and_return(true)
-          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_key, :associations)).to eq false
+          allow(NPlusOneQuery).to receive(:possible?).with(@post).and_return(true)
+          allow(NPlusOneQuery).to receive(:impossible?).with(@post).and_return(false)
+          allow(NPlusOneQuery).to receive(:association?).with(@post, :associations).and_return(true)
+          expect(NPlusOneQuery.conditions_met?(@post, :associations)).to eq false
         end
       end
 
       context ".call_association" do
         it "should create notification if conditions met" do
-          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post.bullet_key, :association).and_return(true)
+          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post, :association).and_return(true)
           expect(NPlusOneQuery).to receive(:caller_in_project).and_return(["caller"])
           expect(NPlusOneQuery).to receive(:create_notification).with(["caller"], "Post", :association)
           NPlusOneQuery.call_association(@post, :association)
         end
 
         it "should not create notification if conditions not met" do
-          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post.bullet_key, :association).and_return(false)
+          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post, :association).and_return(false)
           expect(NPlusOneQuery).not_to receive(:caller_in_project!)
           expect(NPlusOneQuery).not_to receive(:create_notification).with("Post", :association)
           NPlusOneQuery.call_association(@post, :association)
         end
+
+        context "stacktrace_excludes" do
+          before { Bullet.stacktrace_excludes = [ /def/ ] }
+          after { Bullet.stacktrace_excludes = nil }
+
+          it "should not create notification when stacktrace contains paths that are in the exclude list" do
+            in_project = File.join(Dir.pwd, 'abc', 'abc.rb')
+            included_path = '/ghi/ghi.rb'
+            excluded_path = '/def/def.rb'
+
+            expect(NPlusOneQuery).to receive(:caller).and_return([in_project, included_path, excluded_path])
+            expect(NPlusOneQuery).to_not receive(:create_notification)
+            NPlusOneQuery.call_association(@post, :association)
+          end
+        end
       end
 
       context ".caller_in_project" do
@@ -93,23 +108,23 @@ module Bullet
           not_in_project = '/def/def.rb'
 
           expect(NPlusOneQuery).to receive(:caller).and_return([in_project, not_in_project])
-          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post.bullet_key, :association).and_return(true)
+          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post, :association).and_return(true)
           expect(NPlusOneQuery).to receive(:create_notification).with([in_project], "Post", :association)
           NPlusOneQuery.call_association(@post, :association)
         end
 
         context "stacktrace_includes" do
-          before { Bullet.stacktrace_includes = [ 'def' ] }
+          before { Bullet.stacktrace_includes = [ 'def', /xyz/ ] }
           after { Bullet.stacktrace_includes = nil }
 
           it "should include paths that are in the stacktrace_include list" do
             in_project = File.join(Dir.pwd, 'abc', 'abc.rb')
-            included_gem = '/def/def.rb'
+            included_gems = ['/def/def.rb', 'xyz/xyz.rb']
             excluded_gem = '/ghi/ghi.rb'
 
-            expect(NPlusOneQuery).to receive(:caller).and_return([in_project, included_gem, excluded_gem])
-            expect(NPlusOneQuery).to receive(:conditions_met?).with(@post.bullet_key, :association).and_return(true)
-            expect(NPlusOneQuery).to receive(:create_notification).with([in_project, included_gem], "Post", :association)
+            expect(NPlusOneQuery).to receive(:caller).and_return([in_project, *included_gems, excluded_gem])
+            expect(NPlusOneQuery).to receive(:conditions_met?).with(@post, :association).and_return(true)
+            expect(NPlusOneQuery).to receive(:create_notification).with([in_project, *included_gems], "Post", :association)
             NPlusOneQuery.call_association(@post, :association)
           end
         end
@@ -118,8 +133,8 @@ module Bullet
       context ".add_possible_objects" do
         it "should add possible objects" do
           NPlusOneQuery.add_possible_objects([@post, @post2])
-          expect(NPlusOneQuery.send(:possible_objects)).to be_include(@post.bullet_key)
-          expect(NPlusOneQuery.send(:possible_objects)).to be_include(@post2.bullet_key)
+          expect(NPlusOneQuery.possible_objects).to be_include(@post.bullet_key)
+          expect(NPlusOneQuery.possible_objects).to be_include(@post2.bullet_key)
         end
 
         it "should not raise error if object is nil" do
@@ -130,7 +145,7 @@ module Bullet
       context ".add_impossible_object" do
         it "should add impossible object" do
           NPlusOneQuery.add_impossible_object(@post)
-          expect(NPlusOneQuery.send(:impossible_objects)).to be_include(@post.bullet_key)
+          expect(NPlusOneQuery.impossible_objects).to be_include(@post.bullet_key)
         end
       end
     end