bullet 8.2.0 → 8.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fff8caa10888c5cc1aee062b08ac4c4df6e5911e9b4c592b3e0c89c3faedf089
-  data.tar.gz: aebe5eb8c7b8624fc2bbe05f42c4c6e8ba5ef8122f519e4e2f984f83d1ac8762
+  metadata.gz: d5c5aff8226198c501ed0c0a3e9d71138bd896f9956cf072b0f92fef79b125c7
+  data.tar.gz: 90209fe95da7ad96e110cfdabb96a91a9c403ef9e5824df2877aeab20239f020
 SHA512:
-  metadata.gz: 6d60f48c25171229b660274b31ae90689f402d0ea1f46fdf2c63467a550765520b46afb70ff683a8beca75da7ddb86629ba5f58e276667a784d37653f3a94688
-  data.tar.gz: '06973354f3d5158e1ade0f2898577d772b6669d622b176010b6176dbb8b02e5f67c611fbb55668bfee9c93ea873c1183cd28ba30e778a5a6692d0e050a9a3794'
+  metadata.gz: 98dbc38b0e5f77f61617e75bab2b92838bbead761421681791711c917f61282e6ae29fe70fabe645ef8685344a879535fb4634451ff1bb35d560b0fd8a9c3a12
+  data.tar.gz: 49f2ebf88e0d99386ebd35a82403ece35167e9ac253013244f9ded4fe76de6b14ea070741847b6048b90ca1e15b6765430a56a180d8f6e6961383be035d08b38

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## Unreleased
 
+## 8.3.1 (10/24/2026)
+
+* Avoid redefining the `footer_position` getter
+* Avoid the CGI loading warning on Ruby 4
+* Keep request state separate for sibling fibers on one thread
+
+## 8.3.0 (10/10/2026)
+
+* Add support for ActiveRecord 8.2
+
 ## 8.2.0 (08/29/2026)
 
 * Add thread-safe `Bullet.pause`, `Bullet.resume`, `Bullet.paused?`, and `Bullet.skip` APIs
@@ -11,7 +21,7 @@
 
 ## 8.1.3 (06/02/2026)
 
-* Handle inversed polymorphic belongs_to false positives
+* Handle inversed polymorphic `belongs_to` false positives
 
 ## 8.1.2 (05/25/2026)
 

data/lib/bullet/active_record82.rb

@@ -0,0 +1,335 @@
+# frozen_string_literal: true
+
+module Bullet
+  module SaveWithBulletSupport
+    def _create_record(*)
+      super do
+        Bullet::Detector::NPlusOneQuery.update_inversed_object(self)
+        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(*args, **kwargs, &block)
+            result = super(*args, **kwargs, &block)
+            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
+
+          def through_preloaders
+            if Bullet.start? && !defined?(@through_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(*args, **kwargs, &block)
+            @bullet_eager_loadings = {}
+            records = super(*args, **kwargs, &block)
+
+            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(*args, **kwargs, &block)
+            ar_parent, parent, row = args
+            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(*args, **kwargs, &block)
+          end
+
+          # call join associations
+          def construct_model(*args, **kwargs, &block)
+            record, node = args
+            result = super(*args, **kwargs, &block)
+
+            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, caller_locations)
+            end
+            super
+          end
+
+          def include?(object)
+            Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name, caller_locations) 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?
+            if Bullet.start? && !reflection.has_cached_counter?
+              Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name, caller_locations)
+            end
+            super
+          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,
+                caller_locations
+              )
+            end
+            super(column_name)
+          end
+        end
+      )
+    end
+  end
+end

data/lib/bullet/dependency.rb

@@ -25,6 +25,8 @@ module Bullet
             'active_record80'
           elsif active_record81?
             'active_record81'
+          elsif active_record82?
+            'active_record82'
           else
             raise "Bullet does not support active_record #{::ActiveRecord::VERSION::STRING} yet"
           end
@@ -84,6 +86,10 @@ module Bullet
       active_record8? && ::ActiveRecord::VERSION::MINOR == 1
     end
 
+    def active_record82?
+      active_record8? && ::ActiveRecord::VERSION::MINOR == 2
+    end
+
     def mongoid4x?
       mongoid? && ::Mongoid::VERSION =~ /\A4/
     end

data/lib/bullet/detector/association.rb

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

data/lib/bullet/detector/counter_cache.rb

@@ -46,11 +46,11 @@ module Bullet
         end
 
         def possible_objects
-          Thread.current.thread_variable_get(:bullet_counter_possible_objects)
+          Bullet.state[:bullet_counter_possible_objects]
         end
 
         def impossible_objects
-          Thread.current.thread_variable_get(:bullet_counter_impossible_objects)
+          Bullet.state[:bullet_counter_impossible_objects]
         end
 
         private

data/lib/bullet/rack.rb

@@ -2,7 +2,12 @@
 
 require 'rack/request'
 require 'json'
-require 'cgi'
+
+if RUBY_VERSION.to_i >= 4
+  require 'cgi/escape'
+else
+  require 'cgi'
+end
 
 module Bullet
   class Rack

