boring-backup 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 520f4d8e05984b490027c72e0922660b93f73ed22f6d48671ba87b6c4922883e
-  data.tar.gz: 698eeeb6840e35554551cf2d87a2c2a567f8d5b58678a6d0eaed517781dff7db
+  metadata.gz: 851d7814c77a411800884379a85ae1feeffb5c8183d3b524ab3851f1fc7d1dde
+  data.tar.gz: e54bf1a64c28d237753b4eaa5c4bd7114c067a6b6f957b73ad4526f5332fc393
 SHA512:
-  metadata.gz: c6f7efdd9f7ab1a12a53f84cb3bd539f1d2003f61098dee77a48b48a23bbb9e40814293ff6622477e1397a4857242a19775f2ca6d375df3f026208ef301f4600
-  data.tar.gz: d0351b5626ffbc7b17d88b60682a8d4e3b30bfa12d390d47cff858ca0cb741879f8182d2bace733f5e31f8e3a43e653e9e1ddf43be6f73206c87171c57aaf293
+  metadata.gz: 682eb6a513c065b1078ca528bebb9ea5cbc83924a873d47965e5ca463c8d94210a8f6e020242e45ea6fb8817e8c23e8c51a999070c1d5f2c5c63cf0b9ecc605a
+  data.tar.gz: 7afd54ae737169eb4f44d4bfd575acd64b13177b8c1d77d33260d217742934cbe053822cd5ebf4a64aa00a92cbfa16751553042f8a4ff1e7da6861f245f99045

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 ## [Unreleased]
 
+## [0.6.0] - 2026-07-23
+
+- `bb doctor` - improved scheduler checks (now supports `sidekiq-crosidekiq-cron`)
+- support `PG*` env vars
+- support for Cloudflare R2 using their S3-compatible API
+
+## [0.5.0] - 2026-07-14
+
+- **`aws-sdk-s3` is no longer a dependency of the gem.** apps using the `:s3` store must add `gem
+"aws-sdk-s3"` to their own `Gemfile`.
+- New `bb install` command - wires up the initializer, the Solid Queue schedule and a `bin/bb` binstub
+- New `bb doctor` command - checks pg_dump, versions, database, stores and schedule; exits non-zero on failure
+- `bb backup` now shows a boot spinner, a live progress meter and a coloured summary
+- `config.register(:s3)` no longer requires a block - the store configures itself from the environment
+- `Commands::Backup.execute` accepts a `progress:` callback with the running byte count
+
 ## [0.4.0] - 2026-07-13
 
 - **Renamed the gem from `noop-backup` to `boring-backup`.** Breaking, with no shims:

data/README.md

@@ -20,6 +20,19 @@ gem install boring-backup
 
 The gem requires `pg_dump` to be installed on the machine that is running it.
 
+Storage backends bring their own dependencies, which are not installed by default. To use
+the `:s3` and `:r2` stores, add the AWS SDK to your `Gemfile` as well:
+
+```bash
+bundle add aws-sdk-s3
+```
+
+Run the install command to set up the initializer:
+
+```bash
+bundle exec bb install
+```
+
 ## Usage
 
 ### Automatic
@@ -62,6 +75,8 @@ All configuration options can be edited in the initializer:
 # config/initializers/boring-backup.rb
 
 BoringBackup.configure do |config|
+  config.sentinel_key = '12345678-abcd-1234-abcd-abcdef123456'
+
   config.register(:s3) do |store|
     store.bucket = Settings.aws.bucket
     store.region = Settings.aws.region
@@ -69,6 +84,13 @@ BoringBackup.configure do |config|
     store.secret_access_key = Settings.aws.secret_access_key
   end
 
+  config.register(:r2) do |store|
+    store.endpoint = Settings.r2.endpoint
+    store.bucket = Settings.r2.bucket
+    store.access_key_id = Settings.r2.access_key_id
+    store.secret_access_key = Settings.r2.secret_access_key
+  end
+
   config.notifier :slack do |slack|
     slack.webhook_url = 'https://hooks.slack.com/services/whatever'
   end
