stinkingtoe 1.11.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d88e8ea94e8b670203c820b5aa082e82f0515e5e6b995911977431128eea6909
+  data.tar.gz: 80f43ac62f3632ab67527be25ad2c3e9c896f59059c61d798f9927ff5de7d7f7
+SHA512:
+  metadata.gz: 7c876857d5c40dfc152150993ea80e58f58ec531b65a00d944914a81e9d865dc9d2e7a725588b853269bdc7cb796fa3a3b77ae69e98d76bc7d21c204f8116888
+  data.tar.gz: 07ad331dbbb5cc229f9e68ce4c1dc27f70dec49fb0474d02a5477be4c755d0f9a539c67acb82ffd6f85d1cf3bef78352a8f39bd74f7b695589e27624872d2fa7

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+tmp
+stinkingtoe_test
+Gemfile.lock

data/.ruby-version

@@ -0,0 +1 @@
+2.6.8

data/Gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+gemspec
+
+rails_version = ENV["RAILS_VERSION"] || "6.1.0"
+if rails_version == "main"
+  gem "rails", github: "rails/rails"
+else
+  gem "rails", "~> #{rails_version}"
+end

data/LICENSE

@@ -0,0 +1,20 @@
+# Copyright (c) 2026
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,120 @@
+# stinkingtoe 
+
+Add comments to your ActiveRecord queries. By default, this appends the application, controller, and action names as a comment to each query.
+
+This is useful for tracking queries in log files and identifying the source of slow queries.
+
+For example, once enabled, your logs will look like:
+
+    Account Load (0.3ms)  SELECT `accounts`.* FROM `accounts` 
+    WHERE `accounts`.`queenbee_id` = 1234567890 
+    LIMIT 1 
+    /*application:APP,controller:project_imports,action:show*/
+
+## Installation
+
+    # Gemfile
+    gem 'stinkingtoe'
+
+### Customization
+
+Optionally, you can set the application name shown in the log like so in an initializer (e.g. `config/initializers/stinkingtoe.rb`):
+
+    StinkingToe.application_name = "APP"
+
+The name will default to your Rails application name.
+
+#### Components
+
+You can also configure the components of the comment that will be appended,
+by setting `StinkingToe::Comment.components`. By default, this is set to:
+
+    StinkingToe::Comment.components = [:application, :controller, :action]
+
+Which results in a comment of
+`application:#{application_name},controller:#{controller.name},action:#{action_name}`.
+
+You can re-order or remove these components. You can also add additional
+comment components of your desire by defining new module methods for
+`StinkingToe::Comment` which return a string. For example:
+
+    module StinkingToe
+      module Comment
+        def self.mycommentcomponent
+          "TEST"
+        end
+      end
+    end
+
+    StinkingToe::Comment.components = [:application, :mycommentcomponent]
+
+Which will result in a comment like
+`application:#{application_name},mycommentcomponent:TEST`
+The calling controller is available to these methods via `@controller`.
+
+StinkingToe ships with `:application`, `:controller`, and `:action` enabled by
+default. In addition, implementation is provided for:
+  * `:line` (for file and line number calling query). :line supports
+    a configuration by setting a regexp in `StinkingToe::Comment.lines_to_ignore`
+    to exclude parts of the stacktrace from inclusion in the line comment.
+  * `:controller_with_namespace` to include the full classname (including namespace)
+    of the controller.
+  * `:job` to include the classname of the ActiveJob being performed.
+  * `:hostname` to include ```Socket.gethostname```.
+  * `:pid` to include current process id. 
+  * `:db_host` to include the configured database hostname.
+  * `:socket` to include the configured database socket.
+  * `:database` to include the configured database name.
+
+Pull requests for other included comment components are welcome.
+
+#### Prepend comments
+
+By default, `stinkingtoe` appends comments at the end of queries. Some databases, like MySQL, truncate query text—for example, in slow query logs and certain InnoDB internal table queries where the query exceeds 1024 bytes.
+
+In order to not lose the `stinkingtoe` comments from your logs, you can prepend the comments using this option:
+
+    StinkingToe::Comment.prepend_comment = true
+
+#### Inline query annotations
+
+In addition to the request or job-level component-based annotations,
+`stinkingtoe` may be used to add inline annotations to specific queries using a
+block-based API.
+
+For example, the following code:
+
+    StinkingToe.with_annotation("foo") do
+      Account.where(queenbee_id: 1234567890).first
+    end
+
+will issue this query:
+
+    Account Load (0.3ms)  SELECT `accounts`.* FROM `accounts`
+    WHERE `accounts`.`queenbee_id` = 1234567890
+    LIMIT 1
+    /*application:APP,controller:project_imports,action:show*/ /*foo*/
+
+Nesting `with_annotation` blocks will concatenate the comment strings.
+
+### Caveats
+
+#### Prepared statements
+
+Be careful when using `stinkingtoe` with prepared statements. If you use a component
+like `request_id` then every query will be unique and so ActiveRecord will create
+a new prepared statement for each potentially exhausting system resources.
+[Disable prepared statements](https://guides.rubyonrails.org/configuring.html#configuring-a-postgresql-database)
+if you wish to use components with high cardinality values.
+
+## Contributing
+
+Start by bundling and creating the test database:
+
+    bundle
+    rake db:mysql:create
+    rake db:postgresql:create
+
+Then, running `rake` will run the tests on all the database adapters (`mysql`, `mysql2`, `postgresql` and `sqlite`):
+
+    rake

data/Rakefile

@@ -0,0 +1,60 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+task :default => ['test:all']
+
+namespace :test do
+  desc "test all drivers"
+  task :all => [:mysql2, :postgresql, :sqlite]
+
+  desc "test mysql2 driver"
+  task :mysql2 do
+    sh "DRIVER=mysql2 bundle exec ruby -Ilib -Itest test/*_test.rb"
+  end
+
+  desc "test PostgreSQL driver"
+  task :postgresql do
+    sh "DRIVER=postgresql DB_USERNAME=postgres bundle exec ruby -Ilib -Itest test/*_test.rb"
+  end
+
+  desc "test sqlite3 driver"
+  task :sqlite do
+    sh "DRIVER=sqlite3 bundle exec ruby -Ilib -Itest test/*_test.rb"
+  end
+end
+
+namespace :db do
+
+  desc "reset all databases"
+  task :reset => [:"mysql:reset", :"postgresql:reset"]
+
+  namespace :mysql do
+    desc "reset MySQL database"
+    task :reset => [:drop, :create]
+
+    desc "create MySQL database"
+    task :create do
+      sh 'mysql -u root -e "create database stinkingtoe_test;"'
+    end
+
+    desc "drop MySQL database"
+    task :drop do
+      sh 'mysql -u root -e "drop database if exists stinkingtoe_test;"'
+    end
+  end
+
+  namespace :postgresql do
+    desc "reset PostgreSQL database"
+    task :reset => [:drop, :create]
+
+    desc "create PostgreSQL database"
+    task :create do
+      sh 'createdb -U postgres stinkingtoe_test'
+    end
+
+    desc "drop PostgreSQL database"
+    task :drop do
+      sh 'psql -d postgres -U postgres -c "DROP DATABASE IF EXISTS stinkingtoe_test"'
+    end
+  end
+end

data/lib/stinkingtoe/comment.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+module StinkingToe
+  module Comment
+    mattr_accessor :components, :lines_to_ignore, :prepend_comment
+    StinkingToe::Comment.components ||= [:application, :controller, :action]
+
+    def self.update!(controller = nil)
+      self.stinkingtoe_controller = controller
+    end
+
+    def self.update_job!(job)
+      self.stinkingtoe_job = job
+    end
+
+    def self.update_adapter!(adapter)
+      self.stinkingtoe_adapter = adapter
+    end
+
+    def self.construct_comment
+      ret = String.new
+      self.components.each do |c|
+        component_value = self.send(c)
+        if component_value.present?
+          ret << "#{c}:#{component_value},"
+        end
+      end
+      ret.chop!
+      ret = self.escape_sql_comment(ret)
+      ret
+    end
+
+    def self.construct_inline_comment
+      return nil if inline_annotations.none?
+      escape_sql_comment(inline_annotations.join)
+    end
+
+    def self.escape_sql_comment(str)
+      while str.include?('/*') || str.include?('*/')
+        str = str.gsub('/*', '').gsub('*/', '')
+      end
+      str
+    end
+
+    def self.clear!
+      self.stinkingtoe_controller = nil
+    end
+
+    def self.clear_job!
+      self.stinkingtoe_job = nil
+    end
+
+    private
+      def self.stinkingtoe_controller=(controller)
+        Thread.current[:stinkingtoe_controller] = controller
+      end
+
+      def self.stinkingtoe_controller
+        Thread.current[:stinkingtoe_controller]
+      end
+
+      def self.stinkingtoe_job=(job)
+        Thread.current[:stinkingtoe_job] = job
+      end
+
+      def self.stinkingtoe_job
+        Thread.current[:stinkingtoe_job]
+      end
+
+      def self.stinkingtoe_adapter=(adapter)
+        Thread.current[:stinkingtoe_adapter] = adapter
+      end
+
+      def self.stinkingtoe_adapter
+        Thread.current[:stinkingtoe_adapter]
+      end
+
+      def self.application
+        if defined?(Rails.application)
+          StinkingToe.application_name ||= Rails.application.class.name.split("::").first
+        else
+          StinkingToe.application_name ||= "rails"
+        end
+
+        StinkingToe.application_name
+      end
+
+      def self.job
+        stinkingtoe_job.class.name if stinkingtoe_job
+      end
+
+      def self.controller
+        stinkingtoe_controller.controller_name if stinkingtoe_controller.respond_to? :controller_name
+      end
+
+      def self.controller_with_namespace
+        stinkingtoe_controller.class.name if stinkingtoe_controller
+      end
+
+      def self.action
+        stinkingtoe_controller.action_name if stinkingtoe_controller.respond_to? :action_name
+      end
+
+      def self.sidekiq_job
+        stinkingtoe_job["class"] if stinkingtoe_job && stinkingtoe_job.respond_to?(:[])
+      end
+
+      DEFAULT_LINES_TO_IGNORE_REGEX = %r{\.rvm|/ruby/gems/|vendor/|stinkingtoe|rbenv|monitor\.rb.*mon_synchronize}
+
+      def self.line
+        StinkingToe::Comment.lines_to_ignore ||= DEFAULT_LINES_TO_IGNORE_REGEX
+
+        last_line = caller_locations.detect do |loc|
+          !loc.path.match?(StinkingToe::Comment.lines_to_ignore)
+        end
+        if last_line
+          last_line = last_line.to_s
+
+          root = if defined?(Rails) && Rails.respond_to?(:root)
+            Rails.root.to_s
+          elsif defined?(RAILS_ROOT)
+            RAILS_ROOT
+          else
+            ""
+          end
+          if last_line.start_with? root
+            last_line = last_line[root.length..-1]
+          end
+          last_line
+        end
+      end
+
+      def self.hostname
+        @cached_hostname ||= Socket.gethostname
+      end
+
+      def self.pid
+        Process.pid
+      end
+
+      def self.request_id
+        if stinkingtoe_controller.respond_to?(:request) && stinkingtoe_controller.request.respond_to?(:uuid)
+          stinkingtoe_controller.request.uuid
+        end
+      end
+
+      def self.socket
+        if self.connection_config.present?
+          self.connection_config[:socket]
+        end
+      end
+
+      def self.db_host
+        if self.connection_config.present?
+          self.connection_config[:host]
+        end
+      end
+
+      def self.database
+        if self.connection_config.present?
+          self.connection_config[:database]
+        end
+      end
+
+      if Gem::Version.new(ActiveRecord::VERSION::STRING) < Gem::Version.new('6.1')
+        def self.connection_config
+          return if stinkingtoe_adapter.pool.nil?
+          stinkingtoe_adapter.pool.spec.config
+        end
+      else
+        def self.connection_config
+          # `pool` might be a NullPool which has no db_config
+          return unless stinkingtoe_adapter.pool.respond_to?(:db_config)
+          stinkingtoe_adapter.pool.db_config.configuration_hash
+        end
+      end
+
+      def self.inline_annotations
+        Thread.current[:stinkingtoe_inline_annotations] ||= []
+      end
+  end
+
+end

data/lib/stinkingtoe/railtie.rb

@@ -0,0 +1,74 @@
+require 'stinkingtoe'
+require 'rails/railtie'
+
+module StinkingToe
+  class Railtie < Rails::Railtie
+    initializer 'marginalia.insert' do
+      ActiveSupport.on_load :active_record do
+        StinkingToe::Railtie.insert_into_active_record
+      end
+
+      ActiveSupport.on_load :action_controller do
+        StinkingToe::Railtie.insert_into_action_controller
+      end
+
+      ActiveSupport.on_load :active_job do
+        StinkingToe::Railtie.insert_into_active_job
+      end
+    end
+
+    def self.insert
+      insert_into_active_record
+      insert_into_action_controller
+      insert_into_active_job
+    end
+
+    def self.insert_into_active_job
+      if defined? ActiveJob::Base
+        ActiveJob::Base.class_eval do
+          around_perform do |job, block|
+            begin
+              StinkingToe::Comment.update_job! job
+              block.call
+            ensure
+              StinkingToe::Comment.clear_job!
+            end
+          end
+        end
+      end
+    end
+
+    def self.insert_into_action_controller
+      ActionController::Base.send(:include, ActionControllerInstrumentation)
+      if defined? ActionController::API
+        ActionController::API.send(:include, ActionControllerInstrumentation)
+      end
+    end
+
+    def self.insert_into_active_record
+      if defined? ActiveRecord::ConnectionAdapters::Mysql2Adapter
+        ActiveRecord::ConnectionAdapters::Mysql2Adapter.module_eval do
+          include StinkingToe::ActiveRecordInstrumentation
+        end
+      end
+
+      if defined? ActiveRecord::ConnectionAdapters::MysqlAdapter
+        ActiveRecord::ConnectionAdapters::MysqlAdapter.module_eval do
+          include StinkingToe::ActiveRecordInstrumentation
+        end
+      end
+
+      if defined? ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+        ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.module_eval do
+          include StinkingToe::ActiveRecordInstrumentation
+        end
+      end
+
+      if defined? ActiveRecord::ConnectionAdapters::SQLite3Adapter
+        ActiveRecord::ConnectionAdapters::SQLite3Adapter.module_eval do
+          include StinkingToe::ActiveRecordInstrumentation
+        end
+      end
+    end
+  end
+end

data/lib/stinkingtoe/sidekiq_instrumentation.rb

@@ -0,0 +1,24 @@
+module StinkingToe
+
+  # Alternative to ActiveJob Instrumentation for Sidekiq.
+  module SidekiqInstrumentation
+
+    class Middleware
+      def call(worker, msg, queue)
+        StinkingToe::Comment.update_job! msg
+        yield
+      ensure
+        StinkingToe::Comment.clear_job!
+      end
+    end
+
+    def self.enable!
+      Sidekiq.configure_server do |config|
+        config.server_middleware do |chain|
+          chain.add StinkingToe::SidekiqInstrumentation::Middleware
+        end
+      end
+    end
+  end
+
+end

data/lib/stinkingtoe.rb

@@ -0,0 +1,121 @@
+require 'stinkingtoe/railtie'
+require 'stinkingtoe/comment'
+require 'stinkingtoe/sidekiq_instrumentation'
+
+module StinkingToe
+  mattr_accessor :application_name
+
+  module ActiveRecordInstrumentation
+    def self.included(instrumented_class)
+      instrumented_class.class_eval do
+        if instrumented_class.method_defined?(:execute)
+          alias_method :execute_without_stinkingtoe, :execute
+          alias_method :execute, :execute_with_stinkingtoe
+        end
+
+        if instrumented_class.private_method_defined?(:execute_and_clear)
+          alias_method :execute_and_clear_without_stinkingtoe, :execute_and_clear
+          alias_method :execute_and_clear, :execute_and_clear_with_stinkingtoe
+        else
+          is_mysql2 = defined?(ActiveRecord::ConnectionAdapters::Mysql2Adapter) &&
+            ActiveRecord::ConnectionAdapters::Mysql2Adapter == instrumented_class
+          # Dont instrument exec_query on mysql2 as it calls execute internally
+          unless is_mysql2
+            if instrumented_class.method_defined?(:exec_query)
+              alias_method :exec_query_without_stinkingtoe, :exec_query
+              alias_method :exec_query, :exec_query_with_stinkingtoe
+            end
+          end
+
+          is_postgres = defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter) &&
+            ActiveRecord::ConnectionAdapters::PostgreSQLAdapter == instrumented_class
+          # Instrument exec_delete and exec_update since they don't call
+          # execute internally
+          if is_postgres
+            if instrumented_class.method_defined?(:exec_delete)
+              alias_method :exec_delete_without_stinkingtoe, :exec_delete
+              alias_method :exec_delete, :exec_delete_with_stinkingtoe
+            end
+            if instrumented_class.method_defined?(:exec_update)
+              alias_method :exec_update_without_stinkingtoe, :exec_update
+              alias_method :exec_update, :exec_update_with_stinkingtoe
+            end
+          end
+        end
+      end
+    end
+
+    def annotate_sql(sql)
+      StinkingToe::Comment.update_adapter!(self)
+      comment = StinkingToe::Comment.construct_comment
+      if comment.present? && !sql.include?(comment)
+        sql = if StinkingToe::Comment.prepend_comment
+          "/*#{comment}*/ #{sql}"
+        else
+          "#{sql} /*#{comment}*/"
+        end
+      end
+      inline_comment = StinkingToe::Comment.construct_inline_comment
+      if inline_comment.present? && !sql.include?(inline_comment)
+        sql = if StinkingToe::Comment.prepend_comment
+          "/*#{inline_comment}*/ #{sql}"
+        else
+          "#{sql} /*#{inline_comment}*/"
+        end
+      end
+
+      sql
+    end
+
+    def execute_with_stinkingtoe(sql, *args)
+      execute_without_stinkingtoe(annotate_sql(sql), *args)
+    end
+    ruby2_keywords :execute_with_stinkingtoe if respond_to?(:ruby2_keywords, true)
+
+    def exec_query_with_stinkingtoe(sql, *args, **options)
+      options[:prepare] ||= false
+      exec_query_without_stinkingtoe(annotate_sql(sql), *args, **options)
+    end
+
+    def exec_delete_with_stinkingtoe(sql, *args)
+      exec_delete_without_stinkingtoe(annotate_sql(sql), *args)
+    end
+    ruby2_keywords :exec_delete_with_stinkingtoe if respond_to?(:ruby2_keywords, true)
+
+    def exec_update_with_stinkingtoe(sql, *args)
+      exec_update_without_stinkingtoe(annotate_sql(sql), *args)
+    end
+    ruby2_keywords :exec_update_with_stinkingtoe if respond_to?(:ruby2_keywords, true)
+
+    def execute_and_clear_with_stinkingtoe(sql, *args, &block)
+      execute_and_clear_without_stinkingtoe(annotate_sql(sql), *args, &block)
+    end
+    ruby2_keywords :execute_and_clear_with_stinkingtoe if respond_to?(:ruby2_keywords, true)
+  end
+
+  module ActionControllerInstrumentation
+    def self.included(instrumented_class)
+      instrumented_class.class_eval do
+        if respond_to?(:around_action)
+          around_action :record_query_comment
+        else
+          around_filter :record_query_comment
+        end
+      end
+    end
+
+    def record_query_comment
+      StinkingToe::Comment.update!(self)
+      yield
+    ensure
+      StinkingToe::Comment.clear!
+    end
+  end
+
+  def self.with_annotation(comment, &block)
+    StinkingToe::Comment.inline_annotations.push(comment)
+    block.call if block.present?
+  ensure
+    StinkingToe::Comment.inline_annotations.pop
+  end
+end

