active_record_query_counter 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89a919244edbce9bf36bdaa232078b04470f1bacc952469eab4a4fffc2416e08
-  data.tar.gz: 97a66d47fda85ad15b832da3e390f8cc035a374983c64f53e4d673094b54d8b9
+  metadata.gz: 1966d4714e8fc7a3d77b86be07c8c930470d2af298dbd8d88d4bee4043a4da84
+  data.tar.gz: 8ad2b534042042259038f72daff078b6302b552f6a742b4f38f0504afe9a8919
 SHA512:
-  metadata.gz: c5c657cf312deb55e21063b5d08f824cd762e42050704b06fc0610e00f938aacac8fc37050c60d293452521841ca614430cb50cd3bf10d3bca794df9d0dee6d0
-  data.tar.gz: d81cb599eea68c911fad417a902848f1b1f2d0f29f4d095b70d5af8ef2f6366dac0e2b2de0fe534ed51fcbffb3d696147edfc53e64b549862a4dfe78a156a54d
+  metadata.gz: 13a2c8c037ea0b47ea11384e133c294d047a74b34f89564a49adb0c339e2e489a1d61ef8a48c76d31b7a7abbd9afca6caf9ebfea011dcd703dbfec19fa65e46f
+  data.tar.gz: 6ba58ac495883fa98d20e7cda7ae363444f279db7a543016a6ffcdacf1f4f2d7404c8f7f7d06425c9f159d004788c73bde3fb857ce3e63a218380d6d00e359fd

data/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 3.1.0
+
+### Changed
+
+- Transaction time now ends when the COMMIT or ROLLBACK statement completes rather than before it is sent, so it includes the commit itself. Time spent in after commit and after rollback callbacks is not included since those run after the database transaction is over.
+- The counter is now stored in `ActiveSupport::IsolatedExecutionState` when available (Rails 7+) so that query counting follows the application's configured thread or fiber isolation level. On Rails 6.x the counter remains fiber-local.
+
+### Fixed
+
+- A transaction whose COMMIT statement fails (e.g. a deadlock or serialization failure detected at commit time) is now counted as a rollback. Previously it was recorded as a successful commit and the rollback count was not incremented.
+- `ActiveRecordQueryCounter.last_transaction_end_time` now returns the latest transaction end time when transactions on multiple connections overlap. Previously it returned the end time of the transaction that started last.
+- Cached queries for ignored statements (`SCHEMA`, `EXPLAIN`) are no longer counted in the cached query count.
+- Setting up the query cache subscription in `ActiveRecordQueryCounter.enable!` is now thread safe, so concurrent calls can no longer create duplicate subscriptions that would double count cached queries.
+
 ## 3.0.0
 
 ### Changed

data/VERSION

@@ -1 +1 @@
-3.0.0
+3.1.0

data/lib/active_record_query_counter/connection_adapter_extension.rb

@@ -52,13 +52,13 @@ module ActiveRecordQueryCounter
     end
 
     module ExecQuery
-      def exec_query(sql, name = nil, binds = [], *args, **kwargs)
+      def exec_query(sql, name = nil, binds = [], ...)
         ConnectionAdapterExtension.measure_query(sql, name, binds) { super }
       end
     end
 
     module InternalExecQuery
-      def internal_exec_query(sql, name = nil, binds = [], *args, **kwargs)
+      def internal_exec_query(sql, name = nil, binds = [], ...)
         ConnectionAdapterExtension.measure_query(sql, name, binds) { super }
       end
     end

data/lib/active_record_query_counter/transaction_extension.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ActiveRecordQueryCounter
+  # Extension to ActiveRecord::ConnectionAdapters::RealTransaction to count transactions.
+  # Real transactions are always the outermost database transaction; savepoint transactions
+  # nested inside them are considered part of the transaction and are not counted separately.
+  module TransactionExtension
+    class << self
+      def inject(transaction_class)
+        unless transaction_class.include?(self)
+          transaction_class.prepend(self)
+        end
+      end
+    end
+
+    def initialize(...)
+      super
+      @active_record_query_counter_start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def commit(...)
+      # The transaction is only recorded after the COMMIT succeeds. If it raises, the start
+      # time is left in place so the rollback that Rails performs next is counted as a
+      # rollback rather than a successful commit. Recording here rather than in the
+      # transaction manager keeps time spent in after commit callbacks (which run after this
+      # method returns) out of the transaction time.
+      retval = super
+      active_record_query_counter_record_transaction
+      retval
+    end
+
+    def rollback(...)
+      super
+    ensure
+      # Recorded even if the ROLLBACK itself raises (e.g. the connection died) since the
+      # transaction is over either way.
+      active_record_query_counter_record_transaction(rollback: true)
+    end
+
+    private
+
+    def active_record_query_counter_record_transaction(rollback: false)
+      start_time = @active_record_query_counter_start_time
+      return unless start_time
+
+      @active_record_query_counter_start_time = nil
+      end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      ActiveRecordQueryCounter.add_transaction(start_time, end_time)
+      ActiveRecordQueryCounter.increment_rollbacks if rollback
+    end
+  end
+end