@@ -101,12 +123,10 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/gmitre
 
 ## Wishlist
 
-- [ ] S3-compatible backends
+- [X] S3-compatible backends
+- [X] doctor command
 - [ ] file backend
-- [ ] email notifier
-- [ ] SMS notifier
 - [ ] restore command
-- [ ] test command
 - [ ] encryption
 - [ ] delete stale
 

data/lib/boring_backup/cli.rb

@@ -1,17 +1,336 @@
 require "thor"
+require "pastel"
+require "tty-prompt"
+require "tty-spinner"
 
 module BoringBackup
   class CLI < Thor
+    include Thor::Actions
+
+    INITIALIZER = "config/initializers/boring_backup.rb"
+    RECURRING = "config/recurring.yml"
+    BINSTUB = "bin/bb"
+
+    DEFAULT_SCHEDULE = "every day at 3am"
+    PRODUCTION_ANCHOR = /^production:[ \t]*\r?\n/
+
+    SPINNER = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
+    REDRAW_INTERVAL = 0.1
+
+    add_runtime_options!
+
     def self.exit_on_failure? = true
 
+    def self.source_root = File.expand_path("templates", __dir__)
+
     desc "backup", "Create and store a new backup"
     def backup
-      BoringBackup.prepare!
-      result = BoringBackup::Commands::Backup.execute
+      spinner("Booting") { BoringBackup.prepare! }
+
+      say "  #{pastel.bold("Boring Backup")}  #{pastel.dim(BoringBackup.config.pg_env["PGDATABASE"])}"
+
+      result = stream_backup
+
+      result.store_results.each { |store_result| say "  #{store_line(store_result)}" }
+      say "\n  #{verdict(result)}\n"
+
       exit 1 unless result.success?
     rescue => e
-      warn e
+      say "  #{pastel.red("✗")} #{e.message}\n"
       exit 1
     end