data/stinkingtoe.gemspec

@@ -0,0 +1,25 @@
+Gem::Specification.new do |gem|
+  gem.authors       = ["Linda Zhou"]
+  gem.email         = ["lhmzhou@github.com"]
+  gem.homepage      = "https://github.com/lhmzhou"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test}/*`.split("\n")
+  gem.name          = "stinkingtoe"
+  gem.require_paths = ["lib"]
+  gem.version       = "1.11.1"
+  gem.license       = "MIT"
+
+  gem.add_runtime_dependency "actionpack", ">= 5.2"
+  gem.add_runtime_dependency "activerecord", ">= 5.2"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "mysql2"
+  gem.add_development_dependency "pg"
+  gem.add_development_dependency "sqlite3"
+  gem.add_development_dependency "minitest"
+  gem.add_development_dependency "mocha"
+  gem.add_development_dependency "sidekiq"
+
+  gem.summary = gem.description = %q{attach comments to your ActiveRecord queries}
+end

data/test/query_comments_test.rb

@@ -0,0 +1,372 @@
+# -*- coding: utf-8 -*-
+require 'rails/version'
+
+def using_rails_api?
+  ENV["TEST_RAILS_API"] == true
+end
+
+def pool_db_config?
+  Gem::Version.new(ActiveRecord::VERSION::STRING) >= Gem::Version.new('6.1')
+end
+
+require "minitest/autorun"
+require "mocha/minitest"
+require 'logger'
+require 'pp'
+require 'active_record'
+require 'action_controller'
+require 'active_job'
+require 'sidekiq'
+require 'sidekiq/testing'
+
+require 'action_dispatch/middleware/request_id'
+
+if using_rails_api?
+  require 'rails-api/action_controller/api'
+end
+
+# Shim for compatibility with older versions of Minitest
+Minitest::Test = Minitest::Unit::TestCase unless defined?(Minitest::Test)
+
+# From version 4.1, ActiveRecord expects `Rails.env` to be
+# defined if `Rails` is defined
+if defined?(Rails) && !defined?(Rails.env)
+  module Rails
+    def self.env
+    end
+  end
+end
+
+require 'stinkingtoe'
+RAILS_ROOT = File.expand_path(File.dirname(__FILE__))
+
+ActiveRecord::Base.establish_connection({
+  :adapter  => ENV["DRIVER"] || "mysql",
+  :host     => ENV["DB_HOST"] || "localhost",
+  :username => ENV["DB_USERNAME"] || "root",
+  :database => "stinkingtoe_test"
+})
+
+class Post < ActiveRecord::Base
+end
+
+class PostsController < ActionController::Base
+  def driver_only
+    ActiveRecord::Base.connection.execute "select id from posts"
+    if Gem::Version.new(Rails::VERSION::STRING) >= Gem::Version.new('5')
+      render body: nil
+    else
+      render nothing: true
+    end
+  end
+end
+
+module API
+  module V1
+    class PostsController < ::PostsController
+    end
+  end
+end
+
+class PostsJob < ActiveJob::Base
+  def perform
+    Post.first
+  end
+end
+
+class PostsSidekiqJob
+  include Sidekiq::Worker
+  def perform
+    Post.first
+  end
+end
+
+if using_rails_api?
+  class PostsApiController < ActionController::API
+    def driver_only
+      ActiveRecord::Base.connection.execute "select id from posts"
+      head :no_content
+    end
+  end
+end
+
+unless Post.table_exists?
+  ActiveRecord::Schema.define do
+    create_table "posts", :force => true do |t|
+    end
+  end
+end
+
+StinkingToe::Railtie.insert
+
+class StinkingToeTest < Minitest::Test
+  def setup
+    # Touch the model to avoid spurious schema queries
+    Post.first
+
+    @queries = []
+    ActiveSupport::Notifications.subscribe "sql.active_record" do |*args|
+      @queries << args.last[:sql]
+    end
+    @env = Rack::MockRequest.env_for('/')
+    ActiveJob::Base.queue_adapter = :inline
+  end
+
+  def test_double_annotate
+    ActiveRecord::Base.connection.expects(:annotate_sql).returns("select id from posts").once
+    ActiveRecord::Base.connection.send(:select, "select id from posts")
+  ensure
+    ActiveRecord::Base.connection.unstub(:annotate_sql)
+  end
+
+  def test_exists
+    Post.exists?
+    assert_match %r{/\*application:rails\*/$}, @queries.last
+  end
+
+  def test_query_commenting_on_mysql_driver_with_no_action
+    ActiveRecord::Base.connection.execute "select id from posts"
+    assert_match %r{select id from posts /\*application:rails\*/$}, @queries.first
+  end
+
+  if ENV["DRIVER"] =~ /^mysql/
+    def test_query_commenting_on_mysql_driver_with_binary_chars
+      ActiveRecord::Base.connection.execute "select id from posts /* \x81\x80\u0010\ */"
+      assert_equal "select id from posts /* \x81\x80\u0010 */ /*application:rails*/", @queries.first
+    end
+  end
+
+  if ENV["DRIVER"] =~ /^postgres/
+    def test_query_commenting_on_postgres_update
+      ActiveRecord::Base.connection.expects(:annotate_sql).returns("update posts set id = 1").once
+      ActiveRecord::Base.connection.send(:exec_update, "update posts set id = 1")
+    ensure
+      ActiveRecord::Base.connection.unstub(:annotate_sql)
+    end
+
+    def test_query_commenting_on_postgres_delete
+      ActiveRecord::Base.connection.expects(:annotate_sql).returns("delete from posts where id = 1").once
+      ActiveRecord::Base.connection.send(:exec_delete, "delete from posts where id = 1")
+    ensure
+      ActiveRecord::Base.connection.unstub(:annotate_sql)
+    end
+  end
+
+  def test_query_commenting_on_mysql_driver_with_action
+    PostsController.action(:driver_only).call(@env)
+    assert_match %r{select id from posts /\*application:rails,controller:posts,action:driver_only\*/$}, @queries.first
+
+    if using_rails_api?
+      PostsApiController.action(:driver_only).call(@env)
+      assert_match %r{select id from posts /\*application:rails,controller:posts_api,action:driver_only\*/$}, @queries.second
+    end
+  end
+
+  def test_configuring_application
+    StinkingToe.application_name = "customapp"
+    PostsController.action(:driver_only).call(@env)
+    assert_match %r{/\*application:customapp,controller:posts,action:driver_only\*/$}, @queries.first
+
+    if using_rails_api?
+      PostsApiController.action(:driver_only).call(@env)
+      assert_match %r{/\*application:customapp,controller:posts_api,action:driver_only\*/$}, @queries.second
+    end
+  end
+
+  def test_configuring_query_components
+    StinkingToe::Comment.components = [:controller]
+    PostsController.action(:driver_only).call(@env)
+    assert_match %r{/\*controller:posts\*/$}, @queries.first
+
+    if using_rails_api?
+      PostsApiController.action(:driver_only).call(@env)
+      assert_match %r{/\*controller:posts_api\*/$}, @queries.second
+    end
+  end
+
+  def test_last_line_component
+    StinkingToe::Comment.components = [:line]
+    PostsController.action(:driver_only).call(@env)
+
+    # Because "lines_to_ignore" by default includes "stinkingtoe" and "gem", the
+    # extracted line line will be from the line in this file that actually
+    # triggers the query.
+    assert_match %r{/\*line:test/query_comments_test.rb:[0-9]+:in `driver_only'\*/$}, @queries.first
+  end
+
+  def test_last_line_component_with_lines_to_ignore
+    StinkingToe::Comment.lines_to_ignore = /foo bar/
+    StinkingToe::Comment.components = [:line]
+    PostsController.action(:driver_only).call(@env)
+    # Because "lines_to_ignore" does not include "stinkingtoe", the extracted
+    # line will be from stinkingtoe/comment.rb.
+    assert_match %r{/\*line:.*lib/stinkingtoe/comment.rb:[0-9]+}, @queries.first
+  end
+
+  def test_default_lines_to_ignore_regex
+    line = "/gems/a_gem/lib/a_gem.rb:1:in `some_method'"
+    call_stack = [line] + caller
+
+    assert_match(
+      call_stack.detect { |line| line !~ StinkingToe::Comment::DEFAULT_LINES_TO_IGNORE_REGEX },
+      line
+    )
+  end
+
+  def test_hostname_and_pid
+    StinkingToe::Comment.components = [:hostname, :pid]
+    PostsController.action(:driver_only).call(@env)
+    assert_match %r{/\*hostname:#{Socket.gethostname},pid:#{Process.pid}\*/$}, @queries.first
+  end
+
+  def test_controller_with_namespace
+    StinkingToe::Comment.components = [:controller_with_namespace]
+    API::V1::PostsController.action(:driver_only).call(@env)
+    assert_match %r{/\*controller_with_namespace:API::V1::PostsController}, @queries.first
+  end
+
+  def test_db_host
+    StinkingToe::Comment.components = [:db_host]
+    API::V1::PostsController.action(:driver_only).call(@env)
+    assert_match %r{/\*db_host:#{ENV["DB_HOST"] || "localhost"}}, @queries.first
+  end
+
+  def test_database
+    StinkingToe::Comment.components = [:database]
+    API::V1::PostsController.action(:driver_only).call(@env)
+    assert_match %r{/\*database:stinkingtoe_test}, @queries.first
+  end
+
+  if pool_db_config?
+    def test_socket
+      # setting socket in configuration would break some connections - mock it instead
+      pool = ActiveRecord::Base.connection_pool
+      pool.db_config.stubs(:configuration_hash).returns({:socket => "stinkingtoe_socket"})
+      StinkingToe::Comment.components = [:socket]
+      API::V1::PostsController.action(:driver_only).call(@env)
+      assert_match %r{/\*socket:stinkingtoe_socket}, @queries.first
+      pool.db_config.unstub(:configuration_hash)
+    end
+  else
+    def test_socket
+      # setting socket in configuration would break some connections - mock it instead
+      pool = ActiveRecord::Base.connection_pool
+      pool.spec.stubs(:config).returns({:socket => "stinkingtoe_socket"})
+      StinkingToe::Comment.components = [:socket]
+      API::V1::PostsController.action(:driver_only).call(@env)
+      assert_match %r{/\*socket:stinkingtoe_socket}, @queries.first
+      pool.spec.unstub(:config)
+    end
+  end
+
+  def test_request_id
+    @env["action_dispatch.request_id"] = "some-uuid"
+    StinkingToe::Comment.components = [:request_id]
+    PostsController.action(:driver_only).call(@env)
+    assert_match %r{/\*request_id:some-uuid.*}, @queries.first
+
+    if using_rails_api?
+      PostsApiController.action(:driver_only).call(@env)
+      assert_match %r{/\*request_id:some-uuid.*}, @queries.second
+    end
+  end
+
+  def test_active_job
+    StinkingToe::Comment.components = [:job]
+    PostsJob.perform_later
+    assert_match %{job:PostsJob}, @queries.first
+
+    Post.first
+    refute_match %{job:PostsJob}, @queries.last
+  end
+
+  def test_active_job_with_sidekiq
+    StinkingToe::Comment.components = [:job, :sidekiq_job]
+    PostsJob.perform_later
+    assert_match %{job:PostsJob}, @queries.first
+
+    Post.first
+    refute_match %{job:PostsJob}, @queries.last
+  end
+
+  def test_sidekiq_job
+    StinkingToe::Comment.components = [:sidekiq_job]
+    StinkingToe::SidekiqInstrumentation.enable!
+
+    # Test harness does not run Sidekiq middlewares by default so include testing middleware.
+    Sidekiq::Testing.server_middleware do |chain|
+      chain.add StinkingToe::SidekiqInstrumentation::Middleware
+    end
+
+    Sidekiq::Testing.fake!
+    PostsSidekiqJob.perform_async
+    PostsSidekiqJob.drain
+    assert_match %{sidekiq_job:PostsSidekiqJob}, @queries.first
+
+    Post.first
+    refute_match %{sidekiq_job:PostsSidekiqJob}, @queries.last
+  end
+
+  def test_good_comment
+    assert_equal StinkingToe::Comment.escape_sql_comment('app:foo'), 'app:foo'
+  end
+
+  def test_bad_comments
+    assert_equal StinkingToe::Comment.escape_sql_comment('*/; DROP TABLE USERS;/*'), '; DROP TABLE USERS;'
+    assert_equal StinkingToe::Comment.escape_sql_comment('**//; DROP TABLE USERS;/*'), '; DROP TABLE USERS;'
+  end
+
+  def test_inline_annotations
+    StinkingToe.with_annotation("foo") do
+      Post.first
+    end
+    Post.first
+    assert_match %r{/\*foo\*/$}, @queries.first
+    refute_match %r{/\*foo\*/$}, @queries.last
+    # Assert we're not adding an empty comment, either
+    refute_match %r{/\*\s*\*/$}, @queries.last
+  end
+
+  def test_nested_inline_annotations
+    StinkingToe.with_annotation("foo") do
+      StinkingToe.with_annotation("bar") do
+        Post.first
+      end
+    end
+    assert_match %r{/\*foobar\*/$}, @queries.first
+  end
+
+  def test_bad_inline_annotations
+    StinkingToe.with_annotation("*/; DROP TABLE USERS;/*") do
+      Post.first
+    end
+    StinkingToe.with_annotation("**//; DROP TABLE USERS;//**") do
+      Post.first
+    end
+    assert_match %r{/\*; DROP TABLE USERS;\*/$}, @queries.first
+    assert_match %r{/\*; DROP TABLE USERS;\*/$}, @queries.last
+  end
+
+  def test_inline_annotations_are_deduped
+    StinkingToe.with_annotation("foo") do
+      ActiveRecord::Base.connection.execute "select id from posts /*foo*/"
+    end
+    assert_match %r{select id from posts /\*foo\*/ /\*application:rails\*/$}, @queries.first
+  end
+
+  def test_add_comments_to_beginning_of_query
+    StinkingToe::Comment.prepend_comment = true
+
+    ActiveRecord::Base.connection.execute "select id from posts"
+    assert_match %r{/\*application:rails\*/ select id from posts$}, @queries.first
+  ensure
+    StinkingToe::Comment.prepend_comment = nil
+  end
+
+  def teardown
+    StinkingToe.application_name = nil
+    StinkingToe::Comment.lines_to_ignore = nil
+    StinkingToe::Comment.components = [:application, :controller, :action]
+    ActiveSupport::Notifications.unsubscribe "sql.active_record"
+  end
+end

metadata

@@ -0,0 +1,182 @@
+--- !ruby/object:Gem::Specification
+name: stinkingtoe
+version: !ruby/object:Gem::Version
+  version: 1.11.1
+platform: ruby
+authors:
+- Linda Zhou
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-01-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: attach comments to your ActiveRecord queries
+email:
+- lhmzhou@github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".DS_Store"
+- ".gitignore"
+- ".ruby-version"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/stinkingtoe.rb
+- lib/stinkingtoe/comment.rb
+- lib/stinkingtoe/railtie.rb
+- lib/stinkingtoe/sidekiq_instrumentation.rb
+- stinkingtoe.gemspec
+- test/query_comments_test.rb
+homepage: https://github.com/lhmzhou
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: attach comments to your ActiveRecord queries
+test_files: []