data_shifter 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e4e5f5aa36cfac3275fcb493a2555e6f093873c310395e92d4c7c64c42bb63b
-  data.tar.gz: d7c3e9a682d237887960a0bb3946e73a19bd913709ffb7c069a17a89e45f876a
+  metadata.gz: 7c2c6cb1c13bba3100efe294ceeafd838f4c329650b323457b0a75296bbff28f
+  data.tar.gz: b2dfe9b104bcc97fe7f8d1524d9739cb6b5918885a64f0ccf58725a8477d4298
 SHA512:
-  metadata.gz: 74d1ab829e7d3a695d934f6d624fa6bdad25b7bf13ee11d680ecd90ab9ccfbfa8df33eadf9f3239193a246a183db4604691747db7ae5ea12c4548afed547645a
-  data.tar.gz: c70d3e6be2982dc83501349aeee74ae2e3dd476fd2315f46a76b4e2b52e77cfa6f7c1042a7c4f613460880d07382731b2dd24db41d9e85991b54075d6cf76fa0
+  metadata.gz: c501bef9515dae1a53a20dd4b40e4fb454c31b17a781b53df02b861f6ae0415f012a801f2b767f5975cd8cb5aa69555467de5a89dff4448b766ab410e23e7a5a
+  data.tar.gz: cd30ac7dcef93f800101c26a5472063859e8671270c58169083c7116fdd3cac2f6559efe6f9da084a2b7b939aa2ef0e909a96b816964043f8739d544a80fef34

data/.husky/pre-commit

@@ -1,4 +1 @@
-#!/bin/sh
-. "$(dirname "$0")/_/husky.sh"
-
 npx lint-staged

data/CHANGELOG.md

@@ -0,0 +1,39 @@
+# Changelog
+
+## [Unreleased]
+
+* N/A
+
+## [0.3.0]
+
+### Added
+
+- **Task-based shifts**: New `task` DSL for targeted, one-off changes without the `collection`/`process_record` pattern. Define one or more `task "label" do ... end` blocks that run in sequence with shared transaction and dry-run semantics. Labels appear in output and error messages.
+- **Generator `--task` option**: `rails g data_shift fix_order_1234 --task` generates a shift with a `task` block instead of `collection`/`process_record`.
+- **Colorized CLI output**: Headers, summaries, and status output now use ANSI colors for better readability. Colors are automatically disabled when output is not a TTY or when `NO_COLOR` environment variable is set.
+- **Cleaner summaries**: `Failed` and `Skipped` lines are now omitted from summaries when their values are zero.
+
+### Changed
+
+- **Improved error messages**: `NotImplementedError` messages for `collection` and `process_record` now suggest using `task` blocks as an alternative.
+- **Task labels logged on execution**: When running task-based shifts, each labeled task logs its name (`>> label`) when it starts.
+
+## [0.2.0]
+
+### Added
+
+- **Configuration object**: New `DataShifter.configure` block for global settings.
+- **Dry-run rollback for `transaction false`**: Shifts using `transaction false` (or `:none`) now roll back DB changes in dry-run mode, matching the behavior of other transaction modes.
+- **Automatic side-effect guards in dry run**: When a shift runs in dry run mode, HTTP (via WebMock), ActionMailer, ActiveJob, and Sidekiq (if loaded) are now automatically blocked or faked so that unguarded external calls do not run. Restore happens in an `ensure` so state is reverted after the run.
+  - **HTTP**: All outbound requests are blocked unless allowed with the per-shift `allow_external_requests [...]` DSL or global `DataShifter.config.allow_external_requests`.
+  - **ActionMailer**: `perform_deliveries = false` for the duration of the dry run.
+  - **ActiveJob**: Queue adapter set to `:test` for the duration of the dry run.
+  - **Sidekiq**: `Sidekiq::Testing.fake!` for the duration of the dry run (only if `Sidekiq::Testing` is already loaded).
+- Dependency on `webmock` (>= 3.18) for dry-run HTTP blocking.
+- **Log deduplication**: Repeated log messages are now suppressed during shift runs (default: on). First occurrence logs normally; subsequent occurrences are counted and a summary is printed at the end. Configure globally with `config.suppress_repeated_logs` and `config.repeated_log_cap` (default 1000). Override per-shift with `suppress_repeated_logs false`.
+- **Global progress bar default**: `config.progress_enabled` (default `true`) sets the default for all shifts. Per-shift `progress true/false` still overrides.
+- **Global status interval**: `config.status_interval_seconds` (default `nil`) provides a fallback when `STATUS_INTERVAL` env var is not set.
+- **skip! abort behavior**: `skip!` now terminates the current `process_record` (no `return` needed after calling it).
+- **Grouped skip reasons**: Skip reasons are grouped and the top 10 (by count) are shown in the summary and status output instead of logging each skip inline.
+
+## [0.1.0] - Initial release