+
+    desc "doctor", "Check that backups are set up correctly"
+    def doctor
+      spinner("Booting") { BoringBackup.prepare! }
+
+      say "  #{pastel.bold("Boring Backup")}  #{pastel.dim("doctor · #{BoringBackup.environment}")}"
+
+      result = spinner("Running checks") { BoringBackup::Commands::Doctor.execute }
+
+      width = result.checks.map { |check| check.name.length }.max
+
+      result.checks.each { |check| say "  #{check_line(check, width)}" }
+      say "\n  #{doctor_verdict(result)}\n"
+
+      exit 1 unless result.success?
+    rescue => e
+      say "  #{pastel.red("✗")} #{e.message}\n"
+      exit 1
+    end
+
+    desc "install", "Wire up recurring backups in this app"
+    def install
+      say "\n  #{pastel.bold("Boring Backup")}\n\n"
+
+      preflight
+
+      store = configure_store
+      write_initializer(store)
+      install_schedule
+      install_binstub
+
+      say_next_steps
+    end
+
+    private
+
+    def stream_backup
+      BoringBackup.config.silence_stdout!
+
+      @started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @frame = 0
+
+      BoringBackup::Commands::Backup.execute(progress: meter)
+    ensure
+      clear_line
+    end
+
+    def meter
+      return unless $stdout.tty?
+
+      ->(bytes) { draw_meter(bytes) }
+    end
+
+    def draw_meter(bytes)
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      return if @drawn_at && now - @drawn_at < REDRAW_INTERVAL
+
+      @drawn_at = now
+      elapsed = now - @started
+      rate = elapsed.zero? ? 0 : bytes / elapsed
+      tick = SPINNER[@frame = (@frame + 1) % SPINNER.size]
+
+      $stdout.print "\r  #{pastel.cyan(tick)}  Dumping #{pastel.bold(human(bytes))} " \
+        "#{pastel.dim("· #{human(rate)}/s · #{elapsed.round}s")}\e[K"
+    end
+
+    def clear_line
+      $stdout.print "\r\e[K" if $stdout.tty?
+    end
+
+    def store_line(store_result)
+      if store_result.success
+        "#{pastel.green("✓")} #{pastel.bold(store_result.store.to_s.ljust(6))} " \
+          "#{human(store_result.bytes)} in #{store_result.duration.round(1)}s  #{pastel.dim("→ /#{store_result.key}")}"
+      else
+        "#{pastel.red("✗")} #{pastel.bold(store_result.store.to_s.ljust(6))} #{pastel.red(store_result.error.message)}"
+      end
+    end
+
+    def verdict(result)
+      case result.status
+      when :success then pastel.green.bold("Backed up to #{result.store_results.size} store(s).")
+      when :partial_success then pastel.yellow.bold("Partial: #{result.store_results.count(&:success)}/#{result.store_results.size} stores succeeded.")
+      else pastel.red.bold("Backup failed. #{result.error&.message}")
+      end
+    end
+
+    def human(bytes)
+      BoringBackup.utils.human_size(bytes)
+    end
+
+    CHECK_MARKS = {
+      ok: ["✓", :green],
+      fail: ["✗", :red],
+      skip: ["–", :yellow]
+    }.freeze
+
+    def check_line(check, width)
+      mark, colour = CHECK_MARKS.fetch(check.status)
+
+      "#{pastel.decorate(mark, colour)} #{pastel.bold(check.name.to_s.ljust(width))}  #{pastel.dim(check.detail.to_s)}"
+    end
+
+    def doctor_verdict(result)
+      return pastel.red.bold("#{result.failures.size} check(s) failed.") unless result.success?
+
+      skipped = result.checks.count { |check| check.status == :skip }
+
+      if skipped.zero?
+        pastel.green.bold("Everything checks out.")
+      else
+        pastel.green.bold("Checks passed.") + pastel.dim(" #{skipped} skipped — run this where the credentials live to verify the bucket.")
+      end
+    end
+
+    def preflight
+      check "Rails app", rails? && "config/environment.rb"
+      check "Scheduler", solid_queue? && "Solid Queue (#{RECURRING})", hint: "no supported scheduler found"
+      check "Database", database, hint: "could not read ActiveRecord config"
+      check "Store", configured_store_summary, hint: "none configured"
+
+      say ""
+    end
+
+    def check(label, value, hint: "not found")
+      mark = value ? pastel.green("✓") : pastel.yellow("✗")
+      detail = value ? pastel.dim(value.to_s) : pastel.dim(hint)
+
+      say "  #{mark} #{label.to_s.ljust(10)} #{detail}"
+    end
+
+    def rails?
+      File.exist?("config/environment.rb")
+    end
+
+    def solid_queue?
+      File.exist?(RECURRING) && gemfile_lock.include?("solid_queue")
+    end
+
+    def gemfile_lock
+      @gemfile_lock ||= File.exist?("Gemfile.lock") ? read("Gemfile.lock") : ""
+    end
+
+    def read(path)
+      File.read(path, mode: "r:UTF-8")
+    end
+
+    def database
+      return @database if defined?(@database)
+
+      @database = spinner("Reading database config") do
+        BoringBackup.prepare!
+        BoringBackup.config.pg_env["PGDATABASE"]
+      rescue
+        nil
+      end
+    end
+
+    def spinner(message)
+      return yield unless $stdout.tty?
+
+      spinner = TTY::Spinner.new("  #{pastel.dim(message)} :spinner", format: :dots, clear: true, output: $stdout)
+      spinner.auto_spin
+
+      yield
+    ensure
+      spinner&.stop
+      clear_line
+    end
+
+    def configured_store_summary
+      "S3 — #{INITIALIZER}" if File.exist?(INITIALIZER)
+    end
+
+    def configure_store
+      return if File.exist?(INITIALIZER)
+
+      prompt.select("Where should backups go?") do |menu|
+        menu.choice "S3 (or S3-compatible: R2, MinIO, Spaces)", :s3
+      end
+
+      {
+        bucket: prompt.ask("Bucket name:", required: true),
+        region: prompt.ask("Region:", default: ENV.fetch("AWS_REGION", "us-east-1"))
+      }
+    end
+
+    def write_initializer(store)
+      unless store
+        say_status :identical, INITIALIZER, :blue
+        return
+      end
+
+      create_file INITIALIZER, initializer_body(store)
+
+      say_credentials_note
+    end
+
+    def initializer_body(store)
+      <<~RUBY
+        BoringBackup.configure do |config|
+          config.register(:s3) do |store|
+            store.bucket = #{store[:bucket].inspect}
+            store.region = #{store[:region].inspect}
+          end
+        end
+      RUBY
+    end
+
+    def say_credentials_note
+      say_status :note, "credentials come from AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY in the backup environment, or an IAM role", :blue
+      say "  #{pastel.dim("Keep them out of #{INITIALIZER} — it's committed.")}\n"
+    end
+
+    def install_schedule
+      return print_manual_schedule unless solid_queue?
+
+      recurring = read(RECURRING)
+
+      if recurring.include?("BoringBackup::BackupJob")
+        say_status :identical, "#{RECURRING} already runs BoringBackup::BackupJob", :blue
+        return
+      end
+
+      unless recurring.match?(PRODUCTION_ANCHOR)
+        say_status :skip, "#{RECURRING} has no `production:` block", :yellow
+        return print_manual_schedule
+      end
+
+      schedule = prompt.ask("Schedule:", default: DEFAULT_SCHEDULE)
+
+      return unless prompt.yes?("Add the backup job to #{RECURRING} under `production:`?")
+
+      inject_schedule(recurring, schedule)
+
+      say_status :insert, RECURRING, :green
+      say_status :note, "backups run in production only — dev and staging are untouched", :blue
+    end
+
+    def inject_schedule(recurring, schedule)
+      entry = <<~YAML.gsub(/^(?=.)/, "  ")
+        boring_backup:
+          class: BoringBackup::BackupJob
+          schedule: #{schedule}
+      YAML
+
+      updated = recurring.sub(PRODUCTION_ANCHOR) { |anchor| "#{anchor}#{entry}" }
+
+      File.write(RECURRING, updated, mode: "w:UTF-8")
+    end
+
+    def print_manual_schedule
+      say "\n  #{pastel.yellow("No supported scheduler detected.")} Run the backup from cron instead:\n\n"
+      say "#{pastel.dim("    0 3 * * *  cd /path/to/app && #{backup_command}")}\n\n"
+    end
+
+    def install_binstub
+      return unless File.directory?("bin")
+
+      if binstub?
+        say_status :identical, BINSTUB, :blue
+        return
+      end
+
+      return unless prompt.yes?("Add a #{BINSTUB} binstub? (drops the `bundle exec` prefix)")
+
+      run "bundle binstubs boring-backup"
+    end
+
+    def binstub?
+      File.exist?(BINSTUB)
+    end
+
+    def backup_command
+      binstub? ? "#{BINSTUB} backup" : "bundle exec bb backup"
+    end
+
+    def say_next_steps
+      say "\n  #{pastel.bold("Next:")} #{pastel.cyan(doctor_command)}   #{pastel.dim("# check the setup before it runs at 3am")}\n\n"
+    end
+
+    def doctor_command
+      binstub? ? "#{BINSTUB} doctor" : "bundle exec bb doctor"
+    end
+
+    def prompt
+      @prompt ||= TTY::Prompt.new
+    end
+
+    def pastel
+      @pastel ||= Pastel.new
+    end
   end
 end

