bullet 7.1.6 → 8.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 752fed6e96f9ea5c1baefca2e9a80ea3aefa13c279d24688f3341d18c8334afc
-  data.tar.gz: 78edabbca2c71e9c6d2c793bd3786d5b826f4530664aa18e7cd42cb059a85373
+  metadata.gz: eb8c8d2264141849784cb8a103b9521a8fad5ba11eba1daa9a5a576f02c2bcc6
+  data.tar.gz: e9b5a2a2f123ad3e84007407123103535844dcde3c7e9f3da304eb019d55f96d
 SHA512:
-  metadata.gz: 5cad943f3641de44f17da3fe2062ed83525d0bbb1d4321208f55b4d05d6a43840f25fe0728fa4e10f42701dd8ef4eaa2322ca9ab8c8d6a2e7d7067c70d0d3186
-  data.tar.gz: a58309dcbfaadbb9f67352c0a1730be8397c2522ef403093fcf58a8fdcc596b45e961d39b239e40412d46d98a50033ed02398efc70df4314631bd16e220a7c88
+  metadata.gz: bc9c11edab1b705ba7f51f63bf0315c94d5c3f4178684c42da4042adeef52da7570939a91556301dcb076a08a9dc816b89cd38c8a5399c7a8fe81baf2562ca01
+  data.tar.gz: aa0cc8a93443e8fa17582ac89dca1eba8714080ebab2d0199b0a298f77ccf3f0a019b457615e18e6dd8827f3573e0fe657d9ada3c36d6e8cd588e2b2c4a4090f

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 ## Next Release
 