data/lib/active_record_query_counter.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+require "securerandom"
+
 require_relative "active_record_query_counter/connection_adapter_extension"
 require_relative "active_record_query_counter/counter"
 require_relative "active_record_query_counter/thresholds"
 require_relative "active_record_query_counter/transaction_info"
-require_relative "active_record_query_counter/transaction_manager_extension"
+require_relative "active_record_query_counter/transaction_extension"
 
 # Everything you need to count ActiveRecord queries and row counts within a block.
 #
@@ -16,13 +18,17 @@ require_relative "active_record_query_counter/transaction_manager_extension"
 #    puts ActiveRecordQueryCounter.row_count
 #  end
 module ActiveRecordQueryCounter
+  VERSION = File.read(File.join(__dir__, "..", "VERSION")).strip
+
   autoload :RackMiddleware, "active_record_query_counter/rack_middleware"
   autoload :SidekiqMiddleware, "active_record_query_counter/sidekiq_middleware"
-  autoload :VERSION, "active_record_query_counter/version"
 
   IGNORED_STATEMENTS = %w[SCHEMA EXPLAIN].freeze
   private_constant :IGNORED_STATEMENTS
 
+  @lock = Mutex.new
+  @default_thresholds = Thresholds.new
+
   class << self
     # Enable query counting within a block.
     #
@@ -37,8 +43,8 @@ module ActiveRecordQueryCounter
 
         transaction_count = counter.transaction_count
         if transaction_count > 0
-          transaction_threshold = (counter.thresholds.transaction_count || -1)
-          if transaction_threshold >= 0 && transaction_count >= transaction_threshold
+          transaction_threshold = counter.thresholds.transaction_count || -1
+          if transaction_threshold.between?(0, transaction_count)
             send_notification("transaction_count", counter.first_transaction_start_time, counter.last_transaction_end_time, transactions: counter.transactions)
           end
         end
@@ -98,15 +104,15 @@ module ActiveRecordQueryCounter
       notification_end_time = start_time + query_time
 
       trace = nil
-      query_time_threshold = (counter.thresholds.query_time || -1)
-      if query_time_threshold >= 0 && query_time >= query_time_threshold
+      query_time_threshold = counter.thresholds.query_time || -1
+      if query_time_threshold.between?(0, query_time)
         trace = backtrace
         payload = notification_payload(sql: sql, binds: binds, row_count: row_count, trace: trace, elapsed_time: elapsed_time, gc_time: gc_time, cpu_time: cpu_time)
         send_notification("query_time", start_time, notification_end_time, **payload)
       end
 
-      row_count_threshold = (counter.thresholds.row_count || -1)
-      if row_count_threshold >= 0 && row_count >= row_count_threshold
+      row_count_threshold = counter.thresholds.row_count || -1
+      if row_count_threshold.between?(0, row_count)
         trace ||= backtrace
         payload = notification_payload(sql: sql, binds: binds, row_count: row_count, trace: trace, elapsed_time: elapsed_time, gc_time: gc_time, cpu_time: cpu_time)
         send_notification("row_count", start_time, notification_end_time, **payload)
@@ -126,8 +132,8 @@ module ActiveRecordQueryCounter
       trace = backtrace
       counter.add_transaction(trace: trace, start_time: start_time, end_time: end_time)
 
-      transaction_time_threshold = (counter.thresholds.transaction_time || -1)
-      if transaction_time_threshold >= 0 && end_time - start_time >= transaction_time_threshold
+      transaction_time_threshold = counter.thresholds.transaction_time || -1
+      if transaction_time_threshold.between?(0, end_time - start_time)
         send_notification("transaction_time", start_time, end_time, trace: backtrace)
       end
     end
@@ -213,7 +219,7 @@ module ActiveRecordQueryCounter
     # @return [Float, nil] the monotonic time when the last transaction ended,
     def last_transaction_end_time
       counter = current_counter
-      counter.transactions.last&.end_time if counter.is_a?(Counter)
+      counter.last_transaction_end_time if counter.is_a?(Counter)
     end
 
     # Return an array of transaction information for any transactions that have been counted
