Keeping your database migrations strong with strong_migrations gem

Introduction

In software development, the evolution of applications is inevitable. As your project grows and adapts to changing requirements, database migrations become crucial to maintaining data integrity and structural consistency. However, managing migrations effectively can be daunting, especially as your application scales. This is where tools like the Strong Migrations gem come into play, offering a robust solution to streamline the migration process and ensure database changes are implemented smoothly.

What is Strong Migrations?

Strong Migrations is a Ruby gem designed to help Rails developers perform safe and efficient database migrations, especially in production environments. It provides tools and best practices to ensure migrations are performed smoothly without disrupting the application's availability.

Why are Strong Migrations Important?

1. Safety Nets: Strong Migrations introduces safety checks to prevent potentially destructive operations from inadvertently being executed on your production database. Analyzing your migration files can detect unsafe operations, such as irreversible data changes or long-running queries, alerting you to potential issues before they cause harm.

2. Performance Optimization: In large-scale applications, poorly optimized migrations can lead to significant downtime during deployment. Strong Migrations helps optimize migration performance by identifying inefficient queries and suggesting improvements, ensuring database changes are applied swiftly and seamlessly.

3. Data Integrity: Ensuring data integrity is paramount when making structural changes to your database. Strong Migrations provides tools to validate the consistency of your data both before and after migrations, minimizing the risk of corruption or loss.

4. Compliance: In regulated industries where compliance with data protection laws is mandatory, Strong Migrations helps enforce best practices and ensures that migrations adhere to regulatory requirements. This can be especially valuable for applications handling sensitive user information.

How to Use Strong Migrations

Using Strong Migrations in your Rails application is straightforward. First, add the gem to your Gemfile:

gem 'strong_migrations'

Then, run the following command to install it:

bundle install

Once the gem is installed, you can use its features in your migrations. For example, to add a column with a default value, use the add_column method with the default option:

class AddDefaultValueToColumn < ActiveRecord::Migration[6.0]
  def change
    add_column :table_name, :column_name, :string, default: 'default_value', null: false
  end
end

To perform potentially dangerous operations, such as dropping a column, use the safety_assured method to turn off safety checks temporarily.

class RemoveColumnFromTable < ActiveRecord::Migration[6.0]
  def change
    safety_assured { remove_column :table_name, :column_name }
  end
end

Finally, when running migrations in a production environment, use the safety_assured method to ensure that the migration is safe to run:

RAILS_ENV=production bundle exec rails db:migrate

Dangerous Operations

The following operations can cause downtime or errors:

• Adding a column with a non-null default value to an existing table
• Removing a column
• Changing the type of a column
• Setting a NOT NULL constraint with a default value
• Renaming a column
• Renaming a table
• Creating a table with the force option
• Adding an index non-concurrently (Postgres only)
• Adding a JSON column to an existing table (Postgres only)

Let's go over an example to understand the flow.

Adding a column with a non-null default value

Let's say you have a User model and want to add a new column with a default value. You will write a migration as follows.

class AddStatusToUsers < ActiveRecord::Migration[7.1]
  def change
    add_column :users, :status, :text, default: 'on_boarded'
  end
end

In previous iterations of Postgres, introducing a column with a default value to an already-existing table would prompt a complete rewrite of the entire table, resulting in blockage for both reading and writing operations in Postgres.

NOTE: In Postgres 11+, this no longer requires a table rewrite and is safe.

If you try to run the above migration, strong migrations will raise an error as below:

rake aborted!
StandardError: An error has occurred, all later migrations canceled:

=== Dangerous operation detected #strong_migrations ===

Adding a column with a non-null default causes the entire table to be rewritten.
Instead, add the column without a default value, then change the default.

class AddStatusToUsers < ActiveRecord::Migration[7.1]
  def up
    add_column :users, :status, :text
    change_column_default :users, :status, 'on_boarded'
  end

  def down
    remove_column :users, :status
  end
end

Migration Timeouts

The strong_migrations gem in Ruby on Rails also provides functionality to set timeouts for migrations. This is crucial in preventing migrations from causing extended downtime in production environments. Setting timeouts ensures that migrations are complete within a reasonable time frame, preventing situations where they may block database operations for an extended period.

You can set a timeout for migrations globally in your Rails application. Add the following configuration to an initializer file (e.g., config/initializers/strong_migrations.rb):

StrongMigrations.timeout = 600 # Set timeout to 10 minutes (in seconds)

Adjust the timeout value according to your application's needs. The example above sets the timeout to 600 seconds (10 minutes).

If a migration exceeds the specified timeout, strong_migrations will automatically halt the migration and raise an error. This prevents the migration from causing prolonged downtime.

By configuring migration timeouts with the strong_migrations gem, you can enforce time limits on database migrations, mitigating the risk of extended downtime and ensuring the reliability of your application's deployment process.

Best Practices

1. Regularly Update Gem: Stay updated with the latest version of Strong Migrations to leverage new features, bug fixes, and security patches. Regular updates ensure that your migrations remain robust and aligned with best practices.

2. Run Checks Locally: Before deploying migrations to production, run Strong Migrations checks locally to catch any potential issues early in the development cycle. This proactive approach helps in resolving issues before they impact your production environment.

3. Review Migration Plans: Review migration plans carefully, especially for complex schema changes or large datasets. Consider breaking down migrations into smaller, manageable steps to minimize the risk of downtime and optimize performance.

4. Monitor Performance: Monitor the performance of your migrations in production environments using tools like database monitoring and logging. Identify any bottlenecks or performance issues and optimize your migrations accordingly.

5. Practice Safe Rollbacks: Always have a rollback plan in case of unexpected issues during migration deployment. Test rollback procedures in staging or development environments to ensure a smooth recovery.

Conclusion

In the fast-paced world of software development, effective database migration management is essential for maintaining your applications' stability, performance, and integrity. Strong Migrations empowers Rails developers with the tools they need to confidently navigate the complexities of migration management, providing safety checks, performance optimizations, and compliance features to streamline the process and mitigate risks. By incorporating Strong Migrations into your workflow, you can ensure smooth, seamless migrations that pave the way for the continued evolution of your applications.