data/lib/boring_backup/commands/backup.rb

@@ -26,16 +26,17 @@ module BoringBackup::Commands
   end
 
   class Backup
-    def self.execute(report: BoringBackup.config.report?)
-      result = new.execute
+    def self.execute(report: BoringBackup.config.report?, progress: nil)
+      result = new(progress: progress).execute
 
       result.report if report
 
       result
     end
 
-    def initialize
+    def initialize(progress: nil)
       @key = generate_key
+      @progress = progress
       @store_results = []
       @sinks = []
     end
@@ -45,8 +46,8 @@ module BoringBackup::Commands
 
       commands = [config.dump_command]
 
-      # Pipe pg_dump through pv if installed for a basic progress report
-      commands << ["pv", "-btra"] if config.report? && system("which", "pv", out: File::NULL, err: File::NULL)
+      # Pipe pg_dump through pv only when the caller isn't counting bytes itself
+      commands << ["pv", "-btra"] if @progress.nil? && config.report? && system("which", "pv", out: File::NULL, err: File::NULL)
 
       Open3.pipeline_r(*commands) do |last_stdout, wait_threads|
         @sinks = config.stores.map do |store|
@@ -56,7 +57,7 @@ module BoringBackup::Commands
             store.backup!(@key, reader)
           rescue => e
             # *always* return a Result, even if unexpected. Add store name for debugging.
