safe-pg-migrations 1.1.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d806334c473708774d2180dbe91d2483b49f0d27b0a223a2973bc95d986d4030
-  data.tar.gz: 9b5c2d329d5cc1bd12c80944420e20eb5454e5b0a0f7fda2d6ec3fc3c3a5e042
+  metadata.gz: fdee6e752da3fbdec93e5fd5c72fb370497ddd66f1cc27f33609c2a31e364c53
+  data.tar.gz: 143a5dcbf614abed765fac78b16969d900ded5ec574f11d939d802b94d7e2586
 SHA512:
-  metadata.gz: 6786e68cce9dbd91a4633c80526a1fd63f6fbfa335d6e2b53d29b71ba0b566f9bb32169745bb13f89a059b82b0c0b21585a9bffdb9ebc751aa0e4a467f0f7934
-  data.tar.gz: 299a69f1d9413279fd61908a7d8f6eb65bd4c9912abcc1101ca8acbfee39c40d33086efa28a9f2133c0679c1ad9cdbbfe3ce84338f2175ad882b7d1ace707654
+  metadata.gz: 41c264aa05c7b8ad5fe90f7ecdc88fa700504562e69695d5fd9f4dc9ac63315fb666818554e1387251b367aed241fccff31154589f70309905e1ed1cfae90c68
+  data.tar.gz: 9386e6a8b0366387543998ec5cec42e719d2a4138d5eb52f13f6580d2a3d31e48bd438760b358beb1ab5eb32bd8598927d69bafd03756108a514e88eeb431022

data/README.md

@@ -16,6 +16,8 @@ Just drop this line in your Gemfile:
 gem 'safe-pg-migrations'
 ```
 
+**Note: Do not run migrations via PgBouncer connection if it is configured to use transactional or statement pooling modes. You must run migrations via a direct Postgres connection, or configure PgBouncer to use session pooling mode.**
+
 ## Example
 
 Consider the following migration:
@@ -61,7 +63,7 @@ Under the hood, **Safe PG Migrations** patches `ActiveRecord::Migration` and ext
 
 ## Motivation
 
-Writing a safe migration can be daunting. Numerous articles have been written on the topic and a few gems are trying to address the problem. Even for someone who has a pretty good command of Postgres, remembering all the subtleties of explicit locking is not a piece of cake.
+Writing a safe migration can be daunting. Numerous articles, [including ours](https://medium.com/doctolib/stop-worrying-about-postgresql-locks-in-your-rails-migrations-3426027e9cc9), have been written on the topic and a few gems are trying to address the problem. Even for someone who has a pretty good command of Postgres, remembering all the subtleties of explicit locking is not a piece of cake.
 
 Active Record means developers don't have to be proficient in SQL to interact with a database. In the same way, **Safe PG Migrations** was created so that developers don't have to understand the ins and outs of Postgres to write a safe migration.
 
@@ -122,7 +124,7 @@ Note: the addition of the not null constraint may timeout. In that case, you may
 
 </details>
 
-<details><summary>Safe <code>add_index</code> and <code>remove_index</code></summary>
+<details><summary id="safe_add_remove_index">Safe <code>add_index</code> and <code>remove_index</code></summary>
 
 Creating an index requires a `SHARE` lock on the target table which blocks all write on the table while the index is created (which can take some time on a large table). This is usually not practical in a live environment. Thus, **Safe PG Migrations** ensures indexes are created concurrently.
 
@@ -135,7 +137,7 @@ If you still get lock timeout while adding / removing indexes, it might be for o
 
 </details>
 
-<details><summary>safe <code>add_foreign_key</code> (and <code>add_reference</code>)</summary>
+<details><summary id="safe_add_foreign_key">safe <code>add_foreign_key</code> (and <code>add_reference</code>)</summary>
 
 Adding a foreign key requires a `SHARE ROW EXCLUSIVE` lock, which **prevent writing in the tables** while the migration is running.
 
@@ -206,9 +208,9 @@ So you can actually check that the `CREATE INDEX` statement will be performed co
 ```ruby
 SafePgMigrations.config.safe_timeout = 5.seconds # Lock and statement timeout used for all DDL operations except from CREATE / DROP INDEX
 