data/README.md

@@ -1,6 +1,6 @@
 # DataShifter
 
-Rake-backed data migrations (“shifts”) for Rails apps, with **dry run by default**, progress output, and a consistent summary. Define shift classes in `lib/data_shifts/*.rb`; run them as `rake data:shift:<task_name>`.
+Rake-backed data migrations ("shifts") for Rails apps, with **dry run by default**, progress output, and a consistent summary. Define shift classes in `lib/data_shifts/*.rb`; run them as `rake data:shift:<task_name>`.
 
 ## Installation
 
@@ -21,7 +21,7 @@ Generate a shift (optionally scoped to a model):
 
 ```bash
 bin/rails generate data_shift backfill_foo
-bin/rails generate data_shift backfill_users --model=User
+bin/rails generate data_shift backfill_users --model User
 ```
 
 Add  your logic to the generated file in `lib/data_shifts/`.
@@ -33,22 +33,11 @@ rake data:shift:backfill_foo
 COMMIT=1 rake data:shift:backfill_foo
 ```
 
-## How shift files map to rake tasks
-
-DataShifter defines one rake task per file in `lib/data_shifts/*.rb`.
-
-- **Task name**: derived from the filename with any leading digits removed.
-  - `20260201120000_backfill_foo.rb` → `data:shift:backfill_foo` (leading `<digits>_` prefix is stripped)
-  - `backfill_foo.rb` → `data:shift:backfill_foo`
-- **Class name**: task name camelized, inside the `DataShifts` module.
-  - `backfill_foo` → `DataShifts::BackfillFoo`
-
-Shift files are **required only when the task runs** (tasks are defined up front; classes load lazily).
-The `description "..."` line is extracted from the file and used for `rake -T` output without loading the shift class.
-
 ## Defining a shift
 
-Typical shifts implement:
+### Collection-based shifts (typical)
+
+For systemic migrations across many records, implement:
 
 - **`collection`**: an `ActiveRecord::Relation` (uses `find_each`) or an `Array`/Enumerable
 - **`process_record(record)`**: applies the change for one record
@@ -69,15 +58,86 @@ module DataShifts
 end
 ```
 
+### Task-based shifts (targeted, one-off changes)
+
+For targeted changes to specific records (e.g. fixing a bug for particular IDs), use `task` blocks instead:
+
+```ruby
+module DataShifts
+  class FixOrderDiscrepancies < DataShifter::Shift
+    description "Fix order #1234 shipping and billing issues"
+
+    task "Correct shipping address" do
+      order.update!(shipping_address: "123 Main St")
+    end
+
+    task "Apply missing discount" do
+      order.update!(discount_cents: 500)
+    end
+
+    private
+
+    def order
+      @order ||= Order.find(1234)
+    end
+  end
+end
+```
+
+Task blocks run in the context of the shift instance, so they have access to private helper methods, `dry_run?`, `log`, `skip!`, `find_exactly!`, and any other instance methods you define. Use private methods to DRY up shared lookups across tasks.
+
+Task blocks:
+
+- Run in sequence within the same lifecycle (transaction, dry run protection, summary)
+- Default to single transaction (all tasks commit or roll back together); use `transaction :per_record` for per-task transactions
+
+Generate a task-based shift with:
+
+```bash
+bin/rails generate data_shift fix_order_1234 --task
+```
+
 ## Dry run vs commit
 
-Shifts run in **dry run** mode by default. In the automatic transaction modes (`transaction :single` / `true`, and `transaction :per_record`), DB changes are rolled back automatically.
+Shifts run in **dry run** mode by default. DB changes are always rolled back in dry run mode, regardless of transaction setting.
 
 - **Dry run (default)**: `rake data:shift:backfill_foo`
 - **Commit**: `COMMIT=1 rake data:shift:backfill_foo`
   - (`COMMIT=true` or `DRY_RUN=false` also commit)
 
-Non-DB side effects (API calls, emails, enqueued jobs, etc.) obviously cannot be automatically rolled back, so guard them with e.g. `return if dry_run?`.
+### Automatic side-effect guards (dry run)
+
+In **dry run** mode, DataShifter automatically blocks or fakes these side effects so unguarded code is less likely to hit the network or send mail/jobs:
+
+| Service      | Behavior in dry run |
+|-------------|----------------------|
+| **HTTP**    | Blocked via WebMock (`disable_net_connect!`). Allow specific hosts with `allow_external_requests [...]` or `DataShifter.config.allow_external_requests`. |
+| **ActionMailer** | `perform_deliveries = false` (restored after run). |
+| **ActiveJob**    | Queue adapter set to `:test` (restored after run). |
+| **Sidekiq**      | `Sidekiq::Testing.fake!` (restored with `disable!` after run). Only applied if `Sidekiq::Testing` is already loaded. |
+
+**Guarding other side effects:** For anything we don't cover (e.g. another service, or allowed HTTP that mutates), use e.g. `return if dry_run?` in your shift. DB changes are always rolled back in dry run; only non-DB side effects need this.
+
+To allow HTTP to specific hosts during dry run (e.g. a migration that must call an API to compute values), use the per-shift DSL or global config (NOTE: it is your responsibility to ensure you only make readonly requests in `dry_run?` mode):
+
+```ruby
+# Per shift
+module DataShifts
+  class BackfillFromApi < DataShifter::Shift
+    allow_external_requests ["api.readonly.example.com", %r{\.internal\.company\z}]
+    # ...
+  end
+end
+```
+
+```ruby
+# Global (e.g. in config/initializers/data_shifter.rb)
+DataShifter.configure do |config|
+  config.allow_external_requests = ["api.readonly.example.com"]
+end
+```
+
+Allowed hosts are combined (per-shift + global). Restore (WebMock, mail, jobs) happens in an `ensure` so later code and other specs are unaffected.
 
 ## Transaction modes
 
@@ -85,7 +145,7 @@ Set the transaction mode at the class level:
 
 - **`transaction :single` / `transaction true` (default)**: one DB transaction for the entire run; dry run rolls back at the end; a record error aborts the run.
 - **`transaction :per_record`**: in commit mode, each record runs in its own transaction (errors are collected and the run continues); in dry run, the run is wrapped in a single rollback transaction.
-- **`transaction false` / `transaction :none`**: CAUTION: NOT RECOMMENDED. No automatic transactions and no automatic rollback; ⚠️ **you must manually guard DB writes AND side effects with `dry_run?`.**
+- **`transaction false` / `transaction :none`**: No automatic transaction in **commit** mode only. In dry run, the run is still wrapped in a single rollback transaction so DB changes are never committed. Use when you have external side effects or your own transaction strategy in commit mode.
 
 ```ruby
 module DataShifts
@@ -137,7 +197,53 @@ CONTINUE_FROM=123 COMMIT=1 rake data:shift:backfill_foo
 Notes:
 
 - Only supported for `ActiveRecord::Relation` collections (Array-based collections—like those from `find_exactly!`—cannot be resumed).
-- The filter is `primary_key > CONTINUE_FROM`, so it’s only useful with monotonically increasing primary keys (e.g. `find_each`'s default behavior).
+- The filter is `primary_key > CONTINUE_FROM`, so it's only useful with monotonically increasing primary keys (e.g. `find_each`'s default behavior).
+
+## How shift files map to rake tasks
+
+DataShifter defines one rake task per file in `lib/data_shifts/*.rb`.
+
+- **Task name**: derived from the filename with any leading digits removed.
+  - `20260201120000_backfill_foo.rb` → `data:shift:backfill_foo` (leading `<digits>_` prefix is stripped)
+  - `backfill_foo.rb` → `data:shift:backfill_foo`
+- **Class name**: task name camelized, inside the `DataShifts` module.
+  - `backfill_foo` → `DataShifts::BackfillFoo`
+
+Shift files are **required only when the task runs** (tasks are defined up front; classes load lazily).
+The `description "..."` line is extracted from the file and used for `rake -T` output without loading the shift class.
+
+## Configuration
+
+Configure DataShifter globally in an initializer:
+
+```ruby
+# config/initializers/data_shifter.rb
+DataShifter.configure do |config|
+  # Hosts allowed for HTTP during dry run only (no effect in commit mode)
+  config.allow_external_requests = ["api.readonly.example.com"]
+
+  # Suppress repeated log messages during a shift run (default: true)
+  config.suppress_repeated_logs = true
+
+  # Max unique messages to track for deduplication (default: 1000)
+  config.repeated_log_cap = 1000
+
+  # Global default for progress bar visibility (default: true)
+  config.progress_enabled = true
+
+  # Default status print interval in seconds when ENV STATUS_INTERVAL is not set (default: nil)
+  config.status_interval_seconds = nil
+end
+```
+
+Per-shift overrides:
+
+```ruby
+class MyShift < DataShifter::Shift
+  progress false                # Disable progress bar for this shift
+  suppress_repeated_logs false  # Disable log deduplication for this shift
+end
+```
 
 ## Operational tips
 
@@ -145,7 +251,7 @@ Notes:
 
 - **Start with a dry run**: run the task once with no environment variables set, confirm logs and summary look right, then re-run with `COMMIT=1`.
 - **Make shifts idempotent**: structure `process_record` so re-running is safe (for example, update only when the target column is `NULL`, or compute the same derived value deterministically).
-- **Guard side effects explicitly**: even in dry run, API calls / emails / enqueues are not rolled back. Use `dry_run?` helper to skip side-effectful code.
+- **Guard side effects we don't auto-block**: use `return if dry_run?` for any side effect not covered by Automatic side-effect guards (see above).
 
 ### Choosing a transaction mode (behavior + guidance)
 
@@ -156,8 +262,8 @@ Notes:
   - **Behavior**: in commit mode, records are committed one-by-one; errors are collected and the run continues; the overall run fails at the end if any record failed.
   - **Use when**: you want maximum progress and are OK investigating/fixing a subset of failures.
 - **`transaction false` / `:none`**:
-  - **Behavior**: no automatic transaction wrapper (even in dry run) and no automatic rollback.
-  - **Use when**: you have intentional external side effects, or you’re doing your own transaction/locking strategy—**but always guard writes/side effects with `dry_run?`.**
+  - **Behavior**: in commit mode, no automatic transaction; in dry run, the run is still wrapped in a rollback transaction so DB changes are not committed.
+  - **Use when**: you have intentional external side effects or your own transaction/locking strategy in commit mode.
 
 ### Performance and operability (recommended)
 
@@ -182,17 +288,19 @@ def process_record(buyback)
 end
 ```
 
-### `skip!` (count but don’t update)
+### `skip!` (count but don't update)
 
-Mark a record as skipped (it will increment “Skipped” in the summary):
+Mark a record as skipped. Calling `skip!` terminates the current `process_record` immediately (no `return` needed). The record is counted as "Skipped" in the summary.
 
 ```ruby
 def process_record(record)
   skip!("already done") if record.foo.present?
-  record.update!(foo: value)
+  record.update!(foo: value)  # not executed if skipped
 end
 ```
 
+Skip reasons are grouped: the summary shows the top 10 reasons by count (e.g. `"already done" (42), "not eligible" (3)`) instead of logging each skip inline. This keeps the progress bar clean.
+
 ### Throttling and disabling the progress bar
 
 ```ruby
@@ -202,19 +310,29 @@ class SomeShift < DataShifter::Shift
 end
 ```
 
+
 ## Generator
 
 | Command | Generates |
 |--------|----------|
 | `bin/rails generate data_shift backfill_foo` | `lib/data_shifts/<timestamp>_backfill_foo.rb` with a `DataShifts::BackfillFoo` class |
-| `bin/rails generate data_shift backfill_users --model=User` | Same, with `User.all` in `collection` and `process_record(user)` |
+| `bin/rails generate data_shift backfill_users --model User` | Same, with `User.all` in `collection` and `process_record(user)` |
 | `bin/rails generate data_shift backfill_users --spec` | Also generates `spec/lib/data_shifts/backfill_users_spec.rb` when RSpec is enabled |
+| `bin/rails generate data_shift fix_order_1234 --task` | Generates a shift with a `task` block instead of `collection`/`process_record` |
 
 The generator refuses to create a second shift if it would produce a duplicate rake task name.
 
 ## Testing shifts (RSpec)
 
-This gem ships a small helper module for running shifts in tests:
+This gem ships a small helper module for running shifts in tests. Require it and include `DataShifter::SpecHelper` in specs or in `RSpec.configure` for `type: :data_shift`.
+
+**Helpers:**
+
+- **`run_data_shift(shift_class, dry_run: true, commit: false)`** — Runs the shift; returns an `Axn::Result`. Use `commit: true` to run in commit mode.
+- **`silence_data_shift_output`** — Suppresses STDOUT for the block (e.g. progress bar).
+- **`capture_data_shift_output`** — Runs the block and returns `[result, output_string]` for asserting on printed output.
+
+Use `expect { ... }.not_to change(...)` and `expect { ... }.to change(...)` to assert that data stays unchanged in dry run and changes when committed:
 
 ```ruby
 require "data_shifter/spec_helper"
@@ -222,35 +340,29 @@ require "data_shifter/spec_helper"
 RSpec.describe DataShifts::BackfillFoo do
   include DataShifter::SpecHelper
 
-  before { allow($stdout).to receive(:puts) } # silence shift output
+  before { allow($stdout).to receive(:puts) }
 
   it "does not persist changes in dry run" do
-    result = run_data_shift(described_class, dry_run: true)
-    expect(result).to be_ok
-    # TODO: add some check confirming data is unchanged
+    expect do
+      result = run_data_shift(described_class, dry_run: true)
+      expect(result).to be_ok
+    end.not_to change(Foo, :count)
   end
 
   it "persists changes when committed" do
-    result = run_data_shift(described_class, commit: true)
-    expect(result).to be_ok
-    # TODO: add some check confirming data is changed
+    expect do
+      result = run_data_shift(described_class, commit: true)
+      expect(result).to be_ok
+    end.to change(Foo, :count).by(1)
+    # Or for in-place updates: .to change { record.reload.bar }.from(nil).to("baz")
   end
 end
 ```
 
-## Optional RuboCop cop
-
-If you use `transaction false` / `transaction :none`, you should guard writes and side effects with `dry_run?`. You can help avoid mistakes by linting that the helper is at least called once via the bundled cop:
-
-```yaml
-# .rubocop.yml
-require:
-  - data_shifter/rubocop
-```
-
 ## Requirements
 
 - Ruby ≥ 3.2.1
-- Rails (ActiveRecord, ActiveSupport, Railties) ≥ 6.1
+- Rails (ActiveRecord, ActiveSupport, Railties) ≥ 7.0
 - `axn` (Shift classes include `Axn`)
 - `ruby-progressbar` (for progress bars)
+- `webmock` (for dry-run HTTP blocking; optional allowlist via `allow_external_requests [...]` / `DataShifter.config.allow_external_requests`)

data/lib/data_shifter/configuration.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module DataShifter
+  # Global configuration for DataShifter.
+  #
+  # Configure via:
+  #   DataShifter.configure do |config|
+  #     config.allow_external_requests = ["api.readonly.example.com"]
+  #     config.suppress_repeated_logs = true
+  #   end
+  #
+  # Or access directly:
+  #   DataShifter.config.progress_enabled = false
+  class Configuration
+    # Hosts or regexes allowed for HTTP during dry run only (combined with per-shift allow_external_requests).
+    # Has no effect in commit mode — HTTP is unrestricted when dry_run is false.
+    attr_accessor :allow_external_requests
+
+    # Whether to suppress repeated log messages during a shift run. Default: true.
+    # Can be overridden per shift with `suppress_repeated_logs true/false`.
+    attr_accessor :suppress_repeated_logs
+
+    # Maximum unique log messages to track for deduplication. Default: 1000.
+    # When exceeded, entries with count == 1 are cleared first; repeated entries are kept.
+    attr_accessor :repeated_log_cap
+
+    # Global default for progress bar visibility. Default: true.
+    # Per-shift `progress true/false` overrides this.
+    attr_accessor :progress_enabled
+
+    # Default status print interval in seconds when ENV STATUS_INTERVAL is not set. Default: nil.
+    attr_accessor :status_interval_seconds
+
+    def initialize
+      @allow_external_requests = []
+      @suppress_repeated_logs = true
+      @repeated_log_cap = 1000
+      @progress_enabled = true
+      @status_interval_seconds = nil
+    end
+  end
+end

data/lib/data_shifter/errors.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module DataShifter
+  # Raised when a dry run attempts an outbound HTTP request to a host that is
+  # not allowed via allow_external_requests (per-shift or global config).
+  class ExternalRequestNotAllowedError < StandardError
+    def initialize(attempted_host: nil)
+      @attempted_host = attempted_host
+      super(build_message)
+    end
+
+    attr_reader :attempted_host
+
+    private
+
+    def build_message
+      intro = if @attempted_host && !@attempted_host.to_s.strip.empty?
+                "Dry run blocked an outbound HTTP request to #{@attempted_host}."
+              else
+                "Dry run blocked an outbound HTTP request."
+              end
+
+      if @attempted_host && !@attempted_host.to_s.strip.empty?
+        <<~MSG.strip
+          #{intro}
+
+          To allow this host during dry run, add to your shift class:
+
+            allow_external_requests ["#{@attempted_host}"]
+
+          Or set DataShifter.config.allow_external_requests in an initializer.
+        MSG
+      else
+        <<~MSG.strip
+          #{intro}
+
+          To allow specific hosts during dry run, add to your shift class:
+
+            allow_external_requests ["host.example.com"]  # or use a regex
+
+          Or set DataShifter.config.allow_external_requests in an initializer.
+        MSG
+      end
+    end
+  end
+end

data/lib/data_shifter/internal/colors.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module DataShifter
+  module Internal
+    # ANSI color utilities for CLI output.
+    # Automatically detects TTY and respects NO_COLOR environment variable.
+    module Colors
+      CODES = {
+        reset: "\e[0m",
+        bold: "\e[1m",
+        dim: "\e[2m",
+        green: "\e[32m",
+        yellow: "\e[33m",
+        red: "\e[31m",
+        cyan: "\e[36m",
+      }.freeze
+
+      module_function
+
+      def enabled?(io = $stdout)
+        return false if ENV["NO_COLOR"]
+        return false unless io.respond_to?(:tty?)
+
+        io.tty?
+      end
+
+      def wrap(text, *styles, io: $stdout)
+        return text unless enabled?(io)
+
+        codes = styles.map { |s| CODES[s] }.compact.join
+        "#{codes}#{text}#{CODES[:reset]}"
+      end
+
+      def bold(text, io: $stdout)
+        wrap(text, :bold, io:)
+      end
+
+      def dim(text, io: $stdout)
+        wrap(text, :dim, io:)
+      end
+
+      def green(text, io: $stdout)
+        wrap(text, :green, io:)
+      end
+
+      def yellow(text, io: $stdout)
+        wrap(text, :yellow, io:)
+      end
+
+      def red(text, io: $stdout)
+        wrap(text, :red, io:)
+      end
+
+      def cyan(text, io: $stdout)
+        wrap(text, :cyan, io:)
+      end
+
+      def success(text, io: $stdout)
+        wrap(text, :bold, :green, io:)
+      end
+
+      def warning(text, io: $stdout)
+        wrap(text, :bold, :yellow, io:)
+      end
+
+      def error(text, io: $stdout)
+        wrap(text, :bold, :red, io:)
+      end
+    end
+  end
+end

data/lib/data_shifter/internal/env.rb

@@ -18,14 +18,16 @@ module DataShifter
         end
       end
 
-      # Parse STATUS_INTERVAL environment variable.
-      # Returns nil if not set or invalid.
+      # Parse STATUS_INTERVAL environment variable, falling back to config.
+      # Returns nil if not set/invalid and config is nil.
       def status_interval_seconds
-        return nil unless ENV["STATUS_INTERVAL"].present?
-
-        Integer(ENV.fetch("STATUS_INTERVAL", nil), 10)
+        if ENV["STATUS_INTERVAL"].present?
+          Integer(ENV.fetch("STATUS_INTERVAL", nil), 10)
+        else
+          DataShifter.config.status_interval_seconds
+        end
       rescue ArgumentError
-        nil
+        DataShifter.config.status_interval_seconds
       end
 
       # Get CONTINUE_FROM environment variable value.