-            BoringBackup::Stores::Result.new(success: false, error: e, store: store.class.name, key: @key)
+            BoringBackup::Stores::Result.new(success: false, error: e, store: store.name, key: @key)
           ensure
             reader.close
           end
@@ -64,7 +65,7 @@ module BoringBackup::Commands
           BoringBackup::Tee::Sink.new(store:, writer:, thread:)
         end
 
-        sinks_fanout = BoringBackup::Tee.new(@sinks)
+        sinks_fanout = BoringBackup::Tee.new(@sinks, progress: @progress)
 
         begin
           IO.copy_stream(last_stdout, sinks_fanout)

data/lib/boring_backup/commands/doctor.rb

@@ -0,0 +1,133 @@
+module BoringBackup::Commands
+  Check = Struct.new(:name, :status, :detail, keyword_init: true) do
+    def failed? = status == :fail
+    def ok? = status == :ok
+  end
+
+  DoctorResult = Struct.new(:checks, keyword_init: true) do
+    def success? = checks.none?(&:failed?)
+
+    def failures = checks.select(&:failed?)
+  end
+
+  class Doctor
+    SOLID_QUEUE_SCHEDULE_FILE = "config/recurring.yml"
+    SIDEKIQ_CRON_SCHEDULE_FILE = "config/schedule.yml"
+    def self.execute = new.execute
+
+    def execute
+      checks = [
+        pg_dump_present,
+        pg_dump_version,
+        database_resolved,
+        stores_registered,
+        *config.stores.flat_map { |store| store_checks(store) },
+        *scheduler_checks
+      ]
+
+      DoctorResult.new(checks: checks.compact)
+    end
+
+    private
+
+    def check(name, status, detail = nil)
+      Check.new(name: name, status: status, detail: detail)
+    end
+
+    def pg_dump_present
+      if pg_dump_path
+        check("pg_dump", :ok, pg_dump_path)
+      else
+        check("pg_dump", :fail, "not found on PATH")
+      end
+    end
+
+    def pg_dump_path
+      return @pg_dump_path if defined?(@pg_dump_path)
+
+      @pg_dump_path = ENV.fetch("PATH", "").split(File::PATH_SEPARATOR)
+        .map { |dir| File.join(dir, "pg_dump") }
+        .find { |path| File.executable?(path) }
+    end
+
+    def pg_dump_version
+      return unless pg_dump_path
+
+      client = major_version(`#{pg_dump_path} --version`)
+      server = major_version(server_version)
+
+      return check("versions", :skip, "could not read server version") unless server
+      return check("versions", :skip, "could not read pg_dump version") unless client
+
+      if client >= server
+        check("versions", :ok, "pg_dump #{client}, server #{server}")
+      else
+        check("versions", :fail, "pg_dump #{client} is older than server #{server} — the dump may not restore")
+      end
+    end
+
+    def major_version(string)
+      string.to_s[/(\d+)/, 1]&.to_i
+    end
+
+    def server_version
+      return unless defined?(::ActiveRecord)
+
+      ::ActiveRecord::Base.connection.select_value("SHOW server_version")
+    rescue
+      nil
+    end
+
+    def database_resolved
+      database = config.pg_env["PGDATABASE"]
+
+      if database.to_s.empty?
+        check("database", :fail, "could not resolve PGDATABASE")
+      else
+        check("database", :ok, database)
+      end
+    end
+
+    def stores_registered
+      if config.stores.empty?
+        check("stores", :fail, "no stores registered")
+      else
+        check("stores", :ok, "#{config.stores.size} registered")
+      end
+    end
+
+    def store_checks(store)
+      store.validate!
+
+      [check(store.name, :ok, store.description)]
+    rescue => e
+      [check(store.name, :fail, e.message)]
+    end
+
+    def scheduler_checks
+      checks = [solid_queue_check, sidekiq_cron_check].compact
+
+      if checks.none?(&:ok?)
+        [check("scheduler detected", :skip, "no schedulers detected. Make sure BackupJob is executed in a cron or within a scheduler.")]
+      else
+        checks.select(&:ok?)
+      end
+    end
+
+    def solid_queue_check
+      if File.exist?(SOLID_QUEUE_SCHEDULE_FILE) && File.read(SOLID_QUEUE_SCHEDULE_FILE, mode: "r:UTF-8").include?("BoringBackup::BackupJob")
+        check("scheduler detected", :ok, "solid-queue: #{SOLID_QUEUE_SCHEDULE_FILE}")
+      end
+    end
+
+    def sidekiq_cron_check
+      if File.exist?(SIDEKIQ_CRON_SCHEDULE_FILE) && File.read(SIDEKIQ_CRON_SCHEDULE_FILE, mode: "r:UTF-8").include?("BoringBackup::BackupJob")
+        check("scheduler detected", :ok, "sidekiq-cron: #{SIDEKIQ_CRON_SCHEDULE_FILE}")
+      end
+    end
+
+    def config
+      @config ||= BoringBackup.config
+    end
+  end
+end