-SafePgMigrations.config.index_lock_timeout = 30.seconds # Lock timeout used for CREATE / DROP INDEX
+SafePgMigrations.config.blocking_activity_logger_verbose = true # Outputs the raw blocking queries on timeout. When false, outputs information about the lock instead
 
-SafePgMigrations.config.blocking_activity_logger_margin = 1.second # Delay to output blocking queries before timeout. Must be smaller than safe_timeout and index_lock_timeout
+SafePgMigrations.config.blocking_activity_logger_margin = 1.second # Delay to output blocking queries before timeout. Must be shorter than safe_timeout
 
 SafePgMigrations.config.batch_size = 1000 # Size of the batches used for backfilling when adding a column with a default value pre-PG11
 
@@ -254,3 +256,4 @@ Interesting reads:
 - [Rails migrations with no downtime](https://pedro.herokuapp.com/past/2011/7/13/rails_migrations_with_no_downtime/)
 - [Safe Operations For High Volume PostgreSQL](https://www.braintreepayments.com/blog/safe-operations-for-high-volume-postgresql/)
 - [Rails Migrations with Zero Downtime](https://blog.codeship.com/rails-migrations-zero-downtime/)
+- [Stop worrying about PostgreSQL locks in your Rails migrations](https://medium.com/doctolib/stop-worrying-about-postgresql-locks-in-your-rails-migrations-3426027e9cc9)

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

@@ -1,11 +1,13 @@
 # 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'
 require 'safe-pg-migrations/plugins/statement_insurer'
 require 'safe-pg-migrations/plugins/statement_retrier'
 require 'safe-pg-migrations/plugins/idem_potent_statements'
+require 'safe-pg-migrations/plugins/useless_statements_logger'
 
 module SafePgMigrations
   # Order matters: the bottom-most plugin will have precedence
@@ -14,6 +16,7 @@ module SafePgMigrations
     IdemPotentStatements,
     StatementRetrier,
     StatementInsurer,
+    UselessStatementsLogger,
   ].freeze
 
   class << self
@@ -48,13 +51,13 @@ module SafePgMigrations
       @alternate_connection = nil
     end
 
-    def say(*args)
+    ruby2_keywords def say(*args)
       return unless current_migration
 
       current_migration.say(*args)
     end
 
-    def say_method_call(method, *args)
+    ruby2_keywords def say_method_call(method, *args)
       say "#{method}(#{args.map(&:inspect) * ', '})", true
     end
 
@@ -78,6 +81,7 @@ module SafePgMigrations
     end
 
     def disable_ddl_transaction
+      UselessStatementsLogger.warn_useless '`disable_ddl_transaction`' if super
       true
     end
 
@@ -88,6 +92,7 @@ module SafePgMigrations
 
         safety_assured { super(*args) }
       end
+      ruby2_keywords method
     end
   end
 end

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

@@ -5,16 +5,16 @@ require 'active_support/core_ext/numeric/time'
 module SafePgMigrations
   class Configuration
     attr_accessor :safe_timeout
-    attr_accessor :index_lock_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
 
     def initialize
       self.safe_timeout = 5.seconds
-      self.index_lock_timeout = 30.seconds
       self.blocking_activity_logger_margin = 1.second
+      self.blocking_activity_logger_verbose = true
       self.batch_size = 1000
       self.retry_delay = 1.minute
       self.max_tries = 5
@@ -24,10 +24,6 @@ module SafePgMigrations
       pg_duration(safe_timeout)
     end
 
-    def pg_index_lock_timeout
-      pg_duration(index_lock_timeout)
-    end
-
     def pg_duration(duration)
       value, unit = duration.integer? ? [duration, 's'] : [(duration * 1000).to_i, 'ms']
       "#{value}#{unit}"

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

@@ -2,55 +2,64 @@
 
 module SafePgMigrations
   module BlockingActivityLogger
-    SELECT_BLOCKING_QUERIES_SQL = <<~SQL.squish
-      SELECT blocking_activity.query
-      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
+    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
 
     %i[
-      add_column remove_column add_foreign_key remove_foreign_key change_column_default
-      change_column_null create_table add_index remove_index
+      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(method) { super(*args, &block) }
+        log_blocking_queries { super(*args, &block) }
       end
+      ruby2_keywords method
     end
 
     private
 
-    def delay_before_logging(method)
-      timeout_delay =
-        if %i[add_index remove_index].include?(method)
-          SafePgMigrations.config.index_lock_timeout
-        else
-          SafePgMigrations.config.safe_timeout
-        end
+    def select_blocking_queries_sql
+      columns = SafePgMigrations.config.blocking_activity_logger_verbose ? VERBOSE_COLUMNS : FILTERED_COLUMNS
 
-      timeout_delay - SafePgMigrations.config.blocking_activity_logger_margin
+      <<~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
 
-    def log_blocking_queries(method)
+    def log_blocking_queries
+      delay_before_logging =
+        SafePgMigrations.config.safe_timeout - SafePgMigrations.config.blocking_activity_logger_margin
+
       blocking_queries_retriever_thread =
         Thread.new do
-          sleep delay_before_logging(method)
-          SafePgMigrations.alternate_connection.query_values(SELECT_BLOCKING_QUERIES_SQL % raw_connection.backend_pid)
+          sleep delay_before_logging
+          SafePgMigrations.alternate_connection.query(select_blocking_queries_sql % raw_connection.backend_pid)
         end
 
       yield
@@ -75,7 +84,7 @@ module SafePgMigrations
           "Statement was being blocked by the following #{'query'.pluralize(queries.size)}:", true
         )
         SafePgMigrations.say '', true
-        queries.each { |query| SafePgMigrations.say "  #{query}", 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',
@@ -86,5 +95,26 @@ module SafePgMigrations
 
       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
+    end
+
+    def format_start_time(start_time, reference_time = Time.now)
+      duration = (reference_time - start_time).round
+      "transaction started #{duration} #{'second'.pluralize(duration)} ago"
+    end
   end
 end

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

@@ -2,7 +2,8 @@
 
 module SafePgMigrations
   module IdemPotentStatements
-    def add_index(table_name, column_name, **options)
+    ruby2_keywords def add_index(table_name, column_name, *args)
+      options = args.last.is_a?(Hash) ? args.last : {}
       index_name = options.key?(:name) ? options[:name].to_s : index_name(table_name, index_column_names(column_name))
       return super unless index_name_exists?(table_name, index_name)
 
@@ -12,19 +13,20 @@ module SafePgMigrations
       super
     end
 
-    def add_column(table_name, column_name, type, options = {})
+    ruby2_keywords def add_column(table_name, column_name, type, *)
       return super unless column_exists?(table_name, column_name)
 
       SafePgMigrations.say("/!\\ Column '#{column_name}' already exists in '#{table_name}'. Skipping statement.", true)
     end
 
-    def remove_column(table_name, column_name, type = nil, options = {})
+    ruby2_keywords def remove_column(table_name, column_name, type = nil, *)
       return super if column_exists?(table_name, column_name)
 
       SafePgMigrations.say("/!\\ Column '#{column_name}' not found on table '#{table_name}'. Skipping statement.", true)
     end
 
-    def remove_index(table_name, options = {})
+    ruby2_keywords def remove_index(table_name, *args)
+      options = args.last.is_a?(Hash) ? args.last : {}
       index_name = options.key?(:name) ? options[:name].to_s : index_name(table_name, options)
 
       return super if index_name_exists?(table_name, index_name)
@@ -32,9 +34,10 @@ module SafePgMigrations
       SafePgMigrations.say("/!\\ Index '#{index_name}' not found on table '#{table_name}'. Skipping statement.", true)
     end
 
-    def add_foreign_key(from_table, to_table, **options)
-      options_or_to_table = options.slice(:name, :column).presence || to_table
-      return super unless foreign_key_exists?(from_table, options_or_to_table)
+    ruby2_keywords def add_foreign_key(from_table, to_table, *args)
+      options = args.last.is_a?(Hash) ? args.last : {}
+      suboptions = options.slice(:name, :column)
+      return super unless foreign_key_exists?(from_table, suboptions.present? ? nil : to_table, **suboptions)
 
       SafePgMigrations.say(
         "/!\\ Foreign key '#{from_table}' -> '#{to_table}' already exists. Skipping statement.",
@@ -42,13 +45,21 @@ module SafePgMigrations
       )
     end
 
-    def create_table(table_name, comment: nil, **options)
-      return super unless table_exists?(table_name)
+    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)
 
-      SafePgMigrations.say(
-        "/!\\ Table '#{table_name}' already exists. Skipping statement.",
-        true
-      )
+      SafePgMigrations.say "/!\\ Table '#{table_name}' already exists.", true
+
+      td = create_table_definition(table_name, *args)
+
+      yield td if block_given?
+
+      SafePgMigrations.say(td.indexes.empty? ? '-- Skipping statement' : '-- Creating indexes', true)
+
+      td.indexes.each do |column_name, index_options|
+        add_index(table_name, column_name, **index_options)
+      end
     end
 
     private

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

@@ -1,19 +1,21 @@
 # frozen_string_literal: true
 
 module SafePgMigrations
-  module StatementInsurer
+  module StatementInsurer # rubocop:disable Metrics/ModuleLength
     PG_11_VERSION_NUM = 110_000
 
-    %i[change_column_null change_column create_table].each do |method|
+    %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) }
       end
+      ruby2_keywords method
     end
 
-    def add_column(table_name, column_name, type, **options) # rubocop:disable Metrics/CyclomaticComplexity
-      need_default_value_backfill = SafePgMigrations.pg_version_num < PG_11_VERSION_NUM
+    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) if need_default_value_backfill
+      default = options.delete(:default)
       null = options.delete(:null)
 
       if !default.nil? || null == false