+## 8.0.1 (02/10/2025)
+
+* Update benchmark to use sqlite
+* Reduce mem allocations
+* Require active_support's inflections module before requiring the delegation module
+
+## 8.0.0 (11/10/2024)
+
+* Support Rails 8
+* Drop Rails 4.0 and 4.1 support
+* Require Ruby at least 2.7.0
+* Store global objects into thread-local variables
+* Avoid globally polluting `::String` and `::Object` classes
+
+## 7.2.0 (07/12/2024)
+
+* Support Rails 7.2
+* Fix count method signature for active_record5 and active_record60
+
 ## 7.1.6 (01/16/2024)
 
 * Allow apps to not include the user in a notification

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 - 2022 Richard Huang (flyerhzm@gmail.com)
+Copyright (c) 2009 - 2024 Richard Huang (flyerhzm@gmail.com)
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -3,7 +3,7 @@
 ![Main workflow](https://github.com/flyerhzm/bullet/actions/workflows/main.yml/badge.svg)
 [![Gem Version](https://badge.fury.io/rb/bullet.svg)](http://badge.fury.io/rb/bullet)
 [![AwesomeCode Status for flyerhzm/bullet](https://awesomecode.io/projects/6755235b-e2c1-459e-bf92-b8b13d0c0472/status)](https://awesomecode.io/repos/flyerhzm/bullet)
-[![Coderwall Endorse](http://api.coderwall.com/flyerhzm/endorsecount.png)](http://coderwall.com/flyerhzm)
+[![Coderwall Endorse](https://coderwall.com/flyerhzm/endorsecount.png)](https://coderwall.com/flyerhzm)
 
 The Bullet gem is designed to help you increase your application's performance by reducing the number of queries it makes. It will watch your queries while you develop your application and notify you when you should add eager loading (N+1 queries), when you're using eager loading that isn't necessary and when you should use counter cache.
 
@@ -20,7 +20,7 @@ If you use activerecord 3.x, please use bullet < 5.5.0
 * [http://railscasts.com/episodes/372-bullet](http://railscasts.com/episodes/372-bullet)
 * [http://ruby5.envylabs.com/episodes/9-episode-8-september-8-2009](http://ruby5.envylabs.com/episodes/9-episode-8-september-8-2009)
 * [http://railslab.newrelic.com/2009/10/23/episode-19-on-the-edge-part-1](http://railslab.newrelic.com/2009/10/23/episode-19-on-the-edge-part-1)
-* [http://weblog.rubyonrails.org/2009/10/22/community-highlights](http://weblog.rubyonrails.org/2009/10/22/community-highlights)
+* [https://rubyonrails.org/2009/10/22/community-highlights](https://rubyonrails.org/2009/10/22/community-highlights)
 
 ## Install
 

data/lib/bullet/active_record5.rb

@@ -273,7 +273,7 @@ module Bullet
 
       ::ActiveRecord::Associations::CollectionProxy.prepend(
         Module.new do
-          def count
+          def count(column_name = nil)
             if Bullet.start? && !proxy_association.is_a?(::ActiveRecord::Associations::ThroughAssociation)
               Bullet::Detector::CounterCache.add_counter_cache(
                 proxy_association.owner,
@@ -284,7 +284,7 @@ module Bullet
                 proxy_association.reflection.name
               )
             end
-            super
+            super(column_name)
           end
         end
       )

data/lib/bullet/active_record60.rb

@@ -282,7 +282,7 @@ module Bullet
 
       ::ActiveRecord::Associations::CollectionProxy.prepend(
         Module.new do
-          def count
+          def count(column_name = nil)
             if Bullet.start? && !proxy_association.is_a?(::ActiveRecord::Associations::ThroughAssociation)
               Bullet::Detector::CounterCache.add_counter_cache(
                 proxy_association.owner,
@@ -293,7 +293,7 @@ module Bullet
                 proxy_association.reflection.name
               )
             end
-            super
+            super(column_name)
           end
         end
       )

data/lib/bullet/active_record72.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+module Bullet
+  module SaveWithBulletSupport
+    def _create_record(*)
+      super do
+        Bullet::Detector::NPlusOneQuery.add_impossible_object(self)
+        yield(self) if block_given?
+      end
+    end
+  end
+
+  module ActiveRecord
+    def self.enable
+      require 'active_record'
+      ::ActiveRecord::Base.extend(
+        Module.new do
+          def find_by_sql(sql, binds = [], preparable: nil, allow_retry: false, &block)
+            result = super
+            if Bullet.start?
+              if result.is_a? Array
+                if result.size > 1
+                  Bullet::Detector::NPlusOneQuery.add_possible_objects(result)
+                  Bullet::Detector::CounterCache.add_possible_objects(result)
+                elsif result.size == 1
+                  Bullet::Detector::NPlusOneQuery.add_impossible_object(result.first)
+                  Bullet::Detector::CounterCache.add_impossible_object(result.first)
+                end
+              elsif result.is_a? ::ActiveRecord::Base
+                Bullet::Detector::NPlusOneQuery.add_impossible_object(result)
+                Bullet::Detector::CounterCache.add_impossible_object(result)
+              end
+            end
+            result
+          end
+        end
+      )
+
+      ::ActiveRecord::Base.prepend(SaveWithBulletSupport)
+
+      ::ActiveRecord::Relation.prepend(
+        Module.new do
+          # 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 records
+            result = super
+            if Bullet.start?
+              if result.first.class.name !~ /^HABTM_/
+                if result.size > 1
+                  Bullet::Detector::NPlusOneQuery.add_possible_objects(result)
+                  Bullet::Detector::CounterCache.add_possible_objects(result)
+                elsif result.size == 1
+                  Bullet::Detector::NPlusOneQuery.add_impossible_object(result.first)
+                  Bullet::Detector::CounterCache.add_impossible_object(result.first)
+                end
+              end
+            end
+            result
+          end
+        end
+      )
+
+      ::ActiveRecord::Associations::Preloader::Batch.prepend(
+        Module.new do
+          def call
+            if Bullet.start?
+              @preloaders.each do |preloader|
+                preloader.records.each { |record|
+                  Bullet::Detector::Association.add_object_associations(record, preloader.associations)
+                }
+                Bullet::Detector::UnusedEagerLoading.add_eager_loadings(preloader.records, preloader.associations)
+              end
+            end
+            super
+          end
+        end
+      )
+
+      ::ActiveRecord::Associations::Preloader::Branch.prepend(
+        Module.new do
+          def preloaders_for_reflection(reflection, reflection_records)
+            if Bullet.start?
+              reflection_records.compact!
+              if reflection_records.first.class.name !~ /^HABTM_/
+                reflection_records.each { |record|
+                  Bullet::Detector::Association.add_object_associations(record, reflection.name)
+                }
+                Bullet::Detector::UnusedEagerLoading.add_eager_loadings(reflection_records, reflection.name)
+              end
+            end
+            super
+          end
+        end
+      )
+
+      ::ActiveRecord::Associations::Preloader::ThroughAssociation.prepend(
+        Module.new do
+          def source_preloaders
+            if Bullet.start? && !defined?(@source_preloaders)
+              preloaders = super
+              preloaders.each do |preloader|
+                reflection_name = preloader.send(:reflection).name
+                preloader.send(:owners).each do |owner|
+                  Bullet::Detector::NPlusOneQuery.call_association(owner, reflection_name)
+                end
+              end
+            else
+              super
+            end
+          end
+        end
+      )
+
+      ::ActiveRecord::Associations::JoinDependency.prepend(
+        Module.new do
+          def instantiate(result_set, strict_loading_value, &block)
+            @bullet_eager_loadings = {}
+            records = super
+
+            if Bullet.start?
+              @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
+            end
+            records
+          end
+
+          def construct(ar_parent, parent, row, seen, model_cache, strict_loading_value)
+            if Bullet.start?
+              unless ar_parent.nil?
+                parent.children.each do |node|
+                  key = aliases.column_alias(node, node.primary_key)
+                  id = row[key]
+                  next unless id.nil?
+
+                  associations = [node.reflection.name]
+                  if node.reflection.through_reflection?
+                    associations << node.reflection.through_reflection.name
+                  end
+                  associations.each do |association|
+                    Bullet::Detector::Association.add_object_associations(ar_parent, association)
+                    Bullet::Detector::NPlusOneQuery.call_association(ar_parent, association)
+                    @bullet_eager_loadings[ar_parent.class] ||= {}
+                    @bullet_eager_loadings[ar_parent.class][ar_parent] ||= Set.new
+                    @bullet_eager_loadings[ar_parent.class][ar_parent] << association
+                  end
+                end
+              end
+            end
+
+            super
+          end
+
+          # call join associations
+          def construct_model(record, node, row, model_cache, id, strict_loading_value)
+            result = super
+
+            if Bullet.start?
+              associations = [node.reflection.name]
+              if node.reflection.through_reflection?
+                associations << node.reflection.through_reflection.name
+              end
+              associations.each do |association|
+                Bullet::Detector::Association.add_object_associations(record, association)
+                Bullet::Detector::NPlusOneQuery.call_association(record, association)
+                @bullet_eager_loadings[record.class] ||= {}
+                @bullet_eager_loadings[record.class][record] ||= Set.new
+                @bullet_eager_loadings[record.class][record] << association
+              end
+            end
+
+            result
+          end
+        end
+      )
+
+      ::ActiveRecord::Associations::Association.prepend(
+        Module.new do
+          def inversed_from(record)
+            if Bullet.start?
+              Bullet::Detector::NPlusOneQuery.add_inversed_object(owner, reflection.name)
+            end
+            super
+          end
+
+          def inversed_from_queries(record)
+            if Bullet.start? && inversable?(record)
+              Bullet::Detector::NPlusOneQuery.add_inversed_object(owner, reflection.name)
+            end
+            super
+          end
+        end
+      )
+
+      ::ActiveRecord::Associations::CollectionAssociation.prepend(
+        Module.new do
+          def load_target
+            records = super
+
+            if Bullet.start?
+              if is_a? ::ActiveRecord::Associations::ThroughAssociation
+                association = owner.association(reflection.through_reflection.name)
+                if association.loaded?
+                  Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.through_reflection.name)
+                  Array.wrap(association.target).each do |through_record|
+                    Bullet::Detector::NPlusOneQuery.call_association(through_record, source_reflection.name)
+                  end
+
+                  if reflection.through_reflection != through_reflection
+                    Bullet::Detector::NPlusOneQuery.call_association(owner, through_reflection.name)
+                  end
+                end
+              end
+              Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name)
+              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
+            end
+            records
+          end
+
+          def empty?
+            if Bullet.start? && !reflection.has_cached_counter?
+              Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name)
+            end
+            super
+          end
+
+          def include?(object)
+            Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name) if Bullet.start?
+            super
+          end
+        end
+      )
+
+      ::ActiveRecord::Associations::SingularAssociation.prepend(
+        Module.new do
+          # call has_one and belongs_to associations
+          def reader
+            result = super
+
+            if Bullet.start?
+              if owner.class.name !~ /^HABTM_/
+                if is_a? ::ActiveRecord::Associations::ThroughAssociation
+                  Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.through_reflection.name)
+                  association = owner.association(reflection.through_reflection.name)
+                  Array.wrap(association.target).each do |through_record|
+                    Bullet::Detector::NPlusOneQuery.call_association(through_record, source_reflection.name)
+                  end
+
+                  if reflection.through_reflection != through_reflection
+                    Bullet::Detector::NPlusOneQuery.call_association(owner, through_reflection.name)
+                  end
+                end
+                Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name)
+
+                if Bullet::Detector::NPlusOneQuery.impossible?(owner)
+                  Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
+                else
+                  Bullet::Detector::NPlusOneQuery.add_possible_objects(result) if result
+                end
+              end
+            end
+            result
+          end
+        end
+      )
+
+      ::ActiveRecord::Associations::HasManyAssociation.prepend(
+        Module.new do
+          def empty?
+            result = super
+            if Bullet.start? && !reflection.has_cached_counter?
+              Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name)
+            end
+            result
+          end
+
+          def count_records
+            result = reflection.has_cached_counter?
+            if Bullet.start? && !result && !is_a?(::ActiveRecord::Associations::ThroughAssociation)
+              Bullet::Detector::CounterCache.add_counter_cache(owner, reflection.name)
+            end
+            super
+          end
+        end
+      )
+
+      ::ActiveRecord::Associations::CollectionProxy.prepend(
+        Module.new do
+          def count(column_name = nil)
+            if Bullet.start? && !proxy_association.is_a?(::ActiveRecord::Associations::ThroughAssociation)
+              Bullet::Detector::CounterCache.add_counter_cache(
+                proxy_association.owner,
+                proxy_association.reflection.name
+              )
+              Bullet::Detector::NPlusOneQuery.call_association(
+                proxy_association.owner,
+                proxy_association.reflection.name
+              )
+            end
+            super(column_name)
+          end
+        end
+      )
+    end
+  end
+end

data/lib/bullet/active_record80.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+module Bullet
+  module SaveWithBulletSupport
+    def _create_record(*)
+      super do
+        Bullet::Detector::NPlusOneQuery.add_impossible_object(self)
+        yield(self) if block_given?
+      end
+    end
+  end
+
+  module ActiveRecord
+    def self.enable
+      require 'active_record'
+      ::ActiveRecord::Base.extend(
+        Module.new do
+          def find_by_sql(sql, binds = [], preparable: nil, allow_retry: false, &block)
+            result = super
+            if Bullet.start?
+              if result.is_a? Array
+                if result.size > 1
+                  Bullet::Detector::NPlusOneQuery.add_possible_objects(result)
+                  Bullet::Detector::CounterCache.add_possible_objects(result)
+                elsif result.size == 1
+                  Bullet::Detector::NPlusOneQuery.add_impossible_object(result.first)
+                  Bullet::Detector::CounterCache.add_impossible_object(result.first)
+                end
+              elsif result.is_a? ::ActiveRecord::Base
+                Bullet::Detector::NPlusOneQuery.add_impossible_object(result)
+                Bullet::Detector::CounterCache.add_impossible_object(result)
+              end
+            end
+            result
+          end
+        end
+      )
+
+      ::ActiveRecord::Base.prepend(SaveWithBulletSupport)
+
+      ::ActiveRecord::Relation.prepend(
+        Module.new do
+          # 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 records
+            result = super
+            if Bullet.start?
+              if result.first.class.name !~ /^HABTM_/
+                if result.size > 1
+                  Bullet::Detector::NPlusOneQuery.add_possible_objects(result)
+                  Bullet::Detector::CounterCache.add_possible_objects(result)
+                elsif result.size == 1
+                  Bullet::Detector::NPlusOneQuery.add_impossible_object(result.first)
+                  Bullet::Detector::CounterCache.add_impossible_object(result.first)
+                end
+              end
+            end
+            result
+          end
+        end
+      )
+
+      ::ActiveRecord::Associations::Preloader::Batch.prepend(
+        Module.new do
+          def call
+            if Bullet.start?
+              @preloaders.each do |preloader|
+                preloader.records.each { |record|
+                  Bullet::Detector::Association.add_object_associations(record, preloader.associations)
+                }
+                Bullet::Detector::UnusedEagerLoading.add_eager_loadings(preloader.records, preloader.associations)
+              end
+            end
+            super
+          end
+        end
+      )
+
+      ::ActiveRecord::Associations::Preloader::Branch.prepend(
+        Module.new do
+          def preloaders_for_reflection(reflection, reflection_records)
+            if Bullet.start?
+              reflection_records.compact!
+              if reflection_records.first.class.name !~ /^HABTM_/
+                reflection_records.each { |record|
+                  Bullet::Detector::Association.add_object_associations(record, reflection.name)
+                }
+                Bullet::Detector::UnusedEagerLoading.add_eager_loadings(reflection_records, reflection.name)
+              end
+            end
+            super
+          end
+        end
+      )
+
+      ::ActiveRecord::Associations::Preloader::ThroughAssociation.prepend(
+        Module.new do
+          def source_preloaders
+            if Bullet.start? && !defined?(@source_preloaders)
+              preloaders = super
+              preloaders.each do |preloader|
+                reflection_name = preloader.send(:reflection).name
+                preloader.send(:owners).each do |owner|
+                  Bullet::Detector::NPlusOneQuery.call_association(owner, reflection_name)
+                end
+              end
+            else
+              super
+            end
+          end
+        end
+      )
+
+      ::ActiveRecord::Associations::JoinDependency.prepend(
+        Module.new do
+          def instantiate(result_set, strict_loading_value, &block)
+            @bullet_eager_loadings = {}
+            records = super
+
+            if Bullet.start?
+              @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
+            end
+            records
+          end
+
+          def construct(ar_parent, parent, row, seen, model_cache, strict_loading_value)
+            if Bullet.start?
+              unless ar_parent.nil?
+                parent.children.each do |node|
+                  key = aliases.column_alias(node, node.primary_key)
+                  id = row[key]
+                  next unless id.nil?
+
+                  associations = [node.reflection.name]
+                  if node.reflection.through_reflection?
+                    associations << node.reflection.through_reflection.name
+                  end
+                  associations.each do |association|
+                    Bullet::Detector::Association.add_object_associations(ar_parent, association)
+                    Bullet::Detector::NPlusOneQuery.call_association(ar_parent, association)
+                    @bullet_eager_loadings[ar_parent.class] ||= {}
+                    @bullet_eager_loadings[ar_parent.class][ar_parent] ||= Set.new
+                    @bullet_eager_loadings[ar_parent.class][ar_parent] << association
+                  end
+                end
+              end
+            end
+
+            super
+          end
+
+          # call join associations
+          def construct_model(record, node, row, model_cache, id, strict_loading_value)
+            result = super
+
+            if Bullet.start?
+              associations = [node.reflection.name]
+              if node.reflection.through_reflection?
+                associations << node.reflection.through_reflection.name
+              end
+              associations.each do |association|
+                Bullet::Detector::Association.add_object_associations(record, association)
+                Bullet::Detector::NPlusOneQuery.call_association(record, association)
+                @bullet_eager_loadings[record.class] ||= {}
+                @bullet_eager_loadings[record.class][record] ||= Set.new
+                @bullet_eager_loadings[record.class][record] << association
+              end
+            end
+
+            result
+          end
+        end
+      )
+
+      ::ActiveRecord::Associations::Association.prepend(
+        Module.new do
+          def inversed_from(record)
+            if Bullet.start?
+              Bullet::Detector::NPlusOneQuery.add_inversed_object(owner, reflection.name)
+            end
+            super
+          end
+
+          def inversed_from_queries(record)
+            if Bullet.start? && inversable?(record)
+              Bullet::Detector::NPlusOneQuery.add_inversed_object(owner, reflection.name)
+            end
+            super
+          end
+        end
+      )
+
+      ::ActiveRecord::Associations::CollectionAssociation.prepend(
+        Module.new do
+          def load_target
+            records = super
+
+            if Bullet.start?
+              if is_a? ::ActiveRecord::Associations::ThroughAssociation
+                association = owner.association(reflection.through_reflection.name)
+                if association.loaded?
+                  Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.through_reflection.name)
+                  Array.wrap(association.target).each do |through_record|
+                    Bullet::Detector::NPlusOneQuery.call_association(through_record, source_reflection.name)
+                  end
+
+                  if reflection.through_reflection != through_reflection
+                    Bullet::Detector::NPlusOneQuery.call_association(owner, through_reflection.name)
+                  end
+                end
+              end
+              Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name)
+              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
+            end
+            records
+          end
+
+          def empty?
+            if Bullet.start? && !reflection.has_cached_counter?
+              Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name)
+            end
+            super
+          end
+
+          def include?(object)
+            Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name) if Bullet.start?
+            super
+          end
+        end
+      )
+
+      ::ActiveRecord::Associations::SingularAssociation.prepend(
+        Module.new do
+          # call has_one and belongs_to associations
+          def reader
+            result = super
+
+            if Bullet.start?
+              if owner.class.name !~ /^HABTM_/
+                if is_a? ::ActiveRecord::Associations::ThroughAssociation
+                  Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.through_reflection.name)
+                  association = owner.association(reflection.through_reflection.name)
+                  Array.wrap(association.target).each do |through_record|
+                    Bullet::Detector::NPlusOneQuery.call_association(through_record, source_reflection.name)
+                  end
+
+                  if reflection.through_reflection != through_reflection
+                    Bullet::Detector::NPlusOneQuery.call_association(owner, through_reflection.name)
+                  end
+                end
+                Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name)
+
+                if Bullet::Detector::NPlusOneQuery.impossible?(owner)
+                  Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
+                else
+                  Bullet::Detector::NPlusOneQuery.add_possible_objects(result) if result
+                end
+              end
+            end
+            result
+          end
+        end
+      )
+
+      ::ActiveRecord::Associations::HasManyAssociation.prepend(
+        Module.new do
+          def empty?
+            result = super
+            if Bullet.start? && !reflection.has_cached_counter?
+              Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name)
+            end
+            result
+          end
+
+          def count_records
+            result = reflection.has_cached_counter?
+            if Bullet.start? && !result && !is_a?(::ActiveRecord::Associations::ThroughAssociation)
+              Bullet::Detector::CounterCache.add_counter_cache(owner, reflection.name)
+            end
+            super
+          end
+        end
+      )
+
+      ::ActiveRecord::Associations::CollectionProxy.prepend(
+        Module.new do
+          def count(column_name = nil)
+            if Bullet.start? && !proxy_association.is_a?(::ActiveRecord::Associations::ThroughAssociation)
+              Bullet::Detector::CounterCache.add_counter_cache(
+                proxy_association.owner,
+                proxy_association.reflection.name
+              )
+              Bullet::Detector::NPlusOneQuery.call_association(
+                proxy_association.owner,
+                proxy_association.reflection.name
+              )
+            end
+            super(column_name)
+          end
+        end
+      )
+    end
+  end
+end