data/lib/boring_backup/configuration.rb

@@ -47,6 +47,10 @@ module BoringBackup
       [*@notifiers, sentinel].compact
     end
 
+    def silence_stdout!
+      @notifiers.reject! { |notifier| notifier.is_a?(BoringBackup::Notifiers::Stdout) }
+    end
+
     def ignore_tables
       Array(@ignore_tables).map { |table| table.to_s.strip }.reject(&:empty?).uniq
     end
@@ -62,17 +66,18 @@ module BoringBackup
     end
 
     def register(store_type)
-      raise BoringBackup::ConfigurationError, "`config.register` requires a block" unless block_given?
-
       store =
         case store_type.to_sym
-        when :s3 then BoringBackup::Stores::S3.new
+        when :s3 then build_s3_store
+        when :r2 then build_r2_store
         else raise BoringBackup::ConfigurationError, "unknown store type: #{store_type}"
         end
 
       @stores << store
 
-      yield store
+      yield store if block_given?
+
+      store
     end
 
     def notifier(type)
@@ -87,13 +92,31 @@ module BoringBackup
       end
     end
 
+    def build_s3_store
+      require_relative "stores/s3"
+
+      BoringBackup::Stores::S3.new
+    rescue LoadError
+      raise BoringBackup::ConfigurationError,
+        "the :s3 store needs the aws-sdk-s3 gem. Add `gem \"aws-sdk-s3\"` to your Gemfile."
+    end
+
+    def build_r2_store
+      require_relative "stores/r2"
+
+      BoringBackup::Stores::R2.new
+    rescue LoadError
+      raise BoringBackup::ConfigurationError,
+        "the :r2 store needs the aws-sdk-s3 gem. Add `gem \"aws-sdk-s3\"` to your Gemfile."
+    end
+
     def pg_env
       {
-        "PGHOST" => (pg_host || db_config[:host])&.to_s,
-        "PGPORT" => (pg_port || db_config[:port])&.to_s,
-        "PGUSER" => (pg_user || db_config[:username])&.to_s,
-        "PGPASSWORD" => (pg_password || db_config[:password])&.to_s,
-        "PGDATABASE" => (pg_database || db_config[:database])&.to_s
+        "PGHOST" => (pg_host || db_config[:host] || ENV["PGHOST"])&.to_s,
+        "PGPORT" => (pg_port || db_config[:port] || ENV["PGPORT"])&.to_s,
+        "PGUSER" => (pg_user || db_config[:username] || ENV["PGUSER"])&.to_s,
+        "PGPASSWORD" => (pg_password || db_config[:password] || ENV["PGPASSWORD"])&.to_s,
+        "PGDATABASE" => (pg_database || db_config[:database] || ENV["PGDATABASE"])&.to_s
       }.compact
     end
 