@@ -22,7 +24,7 @@ module SafePgMigrations
 
       super
 
-      if need_default_value_backfill && !default.nil?
+      unless default.nil?
         SafePgMigrations.say_method_call(:change_column_default, table_name, column_name, default)
         change_column_default(table_name, column_name, default)
 
@@ -36,29 +38,50 @@ module SafePgMigrations
       end
     end
 
-    def add_foreign_key(from_table, to_table, **options)
+    ruby2_keywords def add_foreign_key(from_table, to_table, *args)
+      options = args.last.is_a?(Hash) ? args.last : {}
       validate_present = options.key? :validate
       options[:validate] = false unless validate_present
+      with_setting(:statement_timeout, SafePgMigrations.config.pg_safe_timeout) do
+        super(from_table, to_table, **options)
+      end
+
+      return if validate_present
 
-      with_setting(:statement_timeout, SafePgMigrations.config.pg_safe_timeout) { super }
+      suboptions = options.slice(:name, :column)
+      without_statement_timeout { validate_foreign_key from_table, suboptions.present? ? nil : to_table, **suboptions }
+    end
 
-      options_or_to_table = options.slice(:name, :column).presence || to_table
-      without_statement_timeout { validate_foreign_key from_table, options_or_to_table } unless validate_present
+    ruby2_keywords def create_table(*)
+      with_setting(:statement_timeout, SafePgMigrations.config.pg_safe_timeout) do
+        super do |td|
+          yield td if block_given?
+          td.indexes.map! do |key, index_options|
+            index_options[:algorithm] ||= :default
+            [key, index_options]
+          end
+        end
+      end
     end
 
     def add_index(table_name, column_name, **options)
