safe-pg-migrations 1.4.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d05d2e6c8647af8e618652235043dfde1b104065e71113f9f55c25117dd6ab6
-  data.tar.gz: 1f67d82d62855e6566f39c92b3cfdf4e9d6f68cc2bd0b9105c3e61ba32fd8ddf
+  metadata.gz: 878eca03499c2fa44ef8e046f5828b2b0978e692ade4440f9489a29889a99b49
+  data.tar.gz: 88a9aa0adf58a3a716565d8a3482839ffd546570ab7238f67daecb0c2396a152
 SHA512:
-  metadata.gz: daeed81cfc524ad80427179930e86b9ba71d4743e390dc8c5ce805d01ea3fdbb9866c30707f76d6b7578c9370b9761564b784813f165c52e1512afdffd9d74ed
-  data.tar.gz: cb4346bcaf47707bb811cefcace498683f63a7854d80c47487dac462b1e79ec62ee702a75fd18985b114a0ab4b69a8863274eb2af86517f166f50795dff3cc55
+  metadata.gz: 15cd514d22cf2b5f182faf16a50a4775fa528754357eeeaa0c81f2f93bf25d12375ae2c7742e8e762addd01ae3b5aeeedb09c758e9e6da063f4b0beca8544c45
+  data.tar.gz: d930ac0e741025ea05743a2ad8f6da979932f67cd9e93e13c64b22581bb073b164212144d152f9a0729a93e49098cb9279caba57a91b746502ccb259cb18bbcb

data/README.md

@@ -6,9 +6,9 @@ ActiveRecord migrations for Postgres made safe.
 
 ## Requirements
 
-- Ruby 2.5+
-- Rails 5.2+
-- PostgreSQL 9.3+
+- Ruby 2.7+
+- Rails 6.0+
+- PostgreSQL 11.7+
 
 ## Usage
 
@@ -25,43 +25,46 @@ gem 'safe-pg-migrations'
 Consider the following migration:
 
 ```rb
-class AddAdminToUsers < ActiveRecord::Migration[5.2]
+class AddPatientRefToAppointments < ActiveRecord::Migration[6.0]
   def change
-    add_column :users, :admin, :boolean, default: false, null: false
+    add_reference :appointments, :patient
   end
 end
 ```
 
-If the `users` table is large, running this migration on a live Postgres 9 database will likely cause downtime. **Safe PG Migrations** hooks into Active Record so that the following gets executed instead:
+If the `users` table is large, running this migration will likely cause downtime. **Safe PG Migrations** hooks into Active Record so that the following gets executed instead:
 
 ```rb
-class AddAdminToUsers < ActiveRecord::Migration[5.2]
+class AddPatientRefToAppointments < ActiveRecord::Migration[6.0]
   # Do not wrap the migration in a transaction so that locks are held for a shorter time.
   disable_ddl_transaction!
 
   def change
     # Lower Postgres' lock timeout to avoid statement queueing. Acts like a seatbelt.
-    execute "SET lock_timeout TO '5s'" # The lock_timeout duration is customizable.
+    execute("SET lock_timeout TO '5s'")
 
-    # Add the column without the default value and the not-null constraint.
-    add_column :users, :admin, :boolean
+    # Lower Postgres' statement timeout to avoid too long transactions. Acts like a seatbelt.
+    execute("SET statement_timeout TO '5s'")
+    add_column :appointments, :patient_id, :bigint
 
-    # Set the column's default value.
-    change_column_default :users, :admin, false
+    # add_index using the concurrent algorithm, to avoid locking the tables
+    add_index :appointments, :patient_id, algorithm: :concurrently
 
-    # Backfill the column in batches.
-    User.in_batches.update_all(admin: false)
+    # add_foreign_key without validation, to avoid locking the table for too long
+    execute("SET statement_timeout TO '5s'")
+    add_foreign_key :appointments, :patients, validate: false
 
-    # Add the not-null constraint. Beforehand, set a short statement timeout so that
-    # Postgres does not spend too much time performing the full table scan to verify
-    # the column contains no nulls.
-    execute "SET statement_timeout TO '5s'"
-    change_column_null :users, :admin, false
+    execute("SET statement_timeout TO '0'")
+
+    # validate the foreign key separately, it avoids taking a lock on the entire tables
+    validate_foreign_key :appointments, :patients
+    
+    # we also need to set timeouts to their initial values if needed
   end
 end
 ```
 