data/lib/bullet/dependency.rb

@@ -33,6 +33,10 @@ module Bullet
             'active_record70'
           elsif active_record71?
             'active_record71'
+          elsif active_record72?
+            'active_record72'
+          elsif active_record80?
+            'active_record80'
           else
             raise "Bullet does not support active_record #{::ActiveRecord::VERSION::STRING} yet"
           end
@@ -74,6 +78,10 @@ module Bullet
       active_record? && ::ActiveRecord::VERSION::MAJOR == 7
     end
 
+    def active_record8?
+      active_record? && ::ActiveRecord::VERSION::MAJOR == 8
+    end
+
     def active_record40?
       active_record4? && ::ActiveRecord::VERSION::MINOR == 0
     end
@@ -114,6 +122,14 @@ module Bullet
       active_record7? && ::ActiveRecord::VERSION::MINOR == 1
     end
 
+    def active_record72?
+      active_record7? && ::ActiveRecord::VERSION::MINOR == 2
+    end
+
+    def active_record80?
+      active_record8? && ::ActiveRecord::VERSION::MINOR == 0
+    end
+
     def mongoid4x?
       mongoid? && ::Mongoid::VERSION =~ /\A4/
     end

data/lib/bullet/detector/association.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+using Bullet::Ext::Object
+
 module Bullet
   module Detector
     class Association < Base