data/lib/boring_backup/notifiers/sentinel.rb

@@ -52,11 +52,11 @@ module BoringBackup::Notifiers
     private
 
     def normalized_host
-      uri = URI.parse(host)
+      return host if host.include?("://")
 
-      return host if uri.is_a?(URI::HTTP)
+      scheme = LOCAL_HOSTS.include?(host.split(":").first) ? "http" : "https"
 
-      "#{LOCAL_HOSTS.include?(uri.scheme) ? "http" : "https"}://#{host}"
+      "#{scheme}://#{host}"
     end
 
     def post(body)

data/lib/boring_backup/stores/r2.rb

@@ -0,0 +1,20 @@
+require "aws-sdk-s3"
+require_relative "s3"
+
+module BoringBackup::Stores
+  class R2 < S3
+    def name = :r2
+
+    def region
+      value = super
+
+      value.to_s.empty? ? "auto" : value
+    end
+
+    def validate!
+      super
+
+      raise BoringBackup::ConfigurationError, "endpoint is not configured" if endpoint.to_s.empty?
+    end
+  end
+end

data/lib/boring_backup/stores/s3.rb

@@ -18,11 +18,10 @@ module BoringBackup::Stores
       snow
     ].freeze
 
-    attr_accessor :bucket, :region, :access_key_id, :secret_access_key, :part_size, :thread_count
+    attr_accessor :bucket, :region, :access_key_id, :secret_access_key, :part_size, :thread_count, :endpoint
     attr_writer :storage_class
 
     def initialize
-      @bucket = ENV["AWS_S3_BUCKET"]
       @region = ENV["AWS_REGION"]
       @access_key_id = ENV["AWS_ACCESS_KEY_ID"]
       @secret_access_key = ENV["AWS_SECRET_ACCESS_KEY"]
@@ -37,6 +36,12 @@ module BoringBackup::Stores
       value.empty? ? nil : value.to_sym
     end
 
+    def name = :s3
+
+    def description
+      [bucket.to_s.empty? ? "no bucket" : "#{name}://#{bucket}", region].compact.join(" ")
+    end
+
     # Prefer Aws::S3::TransferManager for streaming uploads if available.
     # Aws::S3::Resource.upload_stream is deprecated in newer versions
     def backup!(key, stream)
@@ -67,13 +72,13 @@ module BoringBackup::Stores
         raise BoringBackup::DumpTooSmallError, "backup too small: #{BoringBackup.utils.human_size(bytes)} < min_size (#{BoringBackup.utils.human_size(config.min_size)})"
       end
 
