active_record_query_counter 2.2.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 752c1c799ab4ee023a24f4f8c3550da35831fdcebf39e71c9bb945bbf4ca7ff9
-  data.tar.gz: ecd642c76f010996f40d0a6d791db96c06515137b2e1393d5655c1feae314b23
+  metadata.gz: 89a919244edbce9bf36bdaa232078b04470f1bacc952469eab4a4fffc2416e08
+  data.tar.gz: 97a66d47fda85ad15b832da3e390f8cc035a374983c64f53e4d673094b54d8b9
 SHA512:
-  metadata.gz: b4a88b4283290565e8352d35f6c0b5483515dbcacbd17fb223fc90398b94d50ac2984519f84c6a188a576468cb1f9ea373edfcc6855301e78522676558511e9d
-  data.tar.gz: ff360b2f495c953f79668a27520722c425c94d9cafe6607dcae40d25b65d10dd8f38f7b0d478771495927a5229ecf1e6948328b6adb87be5d6d186c77727d4f2
+  metadata.gz: c5c657cf312deb55e21063b5d08f824cd762e42050704b06fc0610e00f938aacac8fc37050c60d293452521841ca614430cb50cd3bf10d3bca794df9d0dee6d0
+  data.tar.gz: d81cb599eea68c911fad417a902848f1b1f2d0f29f4d095b70d5af8ef2f6366dac0e2b2de0fe534ed51fcbffb3d696147edfc53e64b549862a4dfe78a156a54d

data/CHANGELOG.md

@@ -4,6 +4,26 @@ 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.0.0
+
+### Changed
+
+- Query time now excludes GC pause time and Ruby thread CPU time so that it more closely reflects the time actually spent waiting on the database. This is what is now reported as the event duration in the `query_time` and `row_count` notifications.
+
+### Added
+
+- Added `:elapsed_time` (the raw wall clock time), `:gc_time`, and `:cpu_time` (all in milliseconds) to the `query_time` and `row_count` notification payloads.
+
+### Removed
+
+- Dropped support for Ruby versions older than 3.1 (required for `GC.total_time`).
+
+## 2.3.0
+
+### Added
+
+- Added count of rollbacks from transactions
+
 ## 2.2.1
 
 ### Changed

data/README.md