-      options[:algorithm] = :concurrently
-      SafePgMigrations.say_method_call(:add_index, table_name, column_name, options)
+      if options[:algorithm] == :default
+        options.delete :algorithm
+      else
+        options[:algorithm] = :concurrently
+      end
 
-      with_index_timeouts { super }
+      SafePgMigrations.say_method_call(:add_index, table_name, column_name, **options)
+
+      without_timeout { super(table_name, column_name, **options) }
     end
 
-    def remove_index(table_name, options = {})
-      options = { column: options } unless options.is_a?(Hash)
-      options[:algorithm] = :concurrently
-      SafePgMigrations.say_method_call(:remove_index, table_name, options)
+    ruby2_keywords def remove_index(table_name, *args)
+      options = args.last.is_a?(Hash) ? args.last : { column: args.last }
+      options[:algorithm] = :concurrently unless options.key?(:algorithm)
+      SafePgMigrations.say_method_call(:remove_index, table_name, **options)
 
-      with_index_timeouts { super }
+      without_timeout { super(table_name, **options) }
     end
 
     def backfill_column_default(table_name, column_name)
@@ -99,12 +122,12 @@ module SafePgMigrations
       with_setting(:statement_timeout, 0) { yield }
     end
 
-    def with_index_timeouts
-      without_statement_timeout do
-        with_setting(:lock_timeout, SafePgMigrations.config.pg_index_lock_timeout) do
-          yield
-        end
-      end
+    def without_lock_timeout
+      with_setting(:lock_timeout, 0) { yield }
+    end
+
+    def without_timeout
+      without_statement_timeout { without_lock_timeout { yield } }
     end
   end
 end

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