@@ -259,9 +265,7 @@ module ActiveRecordQueryCounter
     # thresholds are used as the default values.
     #
     # @return [ActiveRecordQueryCounter::Thresholds]
-    def default_thresholds
-      @default_thresholds ||= Thresholds.new
-    end
+    attr_reader :default_thresholds
 
     # Get the current local notification thresholds. These thresholds are only used within
     # the current `count_queries` block.
@@ -276,25 +280,39 @@ module ActiveRecordQueryCounter
     def enable!(connection_class)
       ActiveSupport.on_load(:active_record) do
         ConnectionAdapterExtension.inject(connection_class)
-        TransactionManagerExtension.inject(ActiveRecord::ConnectionAdapters::TransactionManager)
+        TransactionExtension.inject(ActiveRecord::ConnectionAdapters::RealTransaction)
       end
 
-      @cache_subscription ||= ActiveSupport::Notifications.subscribe("sql.active_record") do |_name, _start_time, _end_time, _id, payload|
-        if payload[:cached]
-          counter = current_counter
-          counter.cached_query_count += 1 if counter
+      @lock.synchronize do
+        @cache_subscription ||= ActiveSupport::Notifications.subscribe("sql.active_record") do |_name, _start_time, _end_time, _id, payload|
+          if payload[:cached] && !IGNORED_STATEMENTS.include?(payload[:name])
+            counter = current_counter
+            counter.cached_query_count += 1 if counter.is_a?(Counter)
+          end
         end
       end
     end
 
     private
 
+    # The counter is stored in ActiveSupport::IsolatedExecutionState when available so that
+    # it follows the application's configured isolation level (thread or fiber). The fallback
+    # for ActiveSupport 6.x uses Thread.current, which is fiber-local, so on those versions
+    # queries executed in a fiber spawned inside the block are not counted.
     def current_counter
-      Thread.current[:active_record_query_counter]
+      if defined?(ActiveSupport::IsolatedExecutionState)
+        ActiveSupport::IsolatedExecutionState[:active_record_query_counter]
+      else
+        Thread.current[:active_record_query_counter]
+      end
     end
 
     def current_counter=(counter)
-      Thread.current[:active_record_query_counter] = counter
+      if defined?(ActiveSupport::IsolatedExecutionState)
+        ActiveSupport::IsolatedExecutionState[:active_record_query_counter] = counter
+      else
+        Thread.current[:active_record_query_counter] = counter
+      end
     end
 
     def send_notification(name, start_time, end_time, payload = {})

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record_query_counter
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Brian Durand
@@ -54,9 +54,8 @@ files:
 - lib/active_record_query_counter/rack_middleware.rb
 - lib/active_record_query_counter/sidekiq_middleware.rb
 - lib/active_record_query_counter/thresholds.rb
+- lib/active_record_query_counter/transaction_extension.rb
 - lib/active_record_query_counter/transaction_info.rb
-- lib/active_record_query_counter/transaction_manager_extension.rb
-- lib/active_record_query_counter/version.rb
 homepage: https://github.com/bdurand/active_record_query_counter
 licenses:
 - MIT
@@ -78,7 +77,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Provides detailed insights into how your code interacts with the database
   by hooking into ActiveRecord.

data/lib/active_record_query_counter/transaction_manager_extension.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecordQueryCounter
-  # Extension to ActiveRecord::ConnectionAdapters::TransactionManager to count transactions.
-  module TransactionManagerExtension
-    class << self
-      def inject(transaction_manager_class)
-        unless transaction_manager_class.include?(self)
-          transaction_manager_class.prepend(self)
-        end
-      end
-    end
-
-    def begin_transaction(*args, **kwargs)
-      if open_transactions == 0
-        @active_record_query_counter_transaction_start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-      super
-    end
-
-    def commit_transaction(*args)
-      if @active_record_query_counter_transaction_start_time && open_transactions == 1
-        end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        ActiveRecordQueryCounter.add_transaction(@active_record_query_counter_transaction_start_time, end_time)
-        @active_record_query_counter_transaction_start_time = nil
-      end
-      super
-    end
-
-    def rollback_transaction(*args)
-      if @active_record_query_counter_transaction_start_time && open_transactions == 1
-        end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        ActiveRecordQueryCounter.add_transaction(@active_record_query_counter_transaction_start_time, end_time)
-        ActiveRecordQueryCounter.increment_rollbacks
-        @active_record_query_counter_transaction_start_time = nil
-      end
-      super
-    end
-  end
-end

data/lib/active_record_query_counter/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecordQueryCounter
-  VERSION = File.read(File.join(__dir__, "..", "..", "VERSION")).strip
-end