@@ -34,7 +36,7 @@ module Bullet
         # that the objects may cause N+1 query.
         # e.g. { Post => ["Post:1", "Post:2"] }
         def possible_objects
-          Thread.current[:bullet_possible_objects]
+          Thread.current.thread_variable_get(:bullet_possible_objects)
         end
 
         # impossible_objects keep the class to objects relationships
@@ -43,7 +45,7 @@ module Bullet
         # 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]
+          Thread.current.thread_variable_get(:bullet_impossible_objects)
         end
 
         private
@@ -54,7 +56,7 @@ module Bullet
         # 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]
+          Thread.current.thread_variable_get(:bullet_object_associations)
         end
 
         # call_object_associations keep the object relationships
@@ -62,27 +64,27 @@ module Bullet
         # e.g. { "Post:1" => [:comments] }
         # they are used to detect unused preload associations.
         def call_object_associations
-          Thread.current[:bullet_call_object_associations]
+          Thread.current.thread_variable_get(:bullet_call_object_associations)
         end
 
         # inversed_objects keeps object relationships
         # that association is inversed.
         # e.g. { "Comment:1" => ["post"] }
         def inversed_objects
-          Thread.current[:bullet_inversed_objects]
+          Thread.current.thread_variable_get(:bullet_inversed_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]
+          Thread.current.thread_variable_get(:bullet_eager_loadings)
         end
 