data/lib/bullet/version.rb

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

data/lib/bullet.rb

@@ -39,10 +39,10 @@ module Bullet
                 :counter_cache_enable,
                 :stacktrace_includes,
                 :stacktrace_excludes,
-                :skip_html_injection
+                :skip_html_injection,
+                :footer_position
     attr_reader :safelist
     attr_accessor :add_footer,
-                  :footer_position,
                   :orm_patches_applied,
                   :skip_http_headers,
                   :always_append_html_body,
@@ -149,56 +149,71 @@ module Bullet
       puts "[Bullet][#{title}] #{message}" if ENV['BULLET_DEBUG'] == 'true'
     end
 
+    # Fiber storage reaches child fibers; start_request gives each request its own, and the owner check keeps it off new threads.
+    def state
+      unless Fiber.respond_to?(:[])
+        return Thread.current.thread_variable_get(:bullet_state) || Thread.current.thread_variable_set(:bullet_state, {})
+      end
+
+      current = Fiber[:bullet_state]
+      return current if current && current[:owner].equal?(Thread.current)
+
+      Fiber[:bullet_state] = { owner: Thread.current }
+    end
+
     def start_request
-      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)
+      if Fiber.respond_to?(:[])
+        Fiber[:bullet_state] = state.slice(:owner)
+      end
+      Bullet.state[:bullet_start] = true
+      Bullet.state[:bullet_notification_collector] = Bullet::NotificationCollector.new
+
+      Bullet.state[:bullet_object_associations] = Bullet::Registry::Base.new
+      Bullet.state[:bullet_call_object_associations] = Bullet::Registry::Base.new
+      Bullet.state[:bullet_possible_objects] = Bullet::Registry::Object.new
+      Bullet.state[:bullet_impossible_objects] = Bullet::Registry::Object.new
+      Bullet.state[:bullet_inversed_objects] = Bullet::Registry::Base.new
+      Bullet.state[:bullet_eager_loadings] = Bullet::Registry::Association.new
+      Bullet.state[:bullet_call_stacks] = Bullet::Registry::CallStack.new
+
+      unless Bullet.state[:bullet_counter_possible_objects]
+        Bullet.state[:bullet_counter_possible_objects] = Bullet::Registry::Object.new
       end
 
-      unless Thread.current.thread_variable_get(:bullet_counter_impossible_objects)
-        Thread.current.thread_variable_set(:bullet_counter_impossible_objects, Bullet::Registry::Object.new)
+      unless Bullet.state[:bullet_counter_impossible_objects]
+        Bullet.state[:bullet_counter_impossible_objects] = Bullet::Registry::Object.new
       end
     end
 
     def end_request
-      Thread.current.thread_variable_set(:bullet_start, nil)
-      Thread.current.thread_variable_set(:bullet_notification_collector, nil)
+      Bullet.state[:bullet_start] = nil
+      Bullet.state[:bullet_notification_collector] = 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)
+      Bullet.state[:bullet_object_associations] = nil
+      Bullet.state[:bullet_call_object_associations] = nil
+      Bullet.state[:bullet_possible_objects] = nil
+      Bullet.state[:bullet_impossible_objects] = nil
+      Bullet.state[:bullet_inversed_objects] = nil
+      Bullet.state[:bullet_eager_loadings] = nil
 
-      Thread.current.thread_variable_set(:bullet_counter_possible_objects, nil)
-      Thread.current.thread_variable_set(:bullet_counter_impossible_objects, nil)
+      Bullet.state[:bullet_counter_possible_objects] = nil
+      Bullet.state[:bullet_counter_impossible_objects] = nil
     end
 
     def start?
-      enable? && Thread.current.thread_variable_get(:bullet_start)
+      enable? && Bullet.state[:bullet_start]
     end
 
     def pause
-      Thread.current.thread_variable_set(:bullet_start, false)
+      Bullet.state[:bullet_start] = false
     end
 
     def resume
-      Thread.current.thread_variable_set(:bullet_start, true)
+      Bullet.state[:bullet_start] = true
     end
 
     def paused?
-      enable? && !Thread.current.thread_variable_get(:bullet_start)
+      enable? && !Bullet.state[:bullet_start]
     end
 
     def skip
@@ -210,7 +225,7 @@ module Bullet
     end
 
     def notification_collector
-      Thread.current.thread_variable_get(:bullet_notification_collector)
+      Bullet.state[:bullet_notification_collector]
     end
 
     def notification?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bullet
 version: !ruby/object:Gem::Version
-  version: 8.2.0
+  version: 8.3.1
 platform: ruby
 authors:
 - Richard Huang
@@ -82,6 +82,7 @@ files:
 - lib/bullet/active_record72.rb
 - lib/bullet/active_record80.rb
 - lib/bullet/active_record81.rb
+- lib/bullet/active_record82.rb
 - lib/bullet/bullet_xhr.js
 - lib/bullet/dependency.rb
 - lib/bullet/detector.rb
@@ -134,7 +135,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.20
 specification_version: 4
 summary: help to kill N+1 queries and unused eager loading.
 test_files: []