active_record_query_counter 1.1.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29ed527d87037456aa27022d13ea436b462945329de3b343a9391da90db88f90
-  data.tar.gz: 22edd4498820f0452999cbffbad2532b534d791c8b41f0039599c0407bcc2279
+  metadata.gz: eb19f1f7e8a7678f3cdf3079b05e9aa26353b33b809c240943e0899f584dac6a
+  data.tar.gz: 7bcbce0b2d06c4f871074898651071f1400cd87c7ee8ee514837ee80caac6774
 SHA512:
-  metadata.gz: df174f4eb9e9b882c57fdae34456c36bff95581497cafcb628b57a42d06eefe3b784d7f7454367d36cb0d39726cfc141c0d808e9a14648fea898cc84603d651f
-  data.tar.gz: a0ba3580554d39fe487fbc2eb5a9d1a7db59ad0d964b6f4f17e3bc2bdd642c7b46728d9e7130d015f14486901b5db224c6af4c6039d9c127c33d97fecb3a18e8
+  metadata.gz: 80c468ec96c069bb4043a0e210d4fb4b1d82714d2aa0b69bd07ac9fd23bb04255ffcf4b175fcfa66b7aa0afd8434c211645e70f4fd8d05ad9c10faa4ee95c679
+  data.tar.gz: fb972d526b98c97f98230a29eb9412726746a58c3d4a05406ab9ccc046d6eb0ec5007fa8d52d26a40c9a966ad2af4c50c045c1d9257cd15ce90dd21c5dedbcfa

data/CHANGELOG.md

@@ -4,20 +4,40 @@ 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.0.0
+
+### Added
+
+- Added capability to send ActiveSupport notifications when query thresholds are exceeded.
+
+### Changed
+
+- Calculate elapsed time using monotonic time rather than wall clock time.
+- Schema queries to get the table structure and explain plan queries are no longer counted.
+- **Breaking change**: transaction information is now returned in an array of `ActiveRecordQueryCounter::TransactionInfo` objects.
+- **Breaking change**: internal API for tracking queries and transactions has changed
+
 ## 1.1.2
+
 ### Added
-* Ruby 3.0 compatibility
+
+- Ruby 3.0 compatibility
+
 ### Removed
-* Dropped support for ActiveRecord 4.2
+
+- Dropped support for ActiveRecord 4.2
 
 ## 1.1.1
 ### Added
-* Expose stack traces where transactions are being committed.
+
+- Expose stack traces where transactions are being committed.
 
 ## 1.1.0
 ### Added
-* Add number of transactions to statistics being tracked.
+
+- Add number of transactions to statistics being tracked.
 
 ## 1.0.0
 ### Added
-* Track stats about queries run by ActiveRecord within a block.
+
+- Track stats about queries run by ActiveRecord within a block.

data/README.md