@@ -1,39 +1,47 @@
 # ActiveRecordQueryCounter
 
 [![Continuous Integration](https://github.com/bdurand/active_record_query_counter/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/bdurand/active_record_query_counter/actions/workflows/continuous_integration.yml)
-[![Regression Test](https://github.com/bdurand/active_record_query_counter/actions/workflows/regression_test.yml/badge.svg)](https://github.com/bdurand/active_record_query_counter/actions/workflows/regression_test.yml)
 [![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
 [![Gem Version](https://badge.fury.io/rb/active_record_query_counter.svg)](https://badge.fury.io/rb/active_record_query_counter)
 
-This gem injects itself into ActiveRecord to give you insight into how your code is using the database.
+**ActiveRecordQueryCounter** is a ruby gem that provides detailed insights into how your code interacts with the database by hooking into ActiveRecord.
 
-Within a block of code, it will count:
+It measures database usage within a block of code, including:
 
-- the number of queries
-- the number of rows returned
-- the amount of time spent on queries
-- the number of transactions used
-- the amount of time spent inside transactions
+- The number of queries executed
+- The number of rows returned
+- The total time spent on queries
+- The number of transactions used
+- The total time spent inside transactions
+- The number of transactions that were rolled back
 
-The intended use is to gather instrumentation stats for finding hot spots in your code that produce a lot of queries or slow queries or queries that return a lot of rows. It can also be used to find code that is not using transactions when making multiple updates to the database.
+This gem is designed to help you:
+
+- Identify "hot spots" in your code that generate excessive or slow queries.
+- Spot queries returning unexpectedly large result sets.
+- Detect areas where transactions are underutilized, especially when performing multiple database updates.
 
 ## Usage
 
-The behavior must be enabled on your database connection adapter from within an initializer.
+### Enabling The Gem
+
+To use **ActiveRecordQueryCounter**, you first need to enable it on your database connection adapter. Add the following to an initializer:
 
-Postgres:
+For **PostgreSQL**:
 
 ```ruby
 ActiveRecordQueryCounter.enable!(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
 ```
 
-MySQL:
+For **MySQL**:
 
 ```ruby
 ActiveRecordQueryCounter.enable!(ActiveRecord::ConnectionAdapters::Mysql2Adapter)
 ```
 
-Next you must specify the blocks where you want to count queries.
+### Counting Queries
+
+To measure database activity, wrap the code you want to monitor inside a `count_queries` block:
 
 ```ruby
 ActiveRecordQueryCounter.count_queries do
@@ -43,18 +51,34 @@ ActiveRecordQueryCounter.count_queries do
   puts "Query Time: #{ActiveRecordQueryCounter.query_time}"
   puts "Transactions: #{ActiveRecordQueryCounter.transaction_count}"
   puts "Transaction Time: #{ActiveRecordQueryCounter.transaction_time}"
+  puts "Rollbacks: #{ActiveRecordQueryCounter.rollback_count}"
 end
 ```
 
-This gem includes middleware for both Rack and Sidekiq that will enable query counting on web requests and in workers. If you are using Rails with Sidekiq, you can enable both with an initializer.
+### Query Time
+
+The query time (`ActiveRecordQueryCounter.query_time` and the duration reported by the notifications) is **not** the raw wall clock time a query took. The wall clock time includes time the thread was not actually waiting on the database, such as GC pauses (which can be triggered by other threads and stop the world) and the Ruby CPU work of building the result objects. On a busy, multi-threaded server these can add up to seconds, making a trivial query look pathologically slow.
+
+To report the time actually spent waiting on the database as closely as possible, the GC time and thread CPU time that elapsed while the query ran are subtracted from the wall clock time. The raw wall clock time is still available as `:elapsed_time` in the notification payloads.
+
+> [!NOTE]
+> Measuring GC time requires Ruby's GC total time measurement, which is enabled by default (`GC.measure_total_time`). Thread CPU time is measured via `Process::CLOCK_THREAD_CPUTIME_ID`; on platforms that do not provide it, CPU time is treated as zero.
+
+### Middleware Integration
+
+For **Rails** and **Sidekiq**, middleware is included to enable query counting in web requests and workers.
+
+Add the following to an initializer:
 
 ```ruby
 ActiveSupport.on_load(:active_record) do
   ActiveRecordQueryCounter.enable!(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
 end
 
+# Enable Rack Middleware
 Rails.application.config.middleware.use(ActiveRecordQueryCounter::RackMiddleware)
 
+# Enable Sidekiq Middleware
 Sidekiq.configure_server do |config|
   config.server_middleware do |chain|
     chain.add ActiveRecordQueryCounter::SidekiqMiddleware
@@ -62,13 +86,15 @@ Sidekiq.configure_server do |config|
 end
 ```
 
-If you want to disable query counting within a block of code, you can use the `disable` method.
+### Disabling Query Counting
+
+You can temporarily disable query counting within a block using `disable`:
 
 ```ruby
 ActiveRecordQueryCounter.count_queries do
   do_something
   ActiveRecordQueryCounter.disable do
-    # Queries will not be counted in this block.
+    # Queries in this block will not be counted.
     do_something_else
   end
 end
@@ -76,43 +102,54 @@ end
 
 ### Notifications
 
-You can also subscribe to ActiveSupport notifications to get notified when query thresholds are exceeded.
+**ActiveRecordQueryCounter** supports ActiveSupport notifications when certain query thresholds are exceeded.
+
+#### Available Notifications
+
+##### 1. active_record_query_counter.query_time notification
 
-#### active_record_query_counter.query_time notification
+Triggered when a query exceeds the query_time threshold with the payload:
 
-This notification is triggered when a query takes longer than the `query_time` threshold. The payload contains the following keys:
 
 - `:sql` - The SQL statement that was executed.
 - `:binds` - The bind parameters that were used.
 - `:row_count` - The number of rows returned.
 - `:trace` - The stack trace of where the query was executed.
+- `:elapsed_time` - The raw wall clock time the query took (in milliseconds).
+- `:gc_time` - The GC time that elapsed while the query ran (in milliseconds).
+- `:cpu_time` - The thread CPU time spent while the query ran (in milliseconds).
 
-#### active_record_query_counter.row_count notification
+The duration of the notification event is the query time: the wall clock time with the GC time and CPU time subtracted out (see [Query Time](#query-time)). The raw wall clock time is still available as `:elapsed_time`.
 
-This notification is triggered when a query returns more rows than the `row_count` threshold. The payload contains the following keys:
+##### 2. active_record_query_counter.row_count notification
+
+Triggered when a query exceeds the row_count threshold with the payload:
 
 - `:sql` - The SQL statement that was executed.
 - `:binds` - The bind parameters that were used.
 - `:row_count` - The number of rows returned.
 - `:trace` - The stack trace of where the query was executed.
+- `:elapsed_time` - The raw wall clock time the query took (in milliseconds).
+- `:gc_time` - The GC time that elapsed while the query ran (in milliseconds).
+- `:cpu_time` - The thread CPU time spent while the query ran (in milliseconds).
 
-#### active_record_query_counter.transaction_time notification
+##### 3. active_record_query_counter.transaction_time notification
 
-This notification is triggered when a transaction takes longer than the `transaction_time` threshold. The payload contains the following keys:
+Triggered when a transaction exceeds the transaction_time threshold with the payload:
 
 - `:trace` - The stack trace of where the transaction was completed.
 
-#### active_record_query_counter.transaction_count notification
+##### 4. active_record_query_counter.transaction_count notification
 
-This notification is triggered when a transaction takes longer than the `transaction_count` threshold. The payload contains the following keys:
+Triggered when transactions exceed the transaction_count threshold with the payload:
 
 - `:transactions` - An array of `ActiveRecordQueryCounter::TransactionInfo` objects.
 
 The duration of the notification event is the time between when the first transaction was started and the last transaction was completed.
 
-#### Thresholds
+#### Setting Thresholds
 
-The thresholds for triggering notifications can be set globally in an initializer:
+Thresholds can be configured **globally** in an initializer:
 
 ```ruby
 ActiveRecordQueryCounter.default_thresholds.set(
@@ -123,7 +160,7 @@ ActiveRecordQueryCounter.default_thresholds.set(
 )
 ```
 
-They can be set locally inside a `count_queries` block with the `thresholds` object. Local thresholds will override the global thresholds only inside the block and will not change any global state.
+Or locally within a block:
 
 ```ruby
 ActiveRecordQueryCounter.count_queries do
@@ -136,7 +173,8 @@ ActiveRecordQueryCounter.count_queries do
 end
 ```
 
-You can pass thresholds to individual Sidekiq workers via the `sidekiq_options` on the worker.
+#### Sidekiq Worker Thresholds
+Thresholds for individual Sidekiq workers can be set using `sidekiq_options`:
 
 ```ruby
 class MyWorker
@@ -152,7 +190,6 @@ class MyWorker
       }
     }
   )
-  # You can disable thresholds for the worker by setting `thresholds: false`.
 
   def perform
     do_something
@@ -160,7 +197,11 @@ class MyWorker
 end
 ```
 
-You can set separate thresholds on the Rack middleware when you install it.
+To disable thresholds for a worker, set `thresholds: false`.
+
+#### Rack Middleware Thresholds
+
+You can configure separate thresholds for the Rack middleware:
 
 ```ruby
 Rails.application.config.middleware.use(ActiveRecordQueryCounter::RackMiddleware, thresholds: {
@@ -171,7 +212,7 @@ Rails.application.config.middleware.use(ActiveRecordQueryCounter::RackMiddleware
 })
 ```
 
-#### Example Notification Subscriptions
+#### Example: Subscribing to Notifications
 
 ```ruby
 ActiveRecordQueryCounter.default_thresholds.query_time = 1.0

data/VERSION

@@ -1 +1 @@
-2.2.1
+3.0.0

data/active_record_query_counter.gemspec

@@ -4,10 +4,16 @@ Gem::Specification.new do |spec|
   spec.authors = ["Brian Durand"]
   spec.email = ["bbdurand@gmail.com"]
 
-  spec.summary = "Count total number of ActiveRecord queries and row counts inside a block"
+  spec.summary = "Provides detailed insights into how your code interacts with the database by hooking into ActiveRecord."
   spec.homepage = "https://github.com/bdurand/active_record_query_counter"
   spec.license = "MIT"
 
+  spec.metadata = {
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => spec.homepage,
+    "changelog_uri" => "#{spec.homepage}/blob/main/CHANGELOG.md"
+  }
+
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   ignore_files = %w[
@@ -28,9 +34,9 @@ Gem::Specification.new do |spec|
 
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activerecord", ">= 5.1"
+  spec.add_dependency "activerecord", ">= 6.0"
 
   spec.add_development_dependency "bundler"
 
-  spec.required_ruby_version = ">= 2.5"
+  spec.required_ruby_version = ">= 3.1"
 end

data/lib/active_record_query_counter/connection_adapter_extension.rb

@@ -3,37 +3,63 @@
 module ActiveRecordQueryCounter
   # Module to prepend to the connection adapter to inject the counting behavior.
   module ConnectionAdapterExtension
+    # Clock used to measure the CPU time consumed by the current thread while a query runs.
+    # It is not available on every platform (e.g. Windows), in which case CPU time is not
+    # measured and is treated as zero.
+    CPU_CLOCK_ID = (Process::CLOCK_THREAD_CPUTIME_ID if defined?(Process::CLOCK_THREAD_CPUTIME_ID))
+
     class << self
       def inject(connection_class)
         # Rails 7.1+ uses internal_exec_query instead of exec_query.
-        mod = (connection_class.instance_methods.include?(:internal_exec_query) ? InternalExecQuery : ExecQuery)
+        mod = (connection_class.method_defined?(:internal_exec_query) ? InternalExecQuery : ExecQuery)
         unless connection_class.include?(mod)
           connection_class.prepend(mod)
         end
       end
-    end
 
-    module ExecQuery
-      def exec_query(sql, name = nil, binds = [], *args, **kwargs)
+      # Measure a query by wrapping its execution. In addition to the wall clock time, the GC
+      # time and thread CPU time spent while the query runs are captured so that the time
+      # actually spent waiting on the database can be isolated from time lost to garbage
+      # collection and Ruby VM work.
+      #
+      # @param sql [String] the SQL statement being executed
+      # @param name [String, nil] the name of the query
+      # @param binds [Array] the bind parameters
+      # @yield executes the query and returns its result
+      # @return [Object] the result of the query
+      def measure_query(sql, name, binds)
+        gc_start = GC.total_time
+        cpu_start = current_cpu_time
         start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        result = super
+        result = yield
         if result.is_a?(ActiveRecord::Result)
           end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          ActiveRecordQueryCounter.add_query(sql, name, binds, result.length, start_time, end_time)
+          cpu_time = current_cpu_time - cpu_start
+          gc_time = (GC.total_time - gc_start) / 1_000_000_000.0
+          ActiveRecordQueryCounter.add_query(sql, name, binds, result.length, start_time, end_time, gc_time, cpu_time)
         end
         result
       end
+
+      private
+
+      # The current thread CPU time in seconds, or 0.0 when the platform does not support it.
+      #
+      # @return [Float]
+      def current_cpu_time
+        CPU_CLOCK_ID ? Process.clock_gettime(CPU_CLOCK_ID) : 0.0
+      end
+    end
+
+    module ExecQuery
+      def exec_query(sql, name = nil, binds = [], *args, **kwargs)
+        ConnectionAdapterExtension.measure_query(sql, name, binds) { super }
+      end
     end
 
     module InternalExecQuery
       def internal_exec_query(sql, name = nil, binds = [], *args, **kwargs)
-        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        result = super
-        if result.is_a?(ActiveRecord::Result)
-          end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          ActiveRecordQueryCounter.add_query(sql, name, binds, result.length, start_time, end_time)
-        end
-        result
+        ConnectionAdapterExtension.measure_query(sql, name, binds) { super }
       end
     end
   end

data/lib/active_record_query_counter/counter.rb

@@ -3,7 +3,7 @@
 module ActiveRecordQueryCounter
   # Data structure for storing query information encountered within a block.
   class Counter
-    attr_accessor :query_count, :row_count, :query_time, :cached_query_count
+    attr_accessor :query_count, :row_count, :query_time, :cached_query_count, :rollback_count
     attr_reader :thresholds
 
     def initialize
@@ -13,6 +13,7 @@ module ActiveRecordQueryCounter
       @cached_query_count = 0
       @transactions_hash = {}
       @thresholds = ActiveRecordQueryCounter.default_thresholds.dup
+      @rollback_count = 0
     end
 
     # Return the percentage of queries that used the query cache instead of going to the database.

data/lib/active_record_query_counter/transaction_manager_extension.rb

@@ -31,6 +31,7 @@ module ActiveRecordQueryCounter
       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

data/lib/active_record_query_counter.rb

@@ -65,32 +65,51 @@ module ActiveRecordQueryCounter
 
     # Increment the query counters.
     #
+    # The reported query time is the wall clock time spent executing the query with the GC
+    # time and Ruby thread CPU time subtracted out so that it reflects the time actually
+    # spent waiting on the database as closely as possible (see {.database_query_time}). This
+    # query time, rather than the raw wall clock time, is what is accumulated, compared against
+    # the threshold, and used as the duration of the emitted notification.
+    #
+    # @param sql [String] the SQL statement that was executed
+    # @param name [String, nil] the name of the query
+    # @param binds [Array] the bind parameters
     # @param row_count [Integer] the number of rows returned by the query
-    # @param elapsed_time [Float] the time spent executing the query
+    # @param start_time [Float] the monotonic time when the query started
+    # @param end_time [Float] the monotonic time when the query ended
+    # @param gc_time [Float] the GC time in seconds that elapsed while the query ran
+    # @param cpu_time [Float] the thread CPU time in seconds spent while the query ran
     # @return [void]
     # @api private
-    def add_query(sql, name, binds, row_count, start_time, end_time)
+    def add_query(sql, name, binds, row_count, start_time, end_time, gc_time, cpu_time)
       return if IGNORED_STATEMENTS.include?(name)
 
       counter = current_counter
       return unless counter.is_a?(Counter)
 
       elapsed_time = end_time - start_time
+      query_time = database_query_time(elapsed_time, gc_time, cpu_time)
       counter.query_count += 1
       counter.row_count += row_count
-      counter.query_time += elapsed_time
+      counter.query_time += query_time
+
+      # The notification duration is the database query time, so the event ends that long after
+      # it started rather than at the raw wall clock end time.
+      notification_end_time = start_time + query_time
 
       trace = nil
       query_time_threshold = (counter.thresholds.query_time || -1)
-      if query_time_threshold >= 0 && elapsed_time >= query_time_threshold
+      if query_time_threshold >= 0 && query_time >= query_time_threshold
         trace = backtrace
-        send_notification("query_time", start_time, end_time, sql: sql, binds: binds, row_count: row_count, trace: trace)
+        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
         trace ||= backtrace
-        send_notification("row_count", start_time, end_time, sql: sql, binds: binds, row_count: row_count, trace: trace)
+        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)
       end
     end
 
@@ -113,6 +132,17 @@ module ActiveRecordQueryCounter
       end
     end
 
+    # Return the number of rollbacks that have been counted within the current block.
+    # Returns nil if not inside a block where queries are being counted.
+    #
+    # @return [Integer, nil]
+    def increment_rollbacks
+      counter = current_counter
+      return unless counter.is_a?(Counter)
+
+      counter.rollback_count += 1
+    end
+
     # Return the number of queries that have been counted within the current block.
     # Returns nil if not inside a block where queries are being counted.
     #
@@ -195,6 +225,15 @@ module ActiveRecordQueryCounter
       counter.transactions if counter.is_a?(Counter)
     end
 
+    # Return the number of transactions that have rolled back within the current block.
+    # Returns nil if not inside a block where queries are being counted.
+    #
+    # @return [Integer, nil]
+    def rollback_count
+      counter = current_counter
+      counter.rollback_count if counter.is_a?(Counter)
+    end
+
     # Return the query info as a hash with keys :query_count, :row_count, :query_time
     # :transaction_count, and :transaction_type or nil if not inside a block where queries
     # are being counted.
@@ -210,7 +249,8 @@ module ActiveRecordQueryCounter
           cached_query_count: counter.cached_query_count,
           cache_hit_rate: counter.cache_hit_rate,
           transaction_count: counter.transaction_count,
-          transaction_time: counter.transaction_time
+          transaction_time: counter.transaction_time,
+          rollback_count: counter.rollback_count
         }
       end
     end
@@ -262,6 +302,42 @@ module ActiveRecordQueryCounter
       ActiveSupport::Notifications.publish("active_record_query_counter.#{name}", start_time, end_time, id, payload)
     end
 
+    def notification_payload(sql:, binds:, row_count:, trace:, elapsed_time:, gc_time:, cpu_time:)
+      {
+        sql: sql,
+        binds: binds,
+        row_count: row_count,
+        trace: trace,
+        elapsed_time: (elapsed_time * 1000.0).round(6),
+        gc_time: (gc_time * 1000.0).round(6),
+        cpu_time: (cpu_time * 1000.0).round(6)
+      }
+    end
+
+    # Estimate the time spent waiting on the database by subtracting the GC time and thread CPU
+    # time from the wall clock time the query took.
+    #
+    # The GC time and CPU time normally measure distinct, non-overlapping intervals: a GC pause
+    # triggered by another thread happens while this thread is parked waiting on the database
+    # (off CPU, so it does not count as CPU time), while CPU time covers the Ruby work of
+    # building the result. They only overlap when the query's own thread triggers a GC, which
+    # runs on that thread and so counts as both GC time and CPU time. When that overlap is large
+    # enough to drive the result negative, only the larger of the two is subtracted so the shared
+    # interval is removed once. The result is clamped so it never exceeds the wall clock time and
+    # is never negative.
+    #
+    # @param elapsed_time [Float] the wall clock time the query took in seconds
+    # @param gc_time [Float] the GC time in seconds that elapsed while the query ran
+    # @param cpu_time [Float] the thread CPU time in seconds spent while the query ran
+    # @return [Float] the estimated database time in seconds
+    def database_query_time(elapsed_time, gc_time, cpu_time)
+      return 0.0 if elapsed_time <= 0.0
+
+      query_time = elapsed_time - (gc_time + cpu_time)
+      query_time = elapsed_time - [gc_time, cpu_time].max if query_time.negative?
+      query_time.clamp(0.0, elapsed_time)
+    end
+
     def backtrace
       caller.reject { |line| line.start_with?(__dir__) }
     end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: active_record_query_counter
 version: !ruby/object:Gem::Version
-  version: 2.2.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Brian Durand
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-03 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -38,7 +37,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description:
 email:
 - bbdurand@gmail.com
 executables: []
@@ -62,8 +60,10 @@ files:
 homepage: https://github.com/bdurand/active_record_query_counter
 licenses:
 - MIT
-metadata: {}
-post_install_message:
+metadata:
+  homepage_uri: https://github.com/bdurand/active_record_query_counter
+  source_code_uri: https://github.com/bdurand/active_record_query_counter
+  changelog_uri: https://github.com/bdurand/active_record_query_counter/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -71,15 +71,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.12
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
-summary: Count total number of ActiveRecord queries and row counts inside a block
+summary: Provides detailed insights into how your code interacts with the database
+  by hooking into ActiveRecord.
 test_files: []