-      Result.new(success: true, store: :s3, bytes:, key:, duration:)
+      Result.new(success: true, store: name, bytes:, key:, duration:)
     rescue => e
       duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
 
       cleanup!(key) if upload_attempted
 
-      Result.new(success: false, error: e, store: :s3, bytes:, key:, duration:)
+      Result.new(success: false, error: e, store: name, bytes:, key:, duration:)
     end
 
     def validate!
@@ -110,9 +115,10 @@ module BoringBackup::Stores
 
     def s3_config
       {
-        region: region,
-        access_key_id: access_key_id,
-        secret_access_key: secret_access_key
+        endpoint:,
+        region:,
+        access_key_id:,
+        secret_access_key:
       }.compact
     end
   end

data/lib/boring_backup/stores/store.rb

@@ -1,5 +1,13 @@
 module BoringBackup::Stores
   class Store
+    def name
+      self.class.name.split("::").last.downcase.to_sym
+    end
+
+    def description
+      name
+    end
+
     private
 
     def config

data/lib/boring_backup/stores.rb

@@ -1,3 +1,2 @@
 require_relative "stores/store"
 require_relative "stores/result"
-require_relative "stores/s3" # TODO: load conditionally

data/lib/boring_backup/tee.rb

@@ -22,11 +22,20 @@ module BoringBackup
       end
     end
 
-    def initialize(sinks) = @sinks = sinks
+    attr_reader :bytes
+
+    def initialize(sinks, progress: nil)
+      @sinks = sinks
+      @progress = progress
+      @bytes = 0
+    end
 
     def write(chunk)
       @sinks.each { |sink| sink.write(chunk) }
 
+      @bytes += chunk.bytesize
+      @progress&.call(@bytes)
+
       chunk.bytesize
     end
   end

data/lib/boring_backup/version.rb

@@ -1,3 +1,3 @@
 module BoringBackup
-  VERSION = "0.4.0"
+  VERSION = "0.6.0"
 end

data/lib/boring_backup.rb

@@ -4,6 +4,7 @@ require_relative "boring_backup/tee"
 require_relative "boring_backup/utils"
 require_relative "boring_backup/stores"
 require_relative "boring_backup/commands/backup"
+require_relative "boring_backup/commands/doctor"
 require_relative "boring_backup/notifiers/slack"
 require_relative "boring_backup/notifiers/stdout"
 require_relative "boring_backup/notifiers/sentinel"
@@ -53,6 +54,16 @@ module BoringBackup
       require env_file if File.exist?(env_file)
     end
 
+    def environment
+      return ::Rails.env.to_s if defined?(::Rails) && ::Rails.respond_to?(:env)
+
+      ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+    end
+
+    def production?
+      environment == "production"
+    end
+
     def notify(result)
       config.notifiers.each do |notifier|
         notifier.notify(result)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: boring-backup
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Georgi Mitrev
@@ -24,19 +24,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: aws-sdk-s3
+  name: pastel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-spinner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '0'
 description: The simplest way to add recurring database backups to your project with
   minimal setup required.
 email:
@@ -55,6 +83,7 @@ files:
 - lib/boring_backup.rb
 - lib/boring_backup/cli.rb
 - lib/boring_backup/commands/backup.rb
+- lib/boring_backup/commands/doctor.rb
 - lib/boring_backup/configuration.rb
 - lib/boring_backup/jobs/backup_job.rb
 - lib/boring_backup/notifiers/sentinel.rb
@@ -62,6 +91,7 @@ files:
 - lib/boring_backup/notifiers/stdout.rb
 - lib/boring_backup/plugins/rails.rb
 - lib/boring_backup/stores.rb
+- lib/boring_backup/stores/r2.rb
 - lib/boring_backup/stores/result.rb
 - lib/boring_backup/stores/s3.rb
 - lib/boring_backup/stores/store.rb