boring-backup 0.5.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90fcf205730a58bf45284b04cd2a7be2604158b5bcd983c2bd3bdaada0fb06c0
-  data.tar.gz: b17bae14e94295a24d68da3592b3baa238bc1a10fb76bcad464ae515bd7cc46c
+  metadata.gz: 343fecddfbccfc03c5216673a667596b7e6af0ccd4e7edc6c03e864d80f7727b
+  data.tar.gz: cff420aa2b49fcae03d06d03c95d6f5e4d5813b112e66464b1829ef4c069ec0b
 SHA512:
-  metadata.gz: 0317b2fbf1d5768a0b0cfe28e351817d51065579dca37007d6236956c07f474c529297237358c36d4cd572d017bcb1f79209b5c5c4827fb036b169bb2ebc1339
-  data.tar.gz: a3481f64a9c95894830fb1bc92964c154a79796febe716c8e8c27ea09b5de110ce0613386adcdf3703d619a8794730a7470dd09189d504b55cc682b64bea3695
+  metadata.gz: 2f9c315742cb0c19493947d542e7657af569eb1ddc78890839cf239300276707e3b060ff9d02161f3535c5e687aa8facf14d684c859cb14d2d7187af69344a78
+  data.tar.gz: 1dbff91a051d57ab40703c9e760c435789a05c8b671742b795714847dd5385ac4308a803b6f4c36e6fa99f4d7cce5e63a4404ce9fbc56090d028f454c6181016

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## [Unreleased]
 
+## [0.6.1] - 2026-08-12
+
+- The `:r2` store now defaults to the `standard` storage class instead of inheriting `standard_ia` from
+  `:s3`. R2's free tier does not cover Infrequent Access, and its per-request charges round up to a full
+  million, so a single backup a month cost $9.00.
+
+## [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

data/README.md

@@ -21,12 +21,18 @@ 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` store, add the AWS SDK to your `Gemfile` as well:
+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
@@ -66,9 +72,11 @@ anything to disk. Use any scheduler or even cron to run it periodically.
 All configuration options can be edited in the initializer:
 
 ```rb
-# config/initializers/boring-backup.rb
+# 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
@@ -76,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
@@ -108,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

@@ -140,7 +140,7 @@ module BoringBackup
     def check_line(check, width)
       mark, colour = CHECK_MARKS.fetch(check.status)
 
-      "#{pastel.decorate(mark, colour)} #{pastel.bold(check.name.ljust(width))}  #{pastel.dim(check.detail.to_s)}"
+      "#{pastel.decorate(mark, colour)} #{pastel.bold(check.name.to_s.ljust(width))}  #{pastel.dim(check.detail.to_s)}"
     end
 
     def doctor_verdict(result)
@@ -210,19 +210,12 @@ module BoringBackup
       clear_line
     end
 
-    def env_store?
-      !ENV["AWS_S3_BUCKET"].to_s.empty?
-    end
-
     def configured_store_summary
-      return "S3 — s3://#{ENV["AWS_S3_BUCKET"]} (from ENV)" if env_store?
-
       "S3 — #{INITIALIZER}" if File.exist?(INITIALIZER)
     end
 
     def configure_store
       return if File.exist?(INITIALIZER)
-      return if env_store? && prompt.yes?("Use the S3 bucket already in ENV (#{ENV["AWS_S3_BUCKET"]})?")
 
       prompt.select("Where should backups go?") do |menu|
         menu.choice "S3 (or S3-compatible: R2, MinIO, Spaces)", :s3
@@ -236,12 +229,7 @@ module BoringBackup
 
     def write_initializer(store)
       unless store
-        if File.exist?(INITIALIZER)
-          say_status :identical, INITIALIZER, :blue
-        else
-          say_status :skip, "#{INITIALIZER} not needed — the S3 store reads its config from ENV", :blue
-        end
-
+        say_status :identical, INITIALIZER, :blue
         return
       end
 

data/lib/boring_backup/commands/backup.rb

@@ -1,7 +1,7 @@
 require "open3"
 
 module BoringBackup::Commands
-  CommandResult = Struct.new(:error, :store_results, keyword_init: true) do
+  CommandResult = Struct.new(:error, :store_results, :engine, keyword_init: true) do
     def success?
       status == :success
     end
@@ -42,6 +42,8 @@ module BoringBackup::Commands
     end
 
     def execute
+      @engine = BoringBackup::Engine.info
+
       perform_sanity_check!
 
       commands = [config.dump_command]
