online_migrations 0.35.0 → 0.36.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a84bdeb495a3d25432c6ae97d4c46777517ae3bbcf01359020d400ad8f16f30
-  data.tar.gz: 935d3b38b096fcdb222a89065d7c10023a8b85a6009065d73a1df9bb92c2b0f8
+  metadata.gz: c3d28d3f9893b7c26240f94069032fa65ede6b14a1fb79b8c205111b8eedd934
+  data.tar.gz: da807a14d87705650c05bb7d3151129c534a3c50344b60d0e8e865cdecaa04b5
 SHA512:
-  metadata.gz: f2c578a25081bb86cafc2851cb818c40e819363d40bdac2a6f4cde634f71a8dc3a90909e4dbf10bf0fb6df61e1d979f4d581982650eec3834715baa8e5888832
-  data.tar.gz: 01377b6bcdbe0b601a45b53a52a99746e443d60c5ca513e2312322c81718e4a995fde32ee78a45554fe155878391f6a885fdef50bdea4d4619a4e10799bab295
+  metadata.gz: e8101340c889e837247992f15201b6d1065ae9ea00493f245aad1fe092a7dd2def02965882a5cd29acb9af21504959fd8bbfd95c0f48f911af284ae8fa87baee
+  data.tar.gz: 916c40fec0d7bfe7d08d7402e13ad2b56989921074f566474aeef0280579064ea92377a5b621c427b64205ecf098f3868c104be5772e3a5dd76b68a76f1a16e0

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## master (unreleased)
 
+## 0.36.1 (2026-09-23)
+
+- Fix compatibility with future Rails 8.2
+- Fix pausing already paused background data migrations
+
+## 0.36.0 (2026-07-20)
+
+- Serialize to JSON `cursor` value for background data migrations
+
+    Note: Run `bin/rails generate online_migrations:upgrade` if using background migrations.
+
+- Do not consider running background migrations as stuck
+- Do not automatically retry stuck background migrations
+
 ## 0.35.0 (2026-07-01)
 
 - Drop support for Ruby < 3.3

data/README.md