@@ -1,13 +1,19 @@
 # ActiveRecordQueryCounter
 
 ![Continuous Integration](https://github.com/bdurand/active_record_query_counter/workflows/Continuous%20Integration/badge.svg)
-[![Maintainability](https://api.codeclimate.com/v1/badges/21094ecec0c151983bb1/maintainability)](https://codeclimate.com/github/bdurand/active_record_query_counter/maintainability)
-[![Test Coverage](https://api.codeclimate.com/v1/badges/21094ecec0c151983bb1/test_coverage)](https://codeclimate.com/github/bdurand/active_record_query_counter/test_coverage)
 [![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
 
-This gem injects itself into ActiveRecord to count the number of queries, the number of rows returned, the amount of time spent on queries, the number of transactions, and the amount of time spent inside transactions within a block.
+This gem injects itself into ActiveRecord to give you insight into how your code is using the database.
 
-The intended use is to gather instrumentation stats for finding hot spots in your code.
+Within a block of code, it will count:
+
+- 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 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.
 
 ## Usage
 
@@ -38,9 +44,7 @@ ActiveRecordQueryCounter.count_queries do
 end
 ```
 
-This gem includes middleware for both Rack and Sidekiq that will enable query counting.
-
-If you are using Rails with Sidekiq, you can enable both with an initializer.
+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.
 
 ```ruby
 ActiveSupport.on_load(:active_record) do
@@ -55,3 +59,145 @@ Sidekiq.configure_server do |config|
   end
 end
 ```
+
+### Notifications
+
+You can also subscribe to ActiveSupport notifications to get notified when query thresholds are exceeded.
+
+#### active_record_query_counter.query_time notification
+
+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
+
+This notification is triggered when a query returns more rows than the `row_count` 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.transaction_time notification
+
+This notification is triggered when a transaction takes longer than the `transaction_time` threshold. The payload contains the following keys:
+
+- `:trace` - The stack trace of where the transaction was completed.
+
+#### 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:
+
+- `: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
+
+The thresholds for triggering notifications can be set globally in an initializer:
+
+```ruby
+ActiveRecordQueryCounter.default_thresholds.set(
+  query_time: 2.0,
+  row_count: 1000,
+  transaction_time: 5.0,
+  transaction_count: 2
+)
+```
+
+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.
+
+```ruby
+ActiveRecordQueryCounter.count_queries do
+  ActiveRecordQueryCounter.thresholds.set(
+    query_time: 1.0,
+    row_count: 100,
+    transaction_time: 2.0,
+    transaction_count: 1
+  )
+end
+```
+
+You can pass thresholds to individual Sidekiq workers via the `sidekiq_options` on the worker.
+
+```ruby
+class MyWorker
+  include Sidekiq::Worker
+
+  sidekiq_options(
+    active_record_query_counter: {
+      thresholds: {
+        query_time: 1.0,
+        row_count: 100,
+        transaction_time: 2.0,
+        transaction_count: 1
+      }
+    }
+  )
+  # You can disable thresholds for the worker by setting `thresholds: false`.
+
+  def perform
+    do_something
+  end
+end
+```
+
+You can set separate thresholds on the Rack middleware when you install it.
+
+```ruby
+Rails.application.config.middleware.use(ActiveRecordQueryCounter::RackMiddleware, thresholds: {
+  query_time: 1.0,
+  row_count: 100,
+  transaction_time: 2.0,
+  transaction_count: 1
+})
+```
+
+#### Example Notification Subscriptions
+
+```ruby
+ActiveRecordQueryCounter.default_thresholds.query_time = 1.0
+ActiveRecordQueryCounter.default_thresholds.row_count = 1000
+ActiveRecordQueryCounter.default_thresholds.transaction_time = 2.0
+ActiveRecordQueryCounter.default_thresholds.transaction_count = 1
+
+ActiveSupport::Notifications.subscribe('active_record_query_counter.query_time') do |*args|
+  event = ActiveSupport::Notifications::Event.new(*args)
+  puts "Query time exceeded (#{event.duration}ms): #{event.payload[:sql]}"
+  puts event.payload[:trace].join("\n")
+end
+
+ActiveSupport::Notifications.subscribe('active_record_query_counter.row_count') do |*args|
+  event = ActiveSupport::Notifications::Event.new(*args)
+  puts "Row count exceeded (#{event.payload[:row_count]} rows): #{event.payload[:sql]}"
+  puts event.payload[:trace].join("\n")
+end
+
+ActiveSupport::Notifications.subscribe('active_record_query_counter.transaction_time') do |*args|
+  event = ActiveSupport::Notifications::Event.new(*args)
+  puts "Transaction time exceeded (#{event.duration}ms)"
+  puts event.payload[:trace].join("\n")
+end
+
+ActiveSupport::Notifications.subscribe('active_record_query_counter.transaction_count') do |*args|
+  event = ActiveSupport::Notifications::Event.new(*args)
+  puts "Transaction count exceeded (#{event.payload[:transactions].size} transactions in #{event.duration}ms)"
+  event.payload[:transactions].each do |info|
+    puts info.trace.join("\n")
+  end
+end
+```
+
+## Contributing
+
+Open a pull request on GitHub.
+
+Please use the [standardrb](https://github.com/testdouble/standard) syntax and lint your code with `standardrb --fix` before submitting.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/VERSION

@@ -1 +1 @@
-1.1.2
+2.0.0

data/active_record_query_counter.gemspec

@@ -11,12 +11,14 @@ Gem::Specification.new do |spec|
   # 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[
-    .gitignore
-    .travis.yml
+    .
     Appraisals
     Gemfile
     Gemfile.lock
     Rakefile
+    config.ru
+    assets/
+    bin/
     gemfiles/
     spec/
   ]
@@ -29,4 +31,6 @@ Gem::Specification.new do |spec|
   spec.add_dependency "activerecord", ">= 5.0"
 
   spec.add_development_dependency "bundler"
+
+  spec.required_ruby_version = ">= 2.5"
 end

data/lib/active_record_query_counter/connection_adapter_extension.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ActiveRecordQueryCounter
+  # Module to prepend to the connection adapter to inject the counting behavior.
+  module ConnectionAdapterExtension
+    def 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
+    end
+  end
+end

data/lib/active_record_query_counter/counter.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module ActiveRecordQueryCounter
+  # Data structure for storing query information encountered within a block.
+  class Counter
+    attr_accessor :query_count, :row_count, :query_time
+    attr_reader :thresholds
+
+    def initialize
+      @query_count = 0
+      @row_count = 0
+      @query_time = 0.0
+      @transactions_hash = {}
+      @thresholds = ActiveRecordQueryCounter.default_thresholds.dup
+    end
+
+    # Return an array of transaction information for any transactions that have been tracked
+    # by the counter.
+    #
+    # @return [Array<ActiveRecordQueryCounter::TransactionInfo>]
+    def transactions
+      @transactions_hash.values.flatten.sort_by(&:start_time)
+    end
+
+    # Add a tracked transaction.
+    #
+    # @param trace [Array<String>] the trace of the transaction
+    # @param start_time [Float] the monotonic time when the transaction began
+    # @param end_time [Float] the monotonic time when the transaction ended
+    # @return [void]
+    # @api private
+    def add_transaction(trace:, start_time:, end_time:)
+      trace_transactions = @transactions_hash[trace]
+      if trace_transactions
+        # Memory optimization so that we don't store duplicate traces for every transaction in a loop.
+        trace = trace_transactions.first.trace
+      else
+        trace_transactions = []
+        @transactions_hash[trace] = trace_transactions
+      end
+
+      trace_transactions << TransactionInfo.new(start_time: start_time, end_time: end_time, trace: trace)
+    end
+
+    # Return the number of transactions that have been tracked by the counter.
+    #
+    # @return [Integer]
+    def transaction_count
+      @transactions_hash.values.flatten.size
+    end
+
+    # Return the total time spent in transactions that have been tracked by the counter.
+    #
+    # @return [Float]
+    def transaction_time
+      @transactions_hash.values.flatten.sum(&:elapsed_time)
+    end
+
+    # Get the time when the first transaction began.
+    #
+    # @return [Float, nil] the monotonic time when the first transaction began,
+    #   or nil if no transactions have been tracked
+    def first_transaction_start_time
+      transactions.first&.start_time
+    end
+
+    # Get the time when the last transaction completed.
+    #
+    # @return [Float, nil] the monotonic time when the first transaction completed,
+    #   or nil if no transactions have been tracked
+    def last_transaction_end_time
+      transactions.max_by(&:end_time)&.end_time
+    end
+  end
+end

data/lib/active_record_query_counter/rack_middleware.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveRecordQueryCounter
+  # Rack middleware to count queries on a request.
+  class RackMiddleware
+    # @param app [Object] The Rack application.
+    # @param thresholds [Hash] Options for the notification thresholds. Valid keys are:
+    #   * `:query_time` - The minimum query time to send a notification for.
+    #   * `:row_count` - The minimum row count to send a notification for.
+    #   * `:transaction_time` - The minimum transaction time to send a notification for.
+    #   * `:transaction_count` - The minimum transaction count to send a notification for.
+    def initialize(app, thresholds: nil)
+      @app = app
+      @thresholds = thresholds.dup.freeze if thresholds
+    end
+
+    def call(env)
+      ActiveRecordQueryCounter.count_queries do
+        ActiveRecordQueryCounter.thresholds.set(@thresholds) if @thresholds
+
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/active_record_query_counter/sidekiq_middleware.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ActiveRecordQueryCounter
+  # Sidekiq middleware to count queries on a job.
+  #
+  # Notification thresholds can be set per worker with the `active_record_query_counter.thresholds` key in the
+  # `sidekiq_options` hash. Valid keys are:
+  # * `:query_time` - The minimum query time to send a notification for.
+  # * `:row_count` - The minimum row count to send a notification for.
+  # * `:transaction_time` - The minimum transaction time to send a notification for.
+  # * `:transaction_count` - The minimum transaction count to send a notification for.
+  #
+  # Thresholds can be disabled for a worker by setting `active_record_query_counter.thresholds` to `false`.
+  #
+  # @example
+  #
+  #   class MyWorker
+  #     include Sidekiq::Worker
+  #
+  #     sidekiq_options active_record_query_counter: {thresholds: {query_time: 1.5}}
+  #
+  #     def perform
+  #       # ...
+  #     end
+  #   end
+  class SidekiqMiddleware
+    if defined?(Sidekiq::ServerMiddleware)
+      include Sidekiq::ServerMiddleware
+    end
+
+    def call(job_instance, job_payload, queue)
+      ActiveRecordQueryCounter.count_queries do
+        thresholds = job_payload.dig("active_record_query_counter", "thresholds")
+        if thresholds.is_a?(Hash)
+          ActiveRecordQueryCounter.thresholds.set(thresholds)
+        elsif thresholds == false
+          ActiveRecordQueryCounter.thresholds.clear
+        end
+
+        yield
+      end
+    end
+  end
+end

data/lib/active_record_query_counter/thresholds.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ActiveRecordQueryCounter
+  # Thresholds for sending notifications based on query time, row count, transaction time, and
+  # transaction count.
+  class Thresholds
+    attr_reader :query_time, :row_count, :transaction_time, :transaction_count
+
+    def query_time=(value)
+      @query_time = value&.to_f
+    end
+
+    def row_count=(value)
+      @row_count = value&.to_i
+    end
+
+    def transaction_time=(value)
+      @transaction_time = value&.to_f
+    end
+
+    def transaction_count=(value)
+      @transaction_count = value&.to_i
+    end
+
+    # Set threshold values from a hash.
+    #
+    # @param attributes [Hash] the attributes to set
+    # @return [void]
+    def set(values)
+      values.each do |key, value|
+        setter = "#{key}="
+        if respond_to?(setter)
+          public_send("#{key}=", value)
+        else
+          raise ArgumentError, "Unknown threshold: #{key}"
+        end
+      end
+    end
+
+    # Clear all threshold values.
+    def clear
+      @query_time = nil
+      @row_count = nil
+      @transaction_time = nil
+      @transaction_count = nil
+    end
+  end
+end

data/lib/active_record_query_counter/transaction_info.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveRecordQueryCounter
+  # Data structure for storing information about a transaction. Note that the start and end
+  # times are monotonic time and not wall clock time.
+  class TransactionInfo
+    attr_reader :start_time, :end_time, :trace
+
+    def initialize(start_time:, end_time:, trace:)
+      @start_time = start_time
+      @end_time = end_time
+      @trace = trace
+    end
+
+    # Return the time spent in the transaction.
+    #
+    # @return [Float]
+    def elapsed_time
+      end_time - start_time
+    end
+  end
+end

data/lib/active_record_query_counter/transaction_manager_extension.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveRecordQueryCounter
+  # Extension to ActiveRecord::ConnectionAdapters::TransactionManager to count transactions.
+  module TransactionManagerExtension
+    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)
+        @active_record_query_counter_transaction_start_time = nil
+      end
+      super
+    end
+  end
+end

data/lib/active_record_query_counter/version.rb

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

data/lib/active_record_query_counter.rb

@@ -1,8 +1,17 @@
 # frozen_string_literal: true
 
+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.
 #
-# Usage:
+# @example
 #
 #  ActiveRecordQueryCounter.count_queries do
 #    yield
@@ -10,104 +19,164 @@
 #    puts ActiveRecordQueryCounter.row_count
 #  end
 module ActiveRecordQueryCounter
-  class Counter
-    attr_accessor :query_count, :row_count, :query_time
-    attr_reader :transactions
-
-    def initialize
-      @query_count = 0
-      @row_count = 0
-      @query_time = 0.0
-      @transactions = {}
-    end
-
-    def transaction_count
-      @transactions.size
-    end
-
-    def transaction_time
-      @transactions.values.sum { |count, time| time }
-    end
-  end
+  IGNORED_STATEMENTS = %w[CACHE SCHEMA EXPLAIN].freeze
+  private_constant :IGNORED_STATEMENTS
 
   class << self
     # Enable query counting within a block.
+    #
+    # @return [Object] the result of the block
     def count_queries
-      current = Thread.current[:database_query_counter]
+      save_counter = current_counter
       begin
-        Thread.current[:database_query_counter] = Counter.new
-        yield
+        counter = Counter.new
+        self.current_counter = counter
+
+        retval = yield
+
+        transaction_count = counter.transaction_count
+        if transaction_count > 0
+          transaction_threshold = (counter.thresholds.transaction_count || -1)
+          if transaction_threshold >= 0 && transaction_count >= transaction_threshold
+            send_notification("transaction_count", counter.first_transaction_start_time, counter.last_transaction_end_time, transactions: counter.transactions)
+          end
+        end
+
+        retval
       ensure
-        Thread.current[:database_query_counter] = current
+        self.current_counter = save_counter
       end
     end
 
-    # Increment the query counters
-    def increment(row_count, elapsed_time)
-      counter = Thread.current[:database_query_counter]
-      if counter.is_a?(Counter)
-        counter.query_count += 1
-        counter.row_count += row_count
-        counter.query_time += elapsed_time
+    # Increment the query counters.
+    #
+    # @param row_count [Integer] the number of rows returned by the query
+    # @param elapsed_time [Float] the time spent executing the query
+    # @return [void]
+    # @api private
+    def add_query(sql, name, binds, row_count, start_time, end_time)
+      return if IGNORED_STATEMENTS.include?(name)
+
+      counter = current_counter
+      return unless counter.is_a?(Counter)
+
+      elapsed_time = end_time - start_time
+      counter.query_count += 1
+      counter.row_count += row_count
+      counter.query_time += elapsed_time
+
+      trace = nil
+      query_time_threshold = (counter.thresholds.query_time || -1)
+      if query_time_threshold >= 0 && elapsed_time >= query_time_threshold
+        trace = backtrace
+        send_notification("query_time", start_time, end_time, sql: sql, binds: binds, row_count: row_count, trace: trace)
+      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)
       end
     end
 
-    def increment_transaction(elapsed_time)
-      counter = Thread.current[:database_query_counter]
-      if counter.is_a?(Counter)
-        trace = caller
-        index = 0
-        caller.each do |line|
-          break unless line.start_with?(__FILE__)
-          index += 1
-        end
-        trace = trace[index, trace.length]
-        info = counter.transactions[trace]
-        if info
-          info[0] += 1
-          info[1] += elapsed_time
-        else
-          info = [1, elapsed_time]
-          counter.transactions[trace] = info
-        end
+    # Increment the transaction counters.
+    #
+    # @param start_time [Float] the time the transaction started
+    # @param end_time [Float] the time the transaction ended
+    # @return [void]
+    # @api private
+    def add_transaction(start_time, end_time)
+      counter = current_counter
+      return unless counter.is_a?(Counter)
+
+      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
+        send_notification("transaction_time", start_time, end_time, trace: backtrace)
       end
     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.
+    #
+    # @return [Integer, nil]
     def query_count
-      counter = Thread.current[:database_query_counter]
+      counter = current_counter
       counter.query_count if counter.is_a?(Counter)
     end
 
+    # Return the number of rows that have been counted within the current block.
+    # Returns nil if not inside a block where queries are being counted.
+    #
+    # @return [Integer, nil]
     def row_count
-      counter = Thread.current[:database_query_counter]
+      counter = current_counter
       counter.row_count if counter.is_a?(Counter)
     end
 
+    # Return the total time spent executing queries within the current block.
+    # Returns nil if not inside a block where queries are being counted.
+    #
+    # @return [Float, nil]
     def query_time
-      counter = Thread.current[:database_query_counter]
+      counter = current_counter
       counter.query_time if counter.is_a?(Counter)
     end
 
+    # Return the number of transactions that have been counted within the current block.
+    # Returns nil if not inside a block where queries are being counted.
+    #
+    # @return [Integer, nil]
     def transaction_count
-      counter = Thread.current[:database_query_counter]
+      counter = current_counter
       counter.transaction_count if counter.is_a?(Counter)
     end
 
+    # Return the total time spent in transactions that have been counted within the current block.
+    # Returns nil if not inside a block where queries are being counted.
+    #
+    # @return [Float, nil]
     def transaction_time
-      counter = Thread.current[:database_query_counter]
+      counter = current_counter
       counter.transaction_time if counter.is_a?(Counter)
     end
 
+    # Return the time when the first transaction began within the current block.
+    # Returns nil if not inside a block where queries are being counted or there are no transactions.
+    #
+    # @return [Float, nil] the monotonic time when the first transaction began,
+    def first_transaction_start_time
+      counter = current_counter
+      counter.first_transaction_start_time if counter.is_a?(Counter)
+    end
+
+    # Return the time when the last transaction ended within the current block.
+    # Returns nil if not inside a block where queries are being counted or there are no transactions.
+    #
+    # @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)
+    end
+
+    # Return an array of transaction information for any transactions that have been counted
+    # within the current block. Returns nil if not inside a block where queries are being counted.
+    #
+    # @return [Array<ActiveRecordQueryCounter::TransactionInfo>, nil]
     def transactions
-      counter = Thread.current[:database_query_counter]
-      counter.transactions.dup if counter.is_a?(Counter)
+      counter = current_counter
+      counter.transactions 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.
+    #
+    # @return [Hash, nil]
     def info
-      counter = Thread.current[:database_query_counter]
+      counter = current_counter
       if counter.is_a?(Counter)
         {
           query_count: counter.query_count,
@@ -119,7 +188,24 @@ module ActiveRecordQueryCounter
       end
     end
 
+    # The global notification thresholds for sending notifications. The values set in these
+    # thresholds are used as the default values.
+    #
+    # @return [ActiveRecordQueryCounter::Thresholds]
+    def default_thresholds
+      @default_thresholds ||= Thresholds.new
+    end
+
+    # Get the current local notification thresholds. These thresholds are only used within
+    # the current `count_queries` block.
+    def thresholds
+      current_counter&.thresholds || default_thresholds.dup
+    end
+
     # Enable the query counting behavior on a connection adapter class.
+    #
+    # @param connection_class [Class] the connection adapter class to extend
+    # @return [void]
     def enable!(connection_class)
       unless connection_class.include?(ConnectionAdapterExtension)
         connection_class.prepend(ConnectionAdapterExtension)
@@ -128,60 +214,24 @@ module ActiveRecordQueryCounter
         ActiveRecord::ConnectionAdapters::TransactionManager.prepend(TransactionManagerExtension)
       end
     end
-  end
 
-  # Module to prepend to the connection adapter to inject the counting behavior.
-  module ConnectionAdapterExtension
-    def exec_query(*args, **kwargs)
-      start_time = Time.now
-      result = super
-      if result.is_a?(ActiveRecord::Result)
-        ActiveRecordQueryCounter.increment(result.length, Time.now - start_time)
-      end
-      result
-    end
-  end
-
-  module TransactionManagerExtension
-    def begin_transaction(*args, **kwargs)
-      if open_transactions == 0
-        @active_record_query_counter_transaction_start_time = Time.current
-      end
-      super
-    end
-
-    def commit_transaction(*args)
-      if @active_record_query_counter_transaction_start_time && open_transactions == 1
-        ActiveRecordQueryCounter.increment_transaction(Time.current - @active_record_query_counter_transaction_start_time)
-        @active_record_query_counter_transaction_start_time = nil
-      end
-      super
-    end
+    private
 
-    def rollback_transaction(*args)
-      if @active_record_query_counter_transaction_start_time && open_transactions == 1
-        ActiveRecordQueryCounter.increment_transaction(Time.current - @active_record_query_counter_transaction_start_time)
-        @active_record_query_counter_transaction_start_time = nil
-      end
-      super
+    def current_counter
+      Thread.current[:active_record_query_counter]
     end
-  end
 
-  # Rack middleware to count queries on a request.
-  class RackMiddleware
-    def initialize(app)
-      @app = app
+    def current_counter=(counter)
+      Thread.current[:active_record_query_counter] = counter
     end
 
-    def call(env)
-      ActiveRecordQueryCounter.count_queries { @app.call(env) }
+    def send_notification(name, start_time, end_time, payload = {})
+      id = "#{name}-#{SecureRandom.hex}"
+      ActiveSupport::Notifications.publish("active_record_query_counter.#{name}", start_time, end_time, id, payload)
     end
-  end
 
-  # Sidekiq middleware to count queries on a job.
-  class SidekiqMiddleware
-    def call(worker, job, queue, &block)
-      ActiveRecordQueryCounter.count_queries(&block)
+    def backtrace
+      caller.reject { |line| line.start_with?(__dir__) }
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_record_query_counter
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Brian Durand
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-03 00:00:00.000000000 Z
+date: 2023-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -38,27 +38,32 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - bbdurand@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".github/dependabot.yml"
-- ".github/workflows/continuous_integration.yml"
-- ".standard.yml"
 - CHANGELOG.md
 - MIT_LICENSE
 - README.md
 - VERSION
 - active_record_query_counter.gemspec
 - lib/active_record_query_counter.rb
+- lib/active_record_query_counter/connection_adapter_extension.rb
+- lib/active_record_query_counter/counter.rb
+- 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_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
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -66,15 +71,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.4.10
+signing_key:
 specification_version: 4
 summary: Count total number of ActiveRecord queries and row counts inside a block
 test_files: []

data/.github/dependabot.yml

@@ -1,12 +0,0 @@
-# Dependabot update strategy
-version: 2
-updates:
-  - package-ecosystem: bundler
-    directory: "/"
-    schedule:
-      interval: daily
-    allow:
-      # Automatically keep all runtime dependencies updated
-      - dependency-name: "*"
-        dependency-type: "production"
-    versioning-strategy: lockfile-only

data/.github/workflows/continuous_integration.yml

@@ -1,73 +0,0 @@
-name: Continuous Integration
-on:
-  push:
-    branches:
-      - master
-      - actions-*
-    tags:
-      - v*
-  pull_request:
-env:
-  BUNDLE_CLEAN: "true"
-  BUNDLE_PATH: vendor/bundle
-  BUNDLE_JOBS: 3
-  BUNDLE_RETRY: 3
-  CC_TEST_REPORTER_ID: 8f360e59f6cb98313ccbb27fecf82f667455acec33cf23ae115c2db121852700
-jobs:
-  specs:
-    name: ${{ matrix.job }} ruby-${{ matrix.combo.ruby || matrix.ruby }} ${{ matrix.combo.activerecord && format('activerecord-{0}', matrix.combo.activerecord) }}
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        combo:
-          - activerecord: "latest"
-            ruby: "3.0"
-            coverage: true
-          - activerecord: "6.1"
-            ruby: "3.0"
-          - activerecord: "6.0"
-            ruby: "2.7"
-          - activerecord: "5.2"
-            ruby: "2.6"
-          - activerecord: "5.1"
-            ruby: "2.6"
-          - activerecord: "5.0"
-            ruby: "2.5"
-        job: [ rspec ]
-        include:
-          - ruby: "3.0"
-            activerecord: "latest"
-            job: rspec
-          - ruby: "2.7"
-            activerecord: "latest"
-            job: standardrb
-    steps:
-      - name: checkout
-        uses: actions/checkout@v2
-      - name: set up Ruby
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.combo.ruby || matrix.ruby }}
-      - name: setup bundler
-        run: |
-          if [ "${{ matrix.combo.bundler }}" != "" ]; then
-            gem uninstall bundler --all
-            gem install bundler --no-document --version ${{ matrix.combo.bundler }}
-          fi
-          if [ "${{ matrix.combo.activerecord || matrix.activerecord }}" != "latest" ]; then
-            echo "using gemfile gemfiles/activerecord_${{ matrix.combo.activerecord || matrix.activerecord }}.gemfile"
-            bundle config set gemfile "gemfiles/activerecord_${{ matrix.combo.activerecord || matrix.activerecord }}.gemfile"
-          fi
-          bundle update
-      - name: install dependencies
-        run:  bundle install
-      - name: specs
-        if:   matrix.job == 'rspec'
-        run:  bundle exec rake spec
-      - name: code coverage
-        if:   matrix.coverage == true
-        uses: paambaati/codeclimate-action@v2.7.5
-      - name: standardrb
-        if:   matrix.job == 'standardrb'
-        run:  bundle exec rake standard

data/.standard.yml

@@ -1,11 +0,0 @@
-# I really just have issues with the automatic "semantic blocks"
-
-ruby_version: 2.5
-
-format: progress
-
-ignore:
-  - '**/*':
-    - Standard/SemanticBlocks
-  - 'spec/**/*':
-    - Lint/UselessAssignment