active_record_query_counter 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00cf8b2bba420e0b37944a53f4be128aeac846d6e387b15b03c3393f3a0030c2
-  data.tar.gz: 10c05613e25513f1afab756f9cdd1133a19f7b54e34ca811b7f3ba5ad982ff0e
+  metadata.gz: 9b460515835154824cb80fec7db1e62dc4f4f983f8779fc1b80bec3c728646a4
+  data.tar.gz: 3d26302dd73d2ae010f4732ca4711a7dd1daa4ca0cca55e5ccd50349e89b282c
 SHA512:
-  metadata.gz: 4294aac8c3b0b55197ba1d069cc0a57f269ad772c23480b928fcf3f0a01b7c4f806f4969bf32f2d229b8dea65bc976d18cc864f923ec468dbbb43fc2fbe20bdd
-  data.tar.gz: ffddf3b2d87b74a2ad184d0ec55c4b371cda418c262aa2d0889cf40916579f5bff575ef0e631a39764edd58f7d321b71fa1b993dda6c3ff0c9f1ef060ca02769
+  metadata.gz: d1af45ed8c0659df4fcbf665621576b07380565a1289458e868b7cb33825c2d055e7b489eb1e490c31a566157a01f328eedd2771f9f3f5bffdece2b357445a01
+  data.tar.gz: ba21e07f668e1c3f97c61ce6f48fd10ef2d019afdd7d9d579e3487c710d58e8b44a9b1c5042572bc74be55a907c506d6385947dbe85a10b14b57e2b7b94037b7

data/CHANGELOG.md

@@ -4,6 +4,18 @@ 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).
 
+## 2.3.0
+
+### Added
+
+- Added count of rollbacks from transactions
+
+## 2.2.1
+
+### Changed
+
+- Classes not required to run the gem are now lazy loaded.
+
 ## 2.2.0
 
 ### Added

data/README.md

@@ -1,37 +1,47 @@
 # ActiveRecordQueryCounter
 
-![Continuous Integration](https://github.com/bdurand/active_record_query_counter/workflows/Continuous%20Integration/badge.svg)
+[![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)
 [![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
@@ -41,18 +51,25 @@ 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.
+### 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
@@ -60,13 +77,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
@@ -74,43 +93,46 @@ 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.
 
-#### active_record_query_counter.row_count notification
+##### 2. active_record_query_counter.row_count notification
 
-This notification is triggered when a query returns more rows than the `row_count` threshold. The payload contains the following keys:
+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.
 
-#### 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(
@@ -121,7 +143,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
@@ -134,7 +156,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
@@ -150,7 +173,6 @@ class MyWorker
       }
     }
   )
-  # You can disable thresholds for the worker by setting `thresholds: false`.
 
   def perform
     do_something
@@ -158,7 +180,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: {
@@ -169,7 +195,7 @@ Rails.application.config.middleware.use(ActiveRecordQueryCounter::RackMiddleware
 })
 ```
 
-#### Example Notification Subscriptions
+#### Example: Subscribing to Notifications
 
 ```ruby
 ActiveRecordQueryCounter.default_thresholds.query_time = 1.0
@@ -204,6 +230,24 @@ ActiveSupport::Notifications.subscribe('active_record_query_counter.transaction_
 end
 ```
 
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_record_query_counter'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install active_record_query_counter
+```
+
 ## Contributing
 
 Open a pull request on GitHub.

data/VERSION

@@ -1 +1 @@
-2.2.0
+2.3.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[

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/thresholds.rb

@@ -34,7 +34,7 @@ module ActiveRecordQueryCounter
       values.each do |key, value|
         setter = "#{key}="
         if respond_to?(setter)
-          public_send("#{key}=", value)
+          public_send(:"#{key}=", value)
         else
           raise ArgumentError, "Unknown threshold: #{key}"
         end

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

@@ -2,12 +2,9 @@
 
 require_relative "active_record_query_counter/connection_adapter_extension"
 require_relative "active_record_query_counter/counter"
-require_relative "active_record_query_counter/rack_middleware"
-require_relative "active_record_query_counter/sidekiq_middleware"
 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/version"
 
 # Everything you need to count ActiveRecord queries and row counts within a block.
 #
@@ -19,6 +16,10 @@ require_relative "active_record_query_counter/version"
 #    puts ActiveRecordQueryCounter.row_count
 #  end
 module ActiveRecordQueryCounter
+  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
 
@@ -112,6 +113,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.
     #
@@ -194,6 +206,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.
@@ -209,7 +230,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
@@ -233,8 +255,10 @@ module ActiveRecordQueryCounter
     # @param connection_class [Class] the connection adapter class to extend
     # @return [void]
     def enable!(connection_class)
-      ConnectionAdapterExtension.inject(connection_class)
-      TransactionManagerExtension.inject(ActiveRecord::ConnectionAdapters::TransactionManager)
+      ActiveSupport.on_load(:active_record) do
+        ConnectionAdapterExtension.inject(connection_class)
+        TransactionManagerExtension.inject(ActiveRecord::ConnectionAdapters::TransactionManager)
+      end
 
       @cache_subscription ||= ActiveSupport::Notifications.subscribe("sql.active_record") do |_name, _start_time, _end_time, _id, payload|
         if payload[:cached]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_record_query_counter
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Brian Durand
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-03 00:00:00.000000000 Z
+date: 2024-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -46,7 +46,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
-- MIT_LICENSE
+- MIT_LICENSE.txt
 - README.md
 - VERSION
 - active_record_query_counter.gemspec
@@ -62,7 +62,10 @@ files:
 homepage: https://github.com/bdurand/active_record_query_counter
 licenses:
 - MIT
-metadata: {}
+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
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -78,8 +81,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.20
+rubygems_version: 3.4.10
 signing_key:
 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: []