@@ -342,6 +342,8 @@ during writes works automatically). For most column type changes, this does not
 
    ```ruby
    class CleanupChangeFilesSizeType < ActiveRecord::Migration[8.0]
+     disable_ddl_transaction!
+
      def up
        cleanup_column_type_change :files, :size
      end

data/lib/generators/online_migrations/templates/background_data_migrations_convert_cursor.rb.tt

@@ -0,0 +1,9 @@
+class BackgroundDataMigrationsConvertCursor < <%= migration_parent %>
+  def change
+    up_only do
+      OnlineMigrations::DataMigrations::Migration.find_each do |migration|
+        OnlineMigrations::DataMigrations::Migration.where(id: migration.id).update_all(cursor: migration.cursor)
+      end
+    end
+  end
+end

data/lib/generators/online_migrations/upgrade_generator.rb

@@ -57,6 +57,8 @@ module OnlineMigrations
           migrations << "background_migrations_change_status_default"
         end
 
+        migrations << "background_data_migrations_convert_cursor"
+
         migrations
       end
 

data/lib/online_migrations/background_data_migrations/migration.rb

@@ -52,6 +52,8 @@ module OnlineMigrations
 
       enum :status, STATUSES.index_with(&:to_s)
 
+      serialize :cursor, coder: JSON
+
       validates :migration_name, presence: true
       validates :arguments, uniqueness: { scope: [:migration_name, :shard] }
 
@@ -66,6 +68,13 @@ module OnlineMigrations
         migration_name.sub(/^(::)?#{namespace}::/, "")
       end
 
+      # TODO: delete in some future version
+      def cursor
+        self[:cursor]
+      rescue JSON::ParserError
+        cursor_before_type_cast
+      end
+
       def migration_name=(class_name)
         class_name = class_name.name if class_name.is_a?(Class)
         write_attribute(:migration_name, self.class.normalize_migration_name(class_name))
@@ -111,13 +120,13 @@ module OnlineMigrations
       end
 
       # Returns whether a migration is stuck, which is defined as having a status of
-      # running, cancelling or pausing, and not having been updated in the last 5 minutes.
+      # cancelling or pausing, and not having been updated in the last 5 minutes.
       #
       # @return [Boolean] whether the migration is stuck.
       #
       def stuck?
         stuck_timeout = OnlineMigrations.config.background_data_migrations.stuck_timeout
-        (running? || cancelling? || pausing?) && updated_at <= stuck_timeout.ago
+        (cancelling? || pausing?) && updated_at <= stuck_timeout.ago
       end
 
       # @private
@@ -168,12 +177,12 @@ module OnlineMigrations
         true
       end
 
-      # Pause this data migration. No-op if migration is completed.
+      # Pause this data migration. No-op if migration is completed or already paused.
       #
       # @return [Boolean] whether this data migration was paused.
       #
       def pause
-        return false if completed?
+        return false if paused? || completed?
 
         if pending? || enqueued? || delayed? || stuck? || errored?
           paused!

data/lib/online_migrations/background_data_migrations/migration_job.rb

@@ -72,6 +72,7 @@ module OnlineMigrations
         # Job was manually cancelled.
         @migration.cancel if cancelled?
 
+        @migration.update!(jid: nil)
         @migration.complete
       end
 

data/lib/online_migrations/background_data_migrations/migration_status_validator.rb

@@ -13,14 +13,12 @@ module OnlineMigrations
         # enqueued -> failed occurs when the migration job fails to be enqueued, or
         #   if the migration is deleted before is starts running.
         "enqueued" => ["running", "paused", "cancelled", "failed"],
-        # running -> enqueued occurs when the migration is stuck and rescheduled by the scheduler.
         # running -> succeeded occurs when the migration completes successfully.
         # running -> pausing occurs when a user pauses the migration as it's performing.
         # running -> cancelling occurs when a user cancels the migration as it's performing.
         # running -> errored occurs when the migration raised an error during the last run.
         # running -> failed occurs when the migration raises an error when running and retry attempts exceeded.
         "running" => [
-          "enqueued",
           "succeeded",
           "pausing",
           "cancelling",

data/lib/online_migrations/background_data_migrations/scheduler.rb

@@ -36,11 +36,10 @@ module OnlineMigrations
         migrations_to_enqueue = []
 
         with_lock do
-          stuck_migrations, active_migrations = relation.running.partition(&:stuck?)
-          runnable_migrations = migrations_with_existing_classes(relation.pending) + stuck_migrations
+          runnable_migrations = migrations_with_existing_classes(relation.pending)
 
           # Ensure no more than 'concurrency' migrations are running at the same time.
-          remaining_to_enqueue = concurrency - active_migrations.count
+          remaining_to_enqueue = concurrency - relation.running.count
           if remaining_to_enqueue > 0
             runnable_migrations.take(remaining_to_enqueue).each do |migration|
               migration.update!(status: :enqueued)

data/lib/online_migrations/background_schema_migrations/migration.rb

@@ -23,6 +23,7 @@ module OnlineMigrations
       MAX_IDENTIFIER_LENGTH = 63
 
       self.table_name = :background_schema_migrations
+      self.ignored_columns += ["parent_id", "composite"]
 
       scope :queue_order, -> { order(created_at: :asc) }
       scope :active, -> { where(status: [:pending, :running, :errored]) }
@@ -80,15 +81,10 @@ module OnlineMigrations
       def progress
       end
 
-      # Whether the migration is considered stuck (is running for some configured time).
+      # Whether the migration is considered stuck.
       #
       def stuck?
-        if index_addition?
-          running? && !index_build_in_progress?
-        else
-          stuck_timeout = (statement_timeout || 1.day) + 10.minutes
-          running? && updated_at <= stuck_timeout.seconds.ago
-        end
+        index_addition? && running? && !index_build_in_progress?
       end
 
       # Mark this migration as ready to be processed again.

data/lib/online_migrations/background_schema_migrations/migration_runner.rb

@@ -44,9 +44,8 @@ module OnlineMigrations
         # Background schema migrations could take a while to run. It is possible, that the process
         # never reaches this (or the rescue below) line of code. E.g., when it is force quitted
         # (SIGKILL etc.) and so the migration will end up in the "running" state and the query is
-        # still executing (or already finished) in the database. This migration can either be safely
-        # manually retried or will be picked up in the future by scheduler when it decides that
-        # this migration is stuck.
+        # still executing (or already finished) in the database. This migration can be safely
+        # manually retried.
 
         migration.update!(status: :succeeded, finished_at: Time.current)
 

data/lib/online_migrations/background_schema_migrations/scheduler.rb

@@ -35,8 +35,8 @@ module OnlineMigrations
 
       private
         def find_migration(**options)
-          stuck_migrations, active_migrations = Migration.running.partition(&:stuck?)
-          runnable_migrations = (Migration.pending + Migration.errored + stuck_migrations).sort_by(&:created_at)
+          active_migrations = Migration.running.to_a
+          runnable_migrations = (Migration.pending + Migration.errored).sort_by(&:created_at)
 
           if options.key?(:shard)
             runnable_migrations = runnable_migrations.select { |migration| migration.shard.to_s == options[:shard].to_s }

data/lib/online_migrations/command_recorder.rb

@@ -153,4 +153,157 @@ module OnlineMigrations
         [:add_text_limit_constraint, args]
       end
   end
+
+  # @private
+  # New format was introduced in https://github.com/rails/rails/pull/58239.
+  module CommandRecorder82
+    REVERSIBLE_AND_IRREVERSIBLE_METHODS = [
+      :update_column_in_batches,
+      :initialize_column_rename,
+      :initialize_columns_rename,
+      :revert_initialize_column_rename,
+      :revert_initialize_columns_rename,
+      :finalize_column_rename,
+      :finalize_columns_rename,
+      :revert_finalize_column_rename,
+      :revert_finalize_columns_rename,
+      :initialize_table_rename,
+      :revert_initialize_table_rename,
+      :finalize_table_rename,
+      :revert_finalize_table_rename,
+      :swap_column_names,
+      :add_column_with_default,
+      :add_not_null_constraint,
+      :remove_not_null_constraint,
+      :add_text_limit_constraint,
+      :remove_text_limit_constraint,
+      :add_reference_concurrently,
+      :change_column_type_in_background,
+      :enqueue_background_data_migration,
+      :remove_background_data_migration,
+
+      # column type change helpers
+      :initialize_column_type_change,
+      :initialize_columns_type_change,
+      :revert_initialize_column_type_change,
+      :revert_initialize_columns_type_change,
+      :backfill_column_for_type_change,
+      :backfill_columns_for_type_change,
+      :finalize_column_type_change,
+      :finalize_columns_type_change,
+      :revert_finalize_column_type_change,
+      :cleanup_column_type_change,
+      :cleanup_columns_type_change,
+    ]
+
+    REVERSIBLE_AND_IRREVERSIBLE_METHODS.each do |method|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(*args, **kwargs, &block)          # def create_table(*args, **kwargs, &block)
+          record(:"#{method}", args, kwargs, &block)    #   record(:create_table, args, kwargs, &block)
+        end                                             # end
+      RUBY
+    end
+
+    private
+      module StraightReversions
+        {
+          initialize_column_rename:           :revert_initialize_column_rename,
+          initialize_columns_rename:          :revert_initialize_columns_rename,
+          finalize_column_rename:             :revert_finalize_column_rename,
+          finalize_columns_rename:            :revert_finalize_columns_rename,
+          initialize_table_rename:            :revert_initialize_table_rename,
+          finalize_table_rename:              :revert_finalize_table_rename,
+          add_not_null_constraint:            :remove_not_null_constraint,
+          initialize_column_type_change:      :revert_initialize_column_type_change,
+          initialize_columns_type_change:     :revert_initialize_columns_type_change,
+          finalize_column_type_change:        :revert_finalize_column_type_change,
+          finalize_columns_type_change:       :revert_finalize_columns_type_change,
+        }.each do |cmd, inv|
+          [[inv, cmd], [cmd, inv]].each do |method, inverse|
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def invert_#{method}(args, kwargs, &block)    # def invert_create_table(args, kwargs, &block)
+                [:#{inverse}, args, kwargs, block]          #   [:drop_table, args, kwargs, block]
+              end                                           # end
+            RUBY
+          end
+        end
+      end
+
+      include StraightReversions
+
+      def invert_add_reference_concurrently(args, kwargs)
+        [:remove_reference, args, kwargs]
+      end
+
+      def invert_swap_column_names(args, kwargs)
+        table_name, column1, column2 = args
+        [:swap_column_names, [table_name, column2, column1], kwargs]
+      end
+
+      def invert_add_column_with_default(args, kwargs)
+        table_name, column_name, = args
+        [:remove_column, [table_name, column_name], kwargs]
+      end
+
+      def invert_revert_initialize_column_rename(args, kwargs)
+        _table, column, new_column = args
+        if !column || !new_column
+          raise ActiveRecord::IrreversibleMigration,
+            "revert_initialize_column_rename is only reversible if given a column and new_column."
+        end
+        [:initialize_column_rename, args, kwargs]
+      end
+
+      def invert_revert_initialize_columns_rename(args, kwargs)
+        _table, old_new_column_hash = args
+        if !old_new_column_hash
+          raise ActiveRecord::IrreversibleMigration,
+            "revert_initialize_columns_rename is only reversible if given a hash of old and new columns."
+        end
+        [:initialize_columns_rename, args, kwargs]
+      end
+
+      def invert_finalize_table_rename(args, kwargs)
+        _table_name, new_name = args
+        if !new_name
+          raise ActiveRecord::IrreversibleMigration,
+            "finalize_table_rename is only reversible if given a new_name."
+        end
+        [:revert_finalize_table_rename, args, kwargs]
+      end
+
+      def invert_revert_initialize_column_type_change(args, kwargs)
+        if !args[2]
+          raise ActiveRecord::IrreversibleMigration,
+            "revert_initialize_column_type_change is only reversible if given a new_type."
+        end
+        super
+      end
+
+      def invert_revert_initialize_columns_type_change(args, kwargs)
+        if args[1].empty?
+          raise ActiveRecord::IrreversibleMigration,
+            "revert_initialize_columns_type_change is only reversible if given a columns_and_types."
+        end
+        super
+      end
+
+      def invert_add_not_null_constraint(args, kwargs)
+        kwargs.delete(:validate)
+        [:remove_not_null_constraint, args, kwargs]
+      end
+
+      def invert_add_text_limit_constraint(args, kwargs)
+        kwargs.delete(:validate)
+        [:remove_text_limit_constraint, args, kwargs]
+      end
+
+      def invert_remove_text_limit_constraint(args, kwargs)
+        if !args[2]
+          raise ActiveRecord::IrreversibleMigration, "remove_text_limit_constraint is only reversible if given a limit."
+        end
+
+        [:add_text_limit_constraint, args, kwargs]
+      end
+  end
 end

data/lib/online_migrations/schema_dumper.rb

@@ -15,7 +15,13 @@ module OnlineMigrations
 
   class WrappedConnection < SimpleDelegator
     def columns(table_name)
-      super.sort_by(&:name)
+      columns = super
+
+      if Utils.ar_version >= 8.2 && columns.is_a?(Hash)
+        columns.transform_values { |v| v.sort_by(&:name) }
+      else
+        columns.sort_by(&:name)
+      end
     end
   end
 end

data/lib/online_migrations/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OnlineMigrations
-  VERSION = "0.35.0"
+  VERSION = "0.36.1"
 end

data/lib/online_migrations.rb

@@ -119,7 +119,12 @@ module OnlineMigrations
       ActiveRecord::ConnectionAdapters::SchemaCache.prepend(OnlineMigrations::SchemaCache)
 
       ActiveRecord::Tasks::DatabaseTasks.singleton_class.prepend(OnlineMigrations::DatabaseTasks)
-      ActiveRecord::Migration::CommandRecorder.include(OnlineMigrations::CommandRecorder)
+
+      if Utils.ar_version >= 8.2
+        ActiveRecord::Migration::CommandRecorder.include(OnlineMigrations::CommandRecorder82)
+      else
+        ActiveRecord::Migration::CommandRecorder.include(OnlineMigrations::CommandRecorder)
+      end
 
       if !ActiveRecord::Batches::BatchEnumerator.method_defined?(:use_ranges)
         ActiveRecord::Batches::BatchEnumerator.include(OnlineMigrations::ActiveRecordBatchEnumerator)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: online_migrations
 version: !ruby/object:Gem::Version
-  version: 0.35.0
+  version: 0.36.1
 platform: ruby
 authors:
 - fatkodima
@@ -41,6 +41,7 @@ files:
 - lib/generators/online_migrations/templates/add_sharding_to_online_migrations.rb.tt
 - lib/generators/online_migrations/templates/add_timestamps_to_background_migrations.rb.tt
 - lib/generators/online_migrations/templates/background_data_migrations_add_iteration_pause.rb.tt
+- lib/generators/online_migrations/templates/background_data_migrations_convert_cursor.rb.tt
 - lib/generators/online_migrations/templates/background_data_migrations_remove_iteration_pause_default.rb.tt
 - lib/generators/online_migrations/templates/background_migrations_change_status_default.rb.tt
 - lib/generators/online_migrations/templates/background_schema_migrations_change_unique_index.rb.tt
@@ -115,7 +116,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.14
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Catch unsafe PostgreSQL migrations in development and run them easier in
   production