@@ -57,7 +59,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
@@ -80,7 +82,7 @@ module BoringBackup::Commands
         raise BoringBackup::DumpFailedError, "pipeline failed" unless wait_threads.all? { |t| t.value.success? }
       end
 
-      CommandResult.new(store_results: @store_results)
+      CommandResult.new(store_results: @store_results, engine: @engine)
     rescue BoringBackup::DumpFailedError => error
       # The dump stream itself failed, so uploads that finished are truncated copies of a bad stream — delete them.
       # Collect the results first: if copy_stream raised, the collection line above never ran. Sinks are already
@@ -89,9 +91,9 @@ module BoringBackup::Commands
 
       cleanup_uploaded_stores!
 
-      CommandResult.new(error:, store_results: @store_results)
+      CommandResult.new(error:, store_results: @store_results, engine: @engine)
     rescue => error
-      CommandResult.new(error:, store_results: @store_results)
+      CommandResult.new(error:, store_results: @store_results, engine: @engine)
     end
 
     private

data/lib/boring_backup/commands/doctor.rb

@@ -1,6 +1,7 @@
 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
@@ -10,8 +11,8 @@ module BoringBackup::Commands
   end
 
   class Doctor
-    RECURRING = "config/recurring.yml"
-
+    SOLID_QUEUE_SCHEDULE_FILE = "config/recurring.yml"
+    SIDEKIQ_CRON_SCHEDULE_FILE = "config/schedule.yml"
     def self.execute = new.execute
 
     def execute
@@ -21,7 +22,7 @@ module BoringBackup::Commands
         database_resolved,
         stores_registered,
         *config.stores.flat_map { |store| store_checks(store) },
-        schedule_registered
+        *scheduler_checks
       ]
 
       DoctorResult.new(checks: checks.compact)
@@ -42,39 +43,27 @@ module BoringBackup::Commands
     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) }
+      BoringBackup::Engine.pg_dump_path
     end
 
     def pg_dump_version
       return unless pg_dump_path
 
-      client = major_version(`#{pg_dump_path} --version`)
-      server = major_version(server_version)
+      client = BoringBackup::Engine.client_version
+      server = BoringBackup::Engine.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
+      if major(client) >= major(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
+    def major(version)
+      Gem::Version.new(version).segments.first
     end
 
     def database_resolved
@@ -103,29 +92,26 @@ module BoringBackup::Commands
       [check(store.name, :fail, e.message)]
     end
 
-    def schedule_registered
-      return check("schedule", :skip, "no #{RECURRING} — using cron or another scheduler?") unless File.exist?(RECURRING)
+    def scheduler_checks
+      checks = [solid_queue_check, sidekiq_cron_check].compact
 
-      unless File.read(RECURRING, mode: "r:UTF-8").include?("BoringBackup::BackupJob")
-        return check("schedule", :fail, "#{RECURRING} does not run BoringBackup::BackupJob")
+      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
 
-      unless backup_job_loadable?
-        return check("schedule", :fail, "BoringBackup::BackupJob won't load — is activejob in the Gemfile?")
+    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
-
-      check("schedule", :ok, "#{RECURRING} runs BoringBackup::BackupJob")
     end
 
-    def backup_job_loadable?
-      return false unless defined?(::ActiveJob)
-
-      Object.const_get("ActiveJob::Base")
-      require "boring_backup/jobs/backup_job"
-
-      true
-    rescue LoadError, NameError
-      false
+    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

data/lib/boring_backup/configuration.rb

@@ -69,6 +69,7 @@ module BoringBackup
       store =
         case store_type.to_sym
         when :s3 then build_s3_store
+        when :r2 then build_r2_store
         else raise BoringBackup::ConfigurationError, "unknown store type: #{store_type}"
         end
 
@@ -100,13 +101,22 @@ module BoringBackup
         "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/engine.rb

@@ -0,0 +1,46 @@
+module BoringBackup
+  module Engine
+    extend self
+
+    NAME = "postgresql"
+
+    def info
+      client = client_version
+      server = server_version
+
+      return if client.nil? && server.nil?
+
+      {name: NAME, client: client, server: server}
+    end
+
+    def client_version
+      return unless pg_dump_path
+
+      version(`#{pg_dump_path} --version`)
+    rescue
+      nil
+    end
+
+    def server_version
+      return unless defined?(::ActiveRecord)
+
+      version(::ActiveRecord::Base.connection.select_value("SHOW server_version"))
+    rescue
+      nil
+    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
+
+    private
+
+    def version(string)
+      string.to_s[/\d+(?:\.\d+)*/]
+    end
+  end
+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)
@@ -85,6 +85,7 @@ module BoringBackup::Notifiers
         status: result.status,
         error: result.error&.message,
         database: BoringBackup.config.pg_env["PGDATABASE"],