@@ -3,14 +3,14 @@
 module SafePgMigrations
   module StatementRetrier
     RETRIABLE_SCHEMA_STATEMENTS = %i[
-      add_column add_foreign_key remove_foreign_key change_column_default
-      change_column_null add_index remove_index remove_column
+      add_column add_foreign_key remove_foreign_key change_column_default change_column_null remove_column
     ].freeze
 
     RETRIABLE_SCHEMA_STATEMENTS.each do |method|
       define_method method do |*args, &block|
         retry_if_lock_timeout { super(*args, &block) }
       end
+      ruby2_keywords method
     end
 
     private

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SafePgMigrations
+  module UselessStatementsLogger
+    class << self
+      ruby2_keywords def warn_useless(action, link = nil, *args)
+        SafePgMigrations.say "/!\\ No need to explicitly use #{action}, safe-pg-migrations does it for you", *args
+        SafePgMigrations.say "\t see #{link} for more details", *args if link
+      end
+    end
+
+    ruby2_keywords def add_index(*args)
+      options = args.last.is_a?(Hash) ? args.last : {}
+      warn_for_index(**options)
+      super
+    end
+
+    ruby2_keywords def remove_index(table_name, *args)
+      options = args.last.is_a?(Hash) ? args.last : {}
+      warn_for_index(**options) unless options.empty?
+      super
+    end
+
+    ruby2_keywords def add_foreign_key(*args)
+      options = args.last.is_a?(Hash) ? args.last : {}
+      if options[:validate] == false
+        UselessStatementsLogger.warn_useless '`validate: :false`', 'https://github.com/doctolib/safe-pg-migrations#safe_add_foreign_key'
+      end
+      super
+    end
+
+    def warn_for_index(**options)
+      return unless options[:algorithm] == :concurrently
+
+      UselessStatementsLogger.warn_useless '`algorithm: :concurrently`', 'https://github.com/doctolib/safe-pg-migrations#safe_add_remove_index'
+    end
+  end
+end

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

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: safe-pg-migrations
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Matthieu Prat
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-03 00:00:00.000000000 Z
+date: 2021-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -39,6 +39,20 @@ dependencies:
     - - ">="
       - !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
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -166,6 +180,7 @@ files:
 - lib/safe-pg-migrations/plugins/idem_potent_statements.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/railtie.rb
 - lib/safe-pg-migrations/version.rb
@@ -182,6 +197,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ">="
     - !ruby/object:Gem::Version
       version: '2.5'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="