-        # cal_stacks keeps stacktraces where querie-objects were called from.
+        # call_stacks keeps stacktraces where querie-objects were called from.
         # e.g. { 'Object:111' => [SomeProject/app/controllers/...] }
         def call_stacks
-          Thread.current[:bullet_call_stacks]
+          Thread.current.thread_variable_get(:bullet_call_stacks)
         end
       end
     end

data/lib/bullet/detector/counter_cache.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+using Bullet::Ext::Object
+
 module Bullet
   module Detector
     class CounterCache < Base
@@ -44,11 +46,11 @@ module Bullet
         end
 
         def possible_objects
-          Thread.current[:bullet_counter_possible_objects]
+          Thread.current.thread_variable_get(:bullet_counter_possible_objects)
         end
 
         def impossible_objects
-          Thread.current[:bullet_counter_impossible_objects]
+          Thread.current.thread_variable_get(:bullet_counter_impossible_objects)
         end
 
         private

data/lib/bullet/detector/n_plus_one_query.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+using Bullet::Ext::Object
+
 module Bullet
   module Detector
     class NPlusOneQuery < Association
@@ -25,7 +27,7 @@ module Bullet
           )
           if !excluded_stacktrace_path? && conditions_met?(object, associations)
             Bullet.debug('detect n + 1 query', "object: #{object.bullet_key}, associations: #{associations}")