+        engine: result.engine,
         bytes: store_results.filter_map(&:bytes).max,
         duration: store_results.filter_map(&:duration).max&.round(3),
         stores: store_results.map do |store_result|

data/lib/boring_backup/stores/r2.rb

@@ -0,0 +1,24 @@
+require "aws-sdk-s3"
+require_relative "s3"
+
+module BoringBackup::Stores
+  class R2 < S3
+    def name = :r2
+
+    def default_storage_class = :standard
+
+    def storage_classes = %i[standard standard_ia]
+
+    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

@@ -2,33 +2,16 @@ require "aws-sdk-s3"
 
 module BoringBackup::Stores
   class S3 < Store
-    DEFAULT_STORAGE_CLASS = :standard_ia
-
-    STORAGE_CLASSES = %i[
-      standard
-      standard_ia
-      onezone_ia
-      intelligent_tiering
-      glacier_ir
-      glacier
-      deep_archive
-      reduced_redundancy
-      express_onezone
-      outposts
-      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"]
       @part_size = ENV.fetch("BB_S3_PART_SIZE", 8 * 1024 * 1024).to_i
       @thread_count = ENV.fetch("BB_S3_THREAD_COUNT", 2).to_i
-      @storage_class = ENV.fetch("BB_S3_STORAGE_CLASS", DEFAULT_STORAGE_CLASS)
+      @storage_class = ENV.fetch("BB_S3_STORAGE_CLASS", default_storage_class)
     end
 
     def storage_class
@@ -37,10 +20,28 @@ module BoringBackup::Stores
       value.empty? ? nil : value.to_sym
     end
 
-    def name = "s3"
+    def default_storage_class = :standard_ia
+
+    def storage_classes
+      %i[
+        standard
+        standard_ia
+        onezone_ia
+        intelligent_tiering
+        glacier_ir
+        glacier
+        deep_archive
+        reduced_redundancy
+        express_onezone
+        outposts
+        snow
+      ]
+    end
+
+    def name = :s3
 
     def description
-      [bucket.to_s.empty? ? "no bucket" : "s3://#{bucket}", region].compact.join(" ")
+      [bucket.to_s.empty? ? "no bucket" : "#{name}://#{bucket}", region].compact.join(" ")
     end
 
     # Prefer Aws::S3::TransferManager for streaming uploads if available.
@@ -73,13 +74,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!
@@ -90,9 +91,9 @@ module BoringBackup::Stores
           "access_key_id and secret_access_key must both be set, or both left blank to use the default AWS credential chain"
       end
 
-      if storage_class && !STORAGE_CLASSES.include?(storage_class)
+      if storage_class && !storage_classes.include?(storage_class)
         raise BoringBackup::ConfigurationError,
-          "unknown storage class: #{storage_class.inspect} (expected one of: #{STORAGE_CLASSES.map(&:inspect).join(", ")}, or nil to use the bucket default)"
+          "unknown storage class: #{storage_class.inspect} (expected one of: #{storage_classes.map(&:inspect).join(", ")}, or nil to use the bucket default)"
       end
     end
 
@@ -116,9 +117,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,7 +1,7 @@
 module BoringBackup::Stores
   class Store
     def name
-      self.class.name.split("::").last.downcase
+      self.class.name.split("::").last.downcase.to_sym
     end
 
     def description

data/lib/boring_backup/version.rb

@@ -1,3 +1,3 @@
 module BoringBackup
-  VERSION = "0.5.0"
+  VERSION = "0.6.1"
 end

data/lib/boring_backup.rb

@@ -2,6 +2,7 @@ require_relative "boring_backup/version"
 require_relative "boring_backup/configuration"
 require_relative "boring_backup/tee"
 require_relative "boring_backup/utils"
+require_relative "boring_backup/engine"
 require_relative "boring_backup/stores"
 require_relative "boring_backup/commands/backup"
 require_relative "boring_backup/commands/doctor"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: boring-backup
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Georgi Mitrev
@@ -85,12 +85,14 @@ files:
 - lib/boring_backup/commands/backup.rb
 - lib/boring_backup/commands/doctor.rb
 - lib/boring_backup/configuration.rb
+- lib/boring_backup/engine.rb
 - lib/boring_backup/jobs/backup_job.rb
 - lib/boring_backup/notifiers/sentinel.rb
 - lib/boring_backup/notifiers/slack.rb
 - 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
@@ -120,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.17
 specification_version: 4
 summary: Hassle-free database backups
 test_files: []