-Under the hood, **Safe PG Migrations** patches `ActiveRecord::Migration` and extends `ActiveRecord::Base.connection` to make potentially dangerous methods—like `add_column`—safe.
+Under the hood, **Safe PG Migrations** patches `ActiveRecord::Migration` and extends `ActiveRecord::Base.connection` to make potentially dangerous methods—like `add_reference`—safe.
 
 ## Motivation
 
@@ -108,22 +111,6 @@ add_column :users, :created_at, default: 'clock_timestamp()'
 ```
 PG will still needs to update every row of the table, and will most likely statement timeout for big table. In this case, your best bet is to add the column without default, set the default, and backfill existing rows.
 
-<blockquote>
-
-**Note: Pre-postgres 11**
-Adding a column with a default value and a not-null constraint is [dangerous](https://wework.github.io/data/2015/11/05/add-columns-with-default-values-to-large-tables-in-rails-postgres/).
-
-**Safe PG Migrations** makes it safe by:
-
-1.  Adding the column without the default value and the not null constraint,
-2.  Then set the default value on the column,
-3.  Then backfilling the column,
-4.  And then adding the not null constraint with a short statement timeout.
-
-Note: the addition of the not null constraint may timeout. In that case, you may want to add the not-null constraint as initially not valid and validate it in a separate statement. See [Adding a not-null constraint on Postgres with minimal locking](https://medium.com/doctolib-engineering/adding-a-not-null-constraint-on-pg-faster-with-minimal-locking-38b2c00c4d1c).
-
-</blockquote>
-
 </details>
 
 <details><summary id="safe_add_remove_index">Safe <code>add_index</code> and <code>remove_index</code></summary>

data/lib/safe-pg-migrations/base.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'ruby2_keywords'
 require 'safe-pg-migrations/configuration'
 require 'safe-pg-migrations/plugins/verbose_sql_logger'
 require 'safe-pg-migrations/plugins/blocking_activity_logger'
@@ -8,7 +7,9 @@ require 'safe-pg-migrations/plugins/statement_insurer'
 require 'safe-pg-migrations/plugins/statement_retrier'
 require 'safe-pg-migrations/plugins/idempotent_statements'
 require 'safe-pg-migrations/plugins/useless_statements_logger'
-require 'safe-pg-migrations/plugins/legacy_active_record_support'
+require 'safe-pg-migrations/polyfills/satisfied_helper'
+require 'safe-pg-migrations/polyfills/index_definition_polyfill'
+require 'safe-pg-migrations/polyfills/verbose_query_logs_polyfill'
 
 module SafePgMigrations
   # Order matters: the bottom-most plugin will have precedence
@@ -18,30 +19,25 @@ module SafePgMigrations
     StatementRetrier,
     StatementInsurer,
     UselessStatementsLogger,
-    LegacyActiveRecordSupport,
+    Polyfills::IndexDefinitionPolyfill,
   ].freeze
 
   class << self
-    attr_reader :current_migration, :pg_version_num
+    attr_reader :current_migration
 
-    def setup_and_teardown(migration, connection)
-      @pg_version_num = get_pg_version_num(connection)
+    def setup_and_teardown(migration, connection, &block)
       @alternate_connection = nil
       @current_migration = migration
       stdout_sql_logger = VerboseSqlLogger.new.setup if verbose?
       PLUGINS.each { |plugin| connection.extend(plugin) }
 
-      connection.with_setting(:lock_timeout, SafePgMigrations.config.pg_safe_timeout) { yield }
+      connection.with_setting(:lock_timeout, SafePgMigrations.config.pg_safe_timeout, &block)
     ensure
       close_alternate_connection
       @current_migration = nil
       stdout_sql_logger&.teardown
     end
 
-    def get_pg_version_num(connection)
-      connection.query_value('SHOW server_version_num').to_i
-    end
-
     def alternate_connection
       @alternate_connection ||= ActiveRecord::Base.connection_pool.send(:new_connection)
     end
@@ -64,6 +60,9 @@ module SafePgMigrations
     end
 
     def verbose?
+      unless current_migration.class._safe_pg_migrations_verbose.nil?
+        return current_migration.class._safe_pg_migrations_verbose
+      end
       return ENV['SAFE_PG_MIGRATIONS_VERBOSE'] == '1' if ENV['SAFE_PG_MIGRATIONS_VERBOSE']
       return Rails.env.production? if defined?(Rails)
 
@@ -76,6 +75,14 @@ module SafePgMigrations
   end
 
   module Migration
+    module ClassMethods
+      attr_accessor :_safe_pg_migrations_verbose
+
+      def safe_pg_migrations_verbose(verbose)
+        @_safe_pg_migrations_verbose = verbose
+      end
+    end
+
     def exec_migration(connection, direction)
       SafePgMigrations.setup_and_teardown(self, connection) do
         super(connection, direction)

data/lib/safe-pg-migrations/configuration.rb

@@ -4,12 +4,8 @@ require 'active_support/core_ext/numeric/time'
 
 module SafePgMigrations
   class Configuration
-    attr_accessor :safe_timeout
-    attr_accessor :blocking_activity_logger_margin
-    attr_accessor :blocking_activity_logger_verbose
-    attr_accessor :batch_size
-    attr_accessor :retry_delay
-    attr_accessor :max_tries
+    attr_accessor :safe_timeout, :blocking_activity_logger_margin, :blocking_activity_logger_verbose, :batch_size,
+                  :retry_delay, :max_tries
 
     def initialize
       self.safe_timeout = 5.seconds

data/lib/safe-pg-migrations/helpers/blocking_activity_formatter.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module SafePgMigrations
+  module Helpers
+    module BlockingActivityFormatter
+      def log_queries(queries)
+        if queries.empty?
+          SafePgMigrations.say 'Could not find any blocking query.', true
+        else
+          SafePgMigrations.say(
+            "Statement was being blocked by the following #{'query'.pluralize(queries.size)}:",
+            true
+          )
+          SafePgMigrations.say '', true
+          output_blocking_queries(queries)
+          SafePgMigrations.say(
+            'Beware, some of those queries might run in a transaction. In this case the locking query might be ' \
+            'located elsewhere in the transaction',
+            true
+          )
+          SafePgMigrations.say '', true
+        end
+      end
+
+      private
+
+      def output_blocking_queries(queries)
+        if SafePgMigrations.config.blocking_activity_logger_verbose
+          queries.each do |pid, query, start_time|
+            SafePgMigrations.say "Query with pid #{pid || 'null'} started #{format_start_time start_time}:  #{query}",
+                                 true
+          end
+        else
+          output_confidentially_blocking_queries(queries)
+        end
+      end
+
+      def output_confidentially_blocking_queries(queries)
+        queries.each do |start_time, locktype, mode, pid, transactionid|
+          SafePgMigrations.say(
+            "Query with pid #{pid || 'null'} " \
+            "started #{format_start_time(start_time)}: " \
+            "lock type: #{locktype || 'null'}, " \
+            "lock mode: #{mode || 'null'}, " \
+            "lock transactionid: #{transactionid || 'null'}",
+            true
+          )
+        end
+      end
+
+      def format_start_time(start_time, reference_time = Time.now)
+        start_time = Time.parse(start_time) unless start_time.is_a? Time
+
+        duration = (reference_time - start_time).round
+        "#{duration} #{'second'.pluralize(duration)} ago"
+      end
+    end
+  end
+end

data/lib/safe-pg-migrations/helpers/blocking_activity_selector.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module SafePgMigrations
+  module Helpers
+    module BlockingActivitySelector
+      FILTERED_COLUMNS = %w[
+        blocked_activity.xact_start
+        blocked_locks.locktype
+        blocked_locks.mode
+        blocking_activity.pid
+        blocked_locks.transactionid
+      ].freeze
+
+      VERBOSE_COLUMNS = %w[
+        blocking_activity.pid
+        blocking_activity.query
+        blocked_activity.xact_start
+      ].freeze
+
+      def select_blocking_queries_sql
+        columns =
+          (
+            if SafePgMigrations.config.blocking_activity_logger_verbose
+              VERBOSE_COLUMNS
+            else
+              FILTERED_COLUMNS
+            end
+          )
+
+        <<~SQL.squish
+          SELECT #{columns.join(', ')}
+          FROM pg_catalog.pg_locks           blocked_locks
+          JOIN pg_catalog.pg_stat_activity   blocked_activity
+            ON blocked_activity.pid = blocked_locks.pid
+          JOIN pg_catalog.pg_locks           blocking_locks
+            ON blocking_locks.locktype = blocked_locks.locktype
+            AND blocking_locks.DATABASE      IS NOT DISTINCT FROM blocked_locks.DATABASE
+            AND blocking_locks.relation      IS NOT DISTINCT FROM blocked_locks.relation
+            AND blocking_locks.page          IS NOT DISTINCT FROM blocked_locks.page
+            AND blocking_locks.tuple         IS NOT DISTINCT FROM blocked_locks.tuple
+            AND blocking_locks.virtualxid    IS NOT DISTINCT FROM blocked_locks.virtualxid
+            AND blocking_locks.transactionid IS NOT DISTINCT FROM blocked_locks.transactionid
+            AND blocking_locks.classid       IS NOT DISTINCT FROM blocked_locks.classid
+            AND blocking_locks.objid         IS NOT DISTINCT FROM blocked_locks.objid
+            AND blocking_locks.objsubid      IS NOT DISTINCT FROM blocked_locks.objsubid
+            AND blocking_locks.pid != blocked_locks.pid
+          JOIN pg_catalog.pg_stat_activity   blocking_activity
+            ON blocking_activity.pid = blocking_locks.pid
+          WHERE blocked_locks.pid = %d
+        SQL
+      end
+    end
+  end
+end

data/lib/safe-pg-migrations/plugins/blocking_activity_logger.rb

@@ -1,65 +1,62 @@
 # frozen_string_literal: true
 
+require_relative '../helpers/blocking_activity_formatter'
+require_relative '../helpers/blocking_activity_selector'
+
 module SafePgMigrations
-  module BlockingActivityLogger # rubocop:disable Metrics/ModuleLength
-    FILTERED_COLUMNS = %w[
-      blocked_activity.xact_start
-      blocked_locks.locktype
-      blocked_locks.mode
-      blocking_activity.pid
-      blocked_locks.transactionid
-    ].freeze
-
-    VERBOSE_COLUMNS = %w[
-      blocking_activity.query
-      blocked_activity.xact_start
-    ].freeze
+  module BlockingActivityLogger
+    include ::SafePgMigrations::Helpers::BlockingActivityFormatter
+    include ::SafePgMigrations::Helpers::BlockingActivitySelector
 
     %i[
-      add_column remove_column add_foreign_key remove_foreign_key change_column_default change_column_null create_table
+      add_column
+      remove_column
+      add_foreign_key
+      remove_foreign_key
+      change_column_default
+      change_column_null
+      create_table
     ].each do |method|
       define_method method do |*args, &block|
-        log_blocking_queries { super(*args, &block) }
+        log_blocking_queries_after_lock { super(*args, &block) }
       end
       ruby2_keywords method
     end
 
-    private
+    %i[add_index remove_index].each do |method|
+      define_method method do |*args, **options, &block|
+        return super(*args, **options, &block) if options[:algorithm] != :concurrently
 
-    def select_blocking_queries_sql
-      columns = SafePgMigrations.config.blocking_activity_logger_verbose ? VERBOSE_COLUMNS : FILTERED_COLUMNS
-
-      <<~SQL.squish
-        SELECT #{columns.join(', ')}
-        FROM pg_catalog.pg_locks           blocked_locks
-        JOIN pg_catalog.pg_stat_activity   blocked_activity
-          ON blocked_activity.pid = blocked_locks.pid
-        JOIN pg_catalog.pg_locks           blocking_locks
-          ON blocking_locks.locktype = blocked_locks.locktype
-          AND blocking_locks.DATABASE      IS NOT DISTINCT FROM blocked_locks.DATABASE
-          AND blocking_locks.relation      IS NOT DISTINCT FROM blocked_locks.relation
-          AND blocking_locks.page          IS NOT DISTINCT FROM blocked_locks.page
-          AND blocking_locks.tuple         IS NOT DISTINCT FROM blocked_locks.tuple
-          AND blocking_locks.virtualxid    IS NOT DISTINCT FROM blocked_locks.virtualxid
-          AND blocking_locks.transactionid IS NOT DISTINCT FROM blocked_locks.transactionid
-          AND blocking_locks.classid       IS NOT DISTINCT FROM blocked_locks.classid
-          AND blocking_locks.objid         IS NOT DISTINCT FROM blocked_locks.objid
-          AND blocking_locks.objsubid      IS NOT DISTINCT FROM blocked_locks.objsubid
-          AND blocking_locks.pid != blocked_locks.pid
-        JOIN pg_catalog.pg_stat_activity   blocking_activity
-          ON blocking_activity.pid = blocking_locks.pid
-        WHERE blocked_locks.pid = %d
-      SQL
+        log_blocking_queries_loop { super(*args, **options, &block) }
+      end
     end
 
-    def log_blocking_queries
-      delay_before_logging =
-        SafePgMigrations.config.safe_timeout - SafePgMigrations.config.blocking_activity_logger_margin
+    private
+
+    def log_blocking_queries_loop
+      blocking_queries_retriever_thread =
+        Thread.new do
+          loop do
+            sleep SafePgMigrations.config.retry_delay
+
+            log_queries SafePgMigrations.alternate_connection.query(
+              select_blocking_queries_sql % raw_connection.backend_pid
+            )
+          end
+        end
+
+      yield
+
+      blocking_queries_retriever_thread.kill
+    end
 
+    def log_blocking_queries_after_lock
       blocking_queries_retriever_thread =
         Thread.new do
           sleep delay_before_logging
-          SafePgMigrations.alternate_connection.query(select_blocking_queries_sql % raw_connection.backend_pid)
+          SafePgMigrations.alternate_connection.query(
+            select_blocking_queries_sql % raw_connection.backend_pid
+          )
         end
 
       yield
@@ -71,51 +68,25 @@ module SafePgMigrations
         begin
           blocking_queries_retriever_thread.value
         rescue StandardError => e
-          SafePgMigrations.say("Error while retrieving blocking queries: #{e}", true)
+          SafePgMigrations.say(
+            "Error while retrieving blocking queries: #{e}",
+            true
+          )
           nil
         end
 
-      raise if queries.nil?
-
-      if queries.empty?
-        SafePgMigrations.say 'Could not find any blocking query.', true
-      else
-        SafePgMigrations.say(
-          "Statement was being blocked by the following #{'query'.pluralize(queries.size)}:", true
-        )
-        SafePgMigrations.say '', true
-        output_blocking_queries(queries)
-        SafePgMigrations.say(
-          'Beware, some of those queries might run in a transaction. In this case the locking query might be '\
-          'located elsewhere in the transaction',
-          true
-        )
-        SafePgMigrations.say '', true
-      end
+      log_queries queries unless queries.nil?
 
       raise
     end
 
-    def output_blocking_queries(queries)
-      if SafePgMigrations.config.blocking_activity_logger_verbose
-        queries.each { |query, start_time| SafePgMigrations.say "#{format_start_time start_time}:  #{query}", true }
-      else
-        queries.each do |start_time, locktype, mode, pid, transactionid|
-          SafePgMigrations.say(
-            "#{format_start_time(start_time)}: lock type: #{locktype || 'null'}, " \
-              "lock mode: #{mode || 'null'}, " \
-              "lock pid: #{pid || 'null'}, " \
-              "lock transactionid: #{transactionid || 'null'}",
-            true
-          )
-        end
-      end
+    def delay_before_logging
+      SafePgMigrations.config.safe_timeout -
+        SafePgMigrations.config.blocking_activity_logger_margin
     end
 
-    def format_start_time(start_time, reference_time = Time.now)
-      start_time = Time.parse(start_time) unless start_time.is_a? Time
-      duration = (reference_time - start_time).round
-      "transaction started #{duration} #{'second'.pluralize(duration)} ago"
+    def delay_before_retry
+      SafePgMigrations.config.blocking_activity_logger_margin + SafePgMigrations.config.retry_delay
     end
   end
 end

data/lib/safe-pg-migrations/plugins/idempotent_statements.rb

@@ -53,6 +53,16 @@ module SafePgMigrations
       )
     end
 
+    def remove_foreign_key(from_table, to_table = nil, **options)
+      return super if foreign_key_exists?(from_table, to_table, **options)
+
+      reference_name = to_table || options[:to_table] || options[:column] || options[:name]
+      SafePgMigrations.say(
+        "/!\\ Foreign key '#{from_table}' -> '#{reference_name}' does not exist. Skipping statement.",
+        true
+      )
+    end
+
     ruby2_keywords def create_table(table_name, *args)
       options = args.last.is_a?(Hash) ? args.last : {}
       return super if options[:force] || !table_exists?(table_name)

data/lib/safe-pg-migrations/plugins/statement_insurer.rb

@@ -2,8 +2,6 @@
 
 module SafePgMigrations
   module StatementInsurer
-    PG_11_VERSION_NUM = 110_000
-
     %i[change_column_null change_column].each do |method|
       define_method method do |*args, &block|
         with_setting(:statement_timeout, SafePgMigrations.config.pg_safe_timeout) { super(*args, &block) }
@@ -11,33 +9,6 @@ module SafePgMigrations
       ruby2_keywords method
     end
 
-    ruby2_keywords def add_column(table_name, column_name, type, *args) # rubocop:disable Metrics/CyclomaticComplexity
-      options = args.last.is_a?(Hash) ? args.last : {}
-      return super if SafePgMigrations.pg_version_num >= PG_11_VERSION_NUM
-
-      default = options.delete(:default)
-      null = options.delete(:null)
-
-      if !default.nil? || null == false
-        SafePgMigrations.say_method_call(:add_column, table_name, column_name, type, options)
-      end
-
-      super
-
-      unless default.nil?
-        SafePgMigrations.say_method_call(:change_column_default, table_name, column_name, default)
-        change_column_default(table_name, column_name, default)
-
-        SafePgMigrations.say_method_call(:backfill_column_default, table_name, column_name)
-        backfill_column_default(table_name, column_name)
-      end
-
-      if null == false # rubocop:disable Style/GuardClause
-        SafePgMigrations.say_method_call(:change_column_null, table_name, column_name, null)
-        change_column_null(table_name, column_name, null)
-      end
-    end
-
     ruby2_keywords def add_foreign_key(from_table, to_table, *args)
       options = args.last.is_a?(Hash) ? args.last : {}
       validate_present = options.key? :validate
@@ -64,7 +35,9 @@ module SafePgMigrations
       end
     end
 
-    def add_index(table_name, column_name, **options)
+    ruby2_keywords def add_index(table_name, column_name, *args_options)
+      options = args_options.last.is_a?(Hash) ? args_options.last : {}
+
       if options[:algorithm] == :default
         options.delete :algorithm
       else
@@ -84,15 +57,6 @@ module SafePgMigrations
       without_timeout { super(table_name, **options) }
     end
 
-    def backfill_column_default(table_name, column_name)
-      model = Class.new(ActiveRecord::Base) { self.table_name = table_name }
-      quoted_column_name = quote_column_name(column_name)
-
-      model.in_batches(of: SafePgMigrations.config.batch_size).each do |relation|
-        relation.update_all("#{quoted_column_name} = DEFAULT")
-      end
-    end
-
     def with_setting(key, value)
       old_value = query_value("SHOW #{key}")
       execute("SET #{key} TO #{quote(value)}")
@@ -109,16 +73,16 @@ module SafePgMigrations
       end
     end
 
-    def without_statement_timeout
-      with_setting(:statement_timeout, 0) { yield }
+    def without_statement_timeout(&block)
+      with_setting(:statement_timeout, 0, &block)
     end
 
-    def without_lock_timeout
-      with_setting(:lock_timeout, 0) { yield }
+    def without_lock_timeout(&block)
+      with_setting(:lock_timeout, 0, &block)
     end
 
-    def without_timeout
-      without_statement_timeout { without_lock_timeout { yield } }
+    def without_timeout(&block)
+      without_statement_timeout { without_lock_timeout(&block) }
     end
   end
 end

data/lib/safe-pg-migrations/plugins/verbose_sql_logger.rb

@@ -4,7 +4,7 @@ module SafePgMigrations
   class VerboseSqlLogger
     def setup
       @activerecord_logger_was = ActiveRecord::Base.logger
-      @verbose_query_logs_was = ActiveRecord::Base.verbose_query_logs
+      @verbose_query_logs_was = Polyfills::VerboseQueryLogsPolyfill.verbose_query_logs
       @colorize_logging_was = ActiveRecord::LogSubscriber.colorize_logging
 
       disable_marginalia if defined?(Marginalia)
@@ -13,12 +13,12 @@ module SafePgMigrations
       ActiveRecord::Base.logger = stdout_logger
       ActiveRecord::LogSubscriber.colorize_logging = colorize_logging?
       # Do not output caller method, we know it is coming from the migration
-      ActiveRecord::Base.verbose_query_logs = false
+      Polyfills::VerboseQueryLogsPolyfill.verbose_query_logs = false
       self
     end
 
     def teardown
-      ActiveRecord::Base.verbose_query_logs = @verbose_query_logs_was
+      Polyfills::VerboseQueryLogsPolyfill.verbose_query_logs = @verbose_query_logs_was
       ActiveRecord::LogSubscriber.colorize_logging = @colorize_logging_was
       ActiveRecord::Base.logger = @activerecord_logger_was
       enable_marginalia if defined?(Marginalia)

data/lib/safe-pg-migrations/polyfills/index_definition_polyfill.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SafePgMigrations
+  module Polyfills
+    module IndexDefinitionPolyfill
+      include SatisfiedHelper
+
+      protected
+
+      IndexDefinition = Struct.new(:table, :name)
+
+      def index_definition(table_name, column_name, **options)
+        return super(table_name, column_name, **options) if satisfied? '>=6.1.0'
+
+        index_name = options.key?(:name) ? options[:name].to_s : index_name(table_name, index_column_names(column_name))
+        validate_index_length!(table_name, index_name, options.fetch(:internal, false))
+
+        IndexDefinition.new(table_name, index_name)
+      end
+    end
+  end
+end

data/lib/safe-pg-migrations/polyfills/satisfied_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SafePgMigrations
+  module Polyfills
+    module SatisfiedHelper
+      private
+
+      def satisfied?(version)
+        Gem::Requirement.new(version).satisfied_by? Gem::Version.new(::ActiveRecord::VERSION::STRING)
+      end
+    end
+  end
+end

data/lib/safe-pg-migrations/polyfills/verbose_query_logs_polyfill.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module SafePgMigrations
+  module Polyfills
+    module VerboseQueryLogsPolyfill
+      class << self
+        include SatisfiedHelper
+
+        def verbose_query_logs
+          return ActiveRecord.verbose_query_logs if satisfied? '>=7.0.0'
+
+          ActiveRecord::Base.verbose_query_logs
+        end
+
+        def verbose_query_logs=(value)
+          if satisfied? '>=7.0.0'
+            ActiveRecord.verbose_query_logs = value
+            return
+          end
+
+          ActiveRecord::Base.verbose_query_logs = value
+        end
+      end
+    end
+  end
+end

data/lib/safe-pg-migrations/railtie.rb

@@ -7,6 +7,7 @@ module SafePgMigrations
     initializer 'safe_pg_migrations.insert_into_active_record' do
       ActiveSupport.on_load :active_record do
         ActiveRecord::Migration.prepend(SafePgMigrations::Migration)
+        ActiveRecord::Migration.singleton_class.prepend(SafePgMigrations::Migration::ClassMethods)
       end
     end
   end

data/lib/safe-pg-migrations/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SafePgMigrations
-  VERSION = '1.4.1'
+  VERSION = '2.0.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: safe-pg-migrations
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Matthieu Prat
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-01 00:00:00.000000000 Z
+date: 2023-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -18,42 +18,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
-- !ruby/object:Gem::Dependency
-  name: ruby2_keywords
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.0.4
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.0.4
+        version: '6.0'
 description: Make your PG migrations safe.
 email:
 executables: []
@@ -65,13 +51,17 @@ files:
 - lib/safe-pg-migrations.rb
 - lib/safe-pg-migrations/base.rb
 - lib/safe-pg-migrations/configuration.rb
+- lib/safe-pg-migrations/helpers/blocking_activity_formatter.rb
+- lib/safe-pg-migrations/helpers/blocking_activity_selector.rb
 - lib/safe-pg-migrations/plugins/blocking_activity_logger.rb
 - lib/safe-pg-migrations/plugins/idempotent_statements.rb
-- lib/safe-pg-migrations/plugins/legacy_active_record_support.rb
 - lib/safe-pg-migrations/plugins/statement_insurer.rb
 - lib/safe-pg-migrations/plugins/statement_retrier.rb
 - lib/safe-pg-migrations/plugins/useless_statements_logger.rb
 - lib/safe-pg-migrations/plugins/verbose_sql_logger.rb
+- lib/safe-pg-migrations/polyfills/index_definition_polyfill.rb
+- lib/safe-pg-migrations/polyfills/satisfied_helper.rb
+- lib/safe-pg-migrations/polyfills/verbose_query_logs_polyfill.rb
 - lib/safe-pg-migrations/railtie.rb
 - lib/safe-pg-migrations/version.rb
 homepage: https://github.com/doctolib/safe-pg-migrations
@@ -83,6 +73,7 @@ metadata:
   mailing_list_uri: https://doctolib.engineering/engineering-news-ruby-rails-react
   source_code_uri: https://github.com/doctolib/safe-pg-migrations
   contributors_uri: https://github.com/doctolib/safe-pg-migrations/graphs/contributors
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -91,18 +82,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
-  - - "<"
-    - !ruby/object:Gem::Version
-      version: '4'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.7.3
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Make your PG migrations safe.

data/lib/safe-pg-migrations/plugins/legacy_active_record_support.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module SafePgMigrations
-  module LegacyActiveRecordSupport
-    ruby2_keywords def validate_foreign_key(from_table, to_table = nil, **options)
-      return super(from_table, to_table || options) unless satisfied? '>=6.0.0'
-
-      super(from_table, to_table, **options)
-    end
-
-    ruby2_keywords def foreign_key_exists?(from_table, to_table = nil, **options)
-      return super(from_table, to_table || options) unless satisfied? '>=6.0.0'
-
-      super(from_table, to_table, **options)
-    end
-
-    protected
-
-    IndexDefinition = Struct.new(:table, :name)
-
-    def index_definition(table_name, column_name, **options)
-      return super(table_name, column_name, **options) if satisfied? '>=6.1.0'
-
-      index_name = options.key?(:name) ? options[:name].to_s : index_name(table_name, index_column_names(column_name))
-      validate_index_length!(table_name, index_name, options.fetch(:internal, false))
-
-      IndexDefinition.new(table_name, index_name)
-    end
-
-    private
-
-    def satisfied?(version)
-      Gem::Requirement.new(version).satisfied_by? Gem::Version.new(::ActiveRecord::VERSION::STRING)
-    end
-  end
-end