-            create_notification caller_in_project(object.bullet_key), object.class.to_s, associations
+            create_notification(caller_in_project(object.bullet_key), object.class.to_s, associations)
           end
         end
 
@@ -36,16 +38,17 @@ module Bullet
           objects = Array.wrap(object_or_objects)
           class_names_match_regex = true
           primary_key_values_are_empty = true
-          keys_joined = ""
-          objects.each do |obj|
+
+          keys_joined = objects.map do |obj|
             unless obj.class.name =~ /^HABTM_/
               class_names_match_regex = false
             end
             unless obj.bullet_primary_key_value.nil?
               primary_key_values_are_empty = false
             end
-            keys_joined += "#{(keys_joined.empty? ? '' : ', ')}#{obj.bullet_key}"
-          end
+            obj.bullet_key
+          end.join(", ")
+
           unless class_names_match_regex || primary_key_values_are_empty
             Bullet.debug('Detector::NPlusOneQuery#add_possible_objects', "objects: #{keys_joined}")
             objects.each { |object| possible_objects.add object.bullet_key }

data/lib/bullet/detector/unused_eager_loading.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+using Bullet::Ext::Object
+using Bullet::Ext::String
+
 module Bullet
   module Detector
     class UnusedEagerLoading < Association

data/lib/bullet/ext/object.rb

@@ -1,30 +1,34 @@
 # frozen_string_literal: true
 
-class Object
-  def bullet_key
-    "#{self.class}:#{bullet_primary_key_value}"
-  end
+module Bullet
+  module Ext
+    module Object
+      refine ::Object do
+        attr_writer :bullet_key, :bullet_primary_key_value
 
-  def bullet_primary_key_value
-    return if respond_to?(:persisted?) && !persisted?
+        def bullet_key
+          @bullet_key ||= "#{self.class}:#{bullet_primary_key_value}"
+        end
 
-    if self.class.respond_to?(:primary_keys) && self.class.primary_keys
-      primary_key = self.class.primary_keys
-    elsif self.class.respond_to?(:primary_key) && self.class.primary_key
-      primary_key = self.class.primary_key
-    else
-      primary_key = :id
-    end
+        def bullet_primary_key_value
+          @bullet_primary_key_value ||= begin
+            return if respond_to?(:persisted?) && !persisted?
 
-    bullet_join_potential_composite_primary_key(primary_key)
-  end
+            primary_key = self.class.try(:primary_keys) || self.class.try(:primary_key) || :id
 
-  private
+            bullet_join_potential_composite_primary_key(primary_key)
+          end
+        end
 
-  def bullet_join_potential_composite_primary_key(primary_keys)
-    return send(primary_keys) unless primary_keys.is_a?(Enumerable)
+        private
 
-    primary_keys.map { |primary_key| send primary_key }
-                .join(',')
+        def bullet_join_potential_composite_primary_key(primary_keys)
+          return send(primary_keys) unless primary_keys.is_a?(Enumerable)
+
+          primary_keys.map { |primary_key| send primary_key }
+                      .join(',')
+        end
+      end
+    end
   end
 end

data/lib/bullet/ext/string.rb

@@ -1,7 +1,14 @@
 # frozen_string_literal: true
 
-class String
-  def bullet_class_name
-    sub(/:[^:]*?$/, '')
+module Bullet
+  module Ext
+    module String
+      refine ::String do
+        def bullet_class_name
+          last_colon = self.rindex(':')
+          last_colon ? self[0...last_colon].dup : self.dup
+        end
+      end
+    end
   end
 end

data/lib/bullet/registry/call_stack.rb

@@ -5,7 +5,7 @@ module Bullet
     class CallStack < Base
       # remembers found association backtrace
       def add(key)
-        @registry[key] = Thread.current.backtrace
+        @registry[key] ||= Thread.current.backtrace
       end
     end
   end

data/lib/bullet/registry/object.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+using Bullet::Ext::Object
+using Bullet::Ext::String
+
 module Bullet
   module Registry
     class Object < Base

data/lib/bullet/stack_trace_filter.rb

@@ -2,10 +2,11 @@
 
 require "bundler"
 
+using Bullet::Ext::Object
+
 module Bullet
   module StackTraceFilter
     VENDOR_PATH = '/vendor'
-    IS_RUBY_19 = Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0.0')
 
     # @param bullet_key[String] - use this to get stored call stack from call_stacks object.
     def caller_in_project(bullet_key = nil)
@@ -54,13 +55,12 @@ module Bullet
     def location_as_path(location)
       return location if location.is_a?(String)
 
-      IS_RUBY_19 ? location : location.absolute_path.to_s
+      location.absolute_path.to_s
     end
 
     def select_caller_locations(bullet_key = nil)
-      return caller.select { |caller_path| yield caller_path } if IS_RUBY_19
-
       call_stack = bullet_key ? call_stacks[bullet_key] : caller_locations
+
       call_stack.select { |location| yield location }
     end
   end

data/lib/bullet/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bullet
-  VERSION = '7.1.6'
+  VERSION = '8.0.1'
 end

data/lib/bullet.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'active_support/core_ext/string/inflections'
 require 'active_support/core_ext/module/delegation'
 require 'set'
 require 'uniform_notifier'
@@ -148,42 +149,47 @@ module Bullet
     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_inversed_objects] = Bullet::Registry::Base.new
-      Thread.current[:bullet_eager_loadings] = Bullet::Registry::Association.new
-      Thread.current[:bullet_call_stacks] = Bullet::Registry::CallStack.new
+      Thread.current.thread_variable_set(:bullet_start, true)
+      Thread.current.thread_variable_set(:bullet_notification_collector, Bullet::NotificationCollector.new)
+
+      Thread.current.thread_variable_set(:bullet_object_associations, Bullet::Registry::Base.new)
+      Thread.current.thread_variable_set(:bullet_call_object_associations, Bullet::Registry::Base.new)
+      Thread.current.thread_variable_set(:bullet_possible_objects, Bullet::Registry::Object.new)
+      Thread.current.thread_variable_set(:bullet_impossible_objects, Bullet::Registry::Object.new)
+      Thread.current.thread_variable_set(:bullet_inversed_objects, Bullet::Registry::Base.new)
+      Thread.current.thread_variable_set(:bullet_eager_loadings, Bullet::Registry::Association.new)
+      Thread.current.thread_variable_set(:bullet_call_stacks, Bullet::Registry::CallStack.new)
+
+      unless Thread.current.thread_variable_get(:bullet_counter_possible_objects)
+        Thread.current.thread_variable_set(:bullet_counter_possible_objects, Bullet::Registry::Object.new)
+      end
 
-      Thread.current[:bullet_counter_possible_objects] ||= Bullet::Registry::Object.new
-      Thread.current[:bullet_counter_impossible_objects] ||= Bullet::Registry::Object.new
+      unless Thread.current.thread_variable_get(:bullet_counter_impossible_objects)
+        Thread.current.thread_variable_set(:bullet_counter_impossible_objects, Bullet::Registry::Object.new)
+      end
     end
 
     def end_request
-      Thread.current[:bullet_start] = nil
-      Thread.current[:bullet_notification_collector] = nil
+      Thread.current.thread_variable_set(:bullet_start, nil)
+      Thread.current.thread_variable_set(:bullet_notification_collector, nil)
 
-      Thread.current[:bullet_object_associations] = nil
-      Thread.current[:bullet_call_object_associations] = nil
-      Thread.current[:bullet_possible_objects] = nil
-      Thread.current[:bullet_impossible_objects] = nil
-      Thread.current[:bullet_inversed_objects] = nil
-      Thread.current[:bullet_eager_loadings] = nil
+      Thread.current.thread_variable_set(:bullet_object_associations, nil)
+      Thread.current.thread_variable_set(:bullet_call_object_associations, nil)
+      Thread.current.thread_variable_set(:bullet_possible_objects, nil)
+      Thread.current.thread_variable_set(:bullet_impossible_objects, nil)
+      Thread.current.thread_variable_set(:bullet_inversed_objects, nil)
+      Thread.current.thread_variable_set(:bullet_eager_loadings, nil)
 
-      Thread.current[:bullet_counter_possible_objects] = nil
-      Thread.current[:bullet_counter_impossible_objects] = nil
+      Thread.current.thread_variable_set(:bullet_counter_possible_objects, nil)
+      Thread.current.thread_variable_set(:bullet_counter_impossible_objects, nil)
     end
 
     def start?
-      enable? && Thread.current[:bullet_start]
+      enable? && Thread.current.thread_variable_get(:bullet_start)
     end
 
     def notification_collector
-      Thread.current[:bullet_notification_collector]
+      Thread.current.thread_variable_get(:bullet_notification_collector)
     end
 
     def notification?

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: bullet
 version: !ruby/object:Gem::Version
-  version: 7.1.6
+  version: 8.0.1
 platform: ruby
 authors:
 - Richard Huang
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-16 00:00:00.000000000 Z
+date: 2025-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -59,6 +58,8 @@ files:
 - lib/bullet/active_record61.rb
 - lib/bullet/active_record70.rb
 - lib/bullet/active_record71.rb
+- lib/bullet/active_record72.rb
+- lib/bullet/active_record80.rb
 - lib/bullet/bullet_xhr.js
 - lib/bullet/dependency.rb
 - lib/bullet/detector.rb
@@ -96,7 +97,6 @@ licenses:
 metadata:
   changelog_uri: https://github.com/flyerhzm/bullet/blob/main/CHANGELOG.md
   source_code_uri: https://github.com/flyerhzm/bullet
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -104,15 +104,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubygems_version: 3.5.3
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: help to kill N+1 queries and unused eager loading.
 test_files: []