kamal-backup 0.3.0.beta4 → 0.3.0.beta6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78778951b0506ad5ef03f4e644f19a76ab1f7a882512f2a65cf23e1e53557669
-  data.tar.gz: 24c346091e522d02a9233bdffec2b86e7acc3e704485498039d6506fc9780f77
+  metadata.gz: 68d3201dc26c940938479dc76d1c0e17b206676ae69610d736a69879a78de21c
+  data.tar.gz: dd58ee38da83d4652515b108869e5fe441a25d80697b7db3ea1c606240a44766
 SHA512:
-  metadata.gz: a7642dd936a98360f3fb2230a7886878342ba4bb5c68df5ee250bb11ad6d917cfafcc72f86a9d5759edba35d928c298d4639eabab0b252ed54bf2f1e7fad67af
-  data.tar.gz: 24bd2e79792381abf43a3f9f846eb2665596d1b67e4a47cd687717009c119ab51a830447ee52dc37ce40ae10da19bc08ce0d75ce2dccf1d1cf3e289c910ecdc3
+  metadata.gz: 37ca5f6463fe6eb76c2f6994a783e2180f3eecff24e834550743c1f9130e6ad3019ce1e296dc44ac523a36c065f1e05ac00aaaec7c7224254daea0c2d683d7a0
+  data.tar.gz: '0985cd5e2eb8a52db5dcc4265271eddde1513c8c8db80d0aec21ee3ca1be0bd42e2adcd60ffeb942aa7bb2d926cbad69f5d89051485ce64145f3f5c821abe3bb'

data/README.md

@@ -141,7 +141,7 @@ Run the release helper from a clean `master` checkout:
 bin/release 0.2.9
 ```
 
-It updates `lib/kamal_backup/version.rb`, runs the test suite and docs build, commits `Release 0.2.9`, and pushes `master`. CI publishes the RubyGem and Docker image tags first, then creates `v0.2.9`, the GitHub release, and the docs deployment from the release commit.
+It updates `lib/kamal_backup/version.rb`, syncs `Gemfile.lock`, commits `Release 0.2.9`, and pushes `master`. CI runs the test suite and docs build, publishes the RubyGem and Docker image tags, then creates `v0.2.9`, the GitHub release, and the docs deployment from the release commit.
 
 Use `bin/release 0.2.9 --no-push` to prepare the commit locally without publishing.
 

data/lib/kamal_backup/app.rb

@@ -31,10 +31,9 @@ module KamalBackup
       config.validate_backup
       require_restic!
 
-      timestamp = current_timestamp
       restic.ensure_repository
-      databases.each { |database| database.backup(restic, timestamp) }
-      restic.backup_paths(config.backup_paths, tags: ["type:files", "run:#{timestamp}"])
+      databases.each { |database| database.backup(restic) }
+      restic.backup_paths(config.backup_paths, tags: ["type:files"])
 
       if config.forget_after_backup?
         restic.forget_after_success
@@ -135,10 +134,6 @@ module KamalBackup
     end
 
     private
-      def current_timestamp
-        Time.now.utc.strftime("%Y%m%dT%H%M%SZ")
-      end
-
       def build_restore_result(scope, snapshot)
         started_at = Time.now.utc
         result = Schema.record(

data/lib/kamal_backup/cli.rb

@@ -20,11 +20,17 @@ module KamalBackup
       end
 
       def direct_app
-        @direct_app ||= App.new(config: Config.new(env: command_env), redactor: redactor)
+        @direct_app ||= App.new(
+          config: Config.new(env: command_env),
+          redactor: redactor
+        )
       end
 
-      def local_app
-        @local_app ||= App.new(config: local_command_config, redactor: redactor)
+      def local_restore_app
+        @local_restore_app ||= App.new(
+          config: local_command_config,
+          redactor: redactor
+        )
       end
 
       def local_preferences
@@ -65,7 +71,9 @@ module KamalBackup
           redactor: redactor,
           config_file: options[:config_file],
           destination: options[:destination],
-          env: command_env
+          env: command_env,
+          stdout: $stdout,
+          stderr: $stderr
         )
       end
 
@@ -94,9 +102,11 @@ module KamalBackup
 
         result = bridge.execute_on_accessory(
           accessory_name: accessory_name,
-          command: Shellwords.join(argv)
+          command: Shellwords.join(argv),
+          stream: true
         )
-        print(result.stdout)
+        print(result.stdout) unless result.streamed
+        $stderr.print(result.stderr) if !result.streamed && !result.stderr.empty?
         result
       end
 
@@ -276,7 +286,7 @@ module KamalBackup
       desc "local [SNAPSHOT]", "Restore the backup into the local database and Active Storage path"
       def local(snapshot = "latest")
         confirm!("Restore #{snapshot} into the local database and Active Storage path? This will overwrite local data.")
-        puts(JSON.pretty_generate(local_app.restore_to_local_machine(snapshot)))
+        puts(JSON.pretty_generate(local_restore_app.restore_to_local_machine(snapshot)))
       end
 
       method_option :"confirm-production-restore", type: :boolean, default: false, desc: "Confirm production restore without interactive prompts"
@@ -301,9 +311,9 @@ module KamalBackup
       desc "local [SNAPSHOT]", "Run a restore drill on the local machine"
       def local(snapshot = "latest")
         confirm!("Run a local restore drill for #{snapshot}? This will overwrite local data.")
-        result = local_app.drill_on_local_machine(snapshot, check_command: options[:check])
+        result = local_restore_app.drill_on_local_machine(snapshot, check_command: options[:check])
         puts(JSON.pretty_generate(result))
-        exit(1) if local_app.drill_failed?(result)
+        exit(1) if local_restore_app.drill_failed?(result)
       end
 
       method_option :database, type: :string, desc: "Scratch database name for PostgreSQL or MySQL"
@@ -389,7 +399,9 @@ module KamalBackup
 
     def self.start(argv = ARGV, env: ENV)
       self.command_env = env
-      super(normalize_global_options(argv))
+      Command.with_output(CommandOutput.new(io: $stderr)) do
+        super(normalize_global_options(argv))
+      end
     rescue Error => e
       warn("kamal-backup: #{Redactor.new(env: env).redact_string(e.message)}")
       exit(1)

data/lib/kamal_backup/command.rb

@@ -1,4 +1,6 @@
 require "open3"
+require "securerandom"
+require "shellwords"
 require_relative "errors"
 
 module KamalBackup
@@ -18,14 +20,109 @@ module KamalBackup
 
     def display(redactor)
       env_prefix = env.keys.sort.map { |key| "#{key}=#{redactor.redact_value(key, env[key])}" }
-      redactor.redact_string((env_prefix + argv).join(" "))
+      redactor.redact_string((env_prefix + [argv.shelljoin]).join(" "))
     end
   end
 
-  CommandResult = Struct.new(:stdout, :stderr, :status, keyword_init: true)
+  CommandResult = Struct.new(:stdout, :stderr, :status, :streamed, keyword_init: true)
+
+  class CommandOutput
+    def initialize(io: $stdout)
+      @io = io
+      @mutex = Mutex.new
+      @buffers = {}
+    end
+
+    def info(message, redactor:)
+      write_line("  INFO #{redactor.redact_string(message)}")
+    end
+
+    def command_start(spec, redactor:)
+      id = SecureRandom.hex(4)
+      started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      display = spec.display(redactor)
+
+      write_line("  INFO [#{id}] Running #{display} locally")
+      write_line(" DEBUG [#{id}] Command: #{display}")
+
+      { id: id, started_at: started_at, redactor: redactor }
+    end
+
+    def command_output(context, _stream, data, redactor:)
+      raw = data.to_s
+      return if raw.empty?
+
+      synchronize do
+        key = [context.fetch(:id), _stream]
+        @buffers[key] = "#{@buffers[key]}#{raw}"
+        flush_complete_output_lines(context, key, redactor: redactor)
+      end
+    end
+
+    def command_exit(context, status)
+      runtime = Process.clock_gettime(Process::CLOCK_MONOTONIC) - context.fetch(:started_at)
+      result = status.to_i.zero? ? "successful" : "failed"
+
+      synchronize do
+        flush_output_buffers(context)
+        @io.puts("  INFO [#{context.fetch(:id)}] Finished in #{format("%.3f seconds", runtime)} with exit status #{status} (#{result}).")
+      end
+    end
+
+    private
+      def write_line(message)
+        synchronize { @io.puts(message) }
+      end
+
+      def synchronize(&block)
+        @mutex.synchronize(&block)
+      end
+
+      def flush_complete_output_lines(context, key, redactor:)
+        buffer = @buffers.fetch(key)
+        output = +""
+
+        while (index = buffer.index("\n"))
+          output << buffer.slice!(0..index)
+        end
+
+        @buffers[key] = buffer
+        write_output(context, output, redactor: redactor) unless output.empty?
+      end
+
+      def flush_output_buffers(context)
+        id = context.fetch(:id)
+        keys = @buffers.keys.select { |key_id, _stream| key_id == id }
+
+        keys.each do |key|
+          output = @buffers.delete(key)
+          next if output.to_s.empty?
+
+          write_output(context, output, redactor: context.fetch(:redactor))
+          @io.puts unless output.end_with?("\n")
+        end
+      end
+
+      def write_output(context, output, redactor:)
+        redactor.redact_string(output).each_line do |line|
+          @io.print(" DEBUG [#{context.fetch(:id)}] \t#{line}")
+        end
+        @io.flush if @io.respond_to?(:flush)
+      end
+  end
 
   class Command
     class << self
+      attr_accessor :output
+
+      def with_output(output)
+        previous_output = self.output
+        self.output = output
+        yield
+      ensure
+        self.output = previous_output
+      end
+
       def available?(name)
         ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).any? do |dir|
           path = File.join(dir, name)
@@ -33,9 +130,23 @@ module KamalBackup
         end
       end
 
-      def capture(spec, input: nil, redactor:)
-        stdout, stderr, status = Open3.capture3(spec.env, *spec.argv, stdin_data: input)
-        result = CommandResult.new(stdout: stdout, stderr: stderr, status: status.exitstatus)
+      def capture(spec, input: nil, redactor:, log: true, log_output: true, tee_stdout: nil, tee_stderr: nil)
+        output = log ? self.output : nil
+        return capture_quietly(spec, input: input, redactor: redactor) unless output || tee_stdout || tee_stderr
+
+        context = output&.command_start(spec, redactor: redactor)
+        stdout, stderr, status = popen_capture(
+          spec,
+          input: input,
+          redactor: redactor,
+          output: output,
+          context: context,
+          log_output: log_output,
+          tee_stdout: tee_stdout,
+          tee_stderr: tee_stderr
+        )
+        output&.command_exit(context, status.exitstatus)
+        result = CommandResult.new(stdout: stdout, stderr: stderr, status: status.exitstatus, streamed: !!(tee_stdout || tee_stderr))
 
         if status.success?
           result
@@ -46,7 +157,72 @@ module KamalBackup
         raise command_not_found(spec, e)
       end
 
+      def collect_stream(io, command_output: self.output, context: nil, stream: :stdout, log_output: true, tee_io: nil, redactor: nil)
+        captured_output = +""
+        tee_buffer = +""
+
+        loop do
+          chunk = io.readpartial(16 * 1024)
+          captured_output << chunk
+          command_output&.command_output(context, stream, chunk, redactor: redactor) if log_output && context
+          tee_buffer = tee_stream(tee_io, redactor, tee_buffer, chunk) if tee_io
+        rescue EOFError
+          flush_tee_stream(tee_io, redactor, tee_buffer) if tee_io
+          break
+        end
+
+        captured_output
+      end
+
       private
+        def tee_stream(io, redactor, buffer, chunk)
+          buffer << chunk
+
+          while (index = buffer.index("\n"))
+            io.print(redactor.redact_string(buffer.slice!(0..index)))
+          end
+
+          io.flush if io.respond_to?(:flush)
+          buffer
+        end
+
+        def flush_tee_stream(io, redactor, buffer)
+          return if buffer.empty?
+
+          io.print(redactor.redact_string(buffer))
+          io.flush if io.respond_to?(:flush)
+        end
+
+        def capture_quietly(spec, input:, redactor:)
+          stdout, stderr, status = Open3.capture3(spec.env, *spec.argv, stdin_data: input)
+          result = CommandResult.new(stdout: stdout, stderr: stderr, status: status.exitstatus, streamed: false)
+
+          if status.success?
+            result
+          else
+            raise command_failure(spec, status.exitstatus, stdout, stderr, redactor)
+          end
+        end
+
+        def popen_capture(spec, input:, redactor:, output:, context:, log_output:, tee_stdout:, tee_stderr:)
+          Open3.popen3(spec.env, *spec.argv) do |stdin, stdout, stderr, wait_thread|
+            stdin_writer = Thread.new do
+              stdin.write(input) if input
+            ensure
+              stdin.close unless stdin.closed?
+            end
+            stdout_reader = Thread.new do
+              collect_stream(stdout, command_output: output, context: context, stream: :stdout, log_output: log_output, tee_io: tee_stdout, redactor: redactor)
+            end
+            stderr_reader = Thread.new do
+              collect_stream(stderr, command_output: output, context: context, stream: :stderr, log_output: log_output, tee_io: tee_stderr, redactor: redactor)
+            end
+
+            stdin_writer.join
+            [stdout_reader.value, stderr_reader.value, wait_thread.value]
+          end
+        end
+
         def command_failure(spec, status, stdout, stderr, redactor)
           CommandError.new(
             "command failed (#{status}): #{spec.display(redactor)}\n#{redactor.redact_string(stderr)}",

data/lib/kamal_backup/databases/base.rb

@@ -24,11 +24,11 @@ module KamalBackup
         @redactor = redactor
       end
 
-      def backup(restic, timestamp)
+      def backup(restic)
         restic.backup_stream(
           dump_command,
-          filename: database_filename(timestamp),
-          tags: backup_tags(timestamp)
+          filename: database_filename,
+          tags: backup_tags
         )
       end
 
@@ -41,14 +41,14 @@ module KamalBackup
         restic.pipe_dump_to_command(snapshot, filename, scratch_restore_command(target))
       end
 
-      def database_filename(timestamp)
+      def database_filename
         app = config.app_name.gsub(/[^A-Za-z0-9_.-]+/, "-")
         database = config.database_name.gsub(/[^A-Za-z0-9_.-]+/, "-")
-        "databases-#{app}-#{database}-#{adapter_name}-#{timestamp}.#{dump_extension}"
+        "databases/#{app}/#{database}/#{adapter_name}.#{dump_extension}"
       end
 
-      def backup_tags(timestamp)
-        ["type:database", "database:#{config.database_name}", "adapter:#{adapter_name}", "run:#{timestamp}"]
+      def backup_tags
+        ["type:database", "database:#{config.database_name}", "adapter:#{adapter_name}"]
       end
 
       def adapter_name

data/lib/kamal_backup/databases/sqlite.rb

@@ -13,7 +13,7 @@ module KamalBackup
         "sqlite3"
       end
 
-      def backup(restic, timestamp)
+      def backup(restic)
         source = sqlite_source
         Tempfile.create(["kamal-backup-", ".sqlite3"]) do |tempfile|
           tempfile.close
@@ -23,8 +23,8 @@ module KamalBackup
           )
           restic.backup_file(
             tempfile.path,
-            filename: database_filename(timestamp),
-            tags: backup_tags(timestamp)
+            filename: database_filename,
+            tags: backup_tags
           )
         end
       end

data/lib/kamal_backup/kamal_bridge.rb

@@ -7,12 +7,14 @@ module KamalBackup
     DEFAULT_CONFIG_FILE = "config/deploy.yml"
     VERSION_LINE_PATTERN = /\A\d+(?:\.\d+)+(?:[-.][A-Za-z0-9]+)*\z/
 
-    def initialize(redactor:, config_file: nil, destination: nil, env: ENV, cwd: Dir.pwd)
+    def initialize(redactor:, config_file: nil, destination: nil, env: ENV, cwd: Dir.pwd, stdout: $stdout, stderr: $stderr)
       @redactor = redactor
       @config_file = config_file
       @destination = destination
       @env = env
       @cwd = cwd
+      @stdout = stdout
+      @stderr = stderr
     end
 
     def accessory_name(preferred: nil)
@@ -50,8 +52,8 @@ module KamalBackup
       accessory_secret_placeholders(accessory_name).merge(accessory_clear_env(accessory_name))
     end
 
-    def execute_on_accessory(accessory_name:, command:)
-      capture_kamal(kamal_exec_argv(accessory_name, command))
+    def execute_on_accessory(accessory_name:, command:, stream: false)
+      capture_kamal(kamal_exec_argv(accessory_name, command), stream: stream)
     end
 
     def remote_version(accessory_name:)
@@ -212,13 +214,19 @@ module KamalBackup
         argv
       end
 
-      def capture_kamal(argv)
+      def capture_kamal(argv, stream: false)
         spec = CommandSpec.new(argv: argv)
+        options = {
+          redactor: @redactor,
+          log_output: false,
+          tee_stdout: stream ? @stdout : nil,
+          tee_stderr: stream ? @stderr : nil
+        }
 
         if defined?(Bundler)
-          Bundler.with_unbundled_env { Command.capture(spec, redactor: @redactor) }
+          Bundler.with_unbundled_env { Command.capture(spec, **options) }
         else
-          Command.capture(spec, redactor: @redactor)
+          Command.capture(spec, **options)
         end
       end
 

data/lib/kamal_backup/restic.rb

@@ -16,7 +16,7 @@ module KamalBackup
     end
 
     def ensure_repository
-      run(%w[snapshots --json])
+      run(%w[snapshots --json], log_output: false)
     rescue CommandError => e
       if config.restic_init_if_missing?
         log("restic repository not ready, running restic init")
@@ -28,7 +28,7 @@ module KamalBackup
 
     def backup_stream(command, filename:, tags:)
       restic_command = CommandSpec.new(
-        argv: ["restic", "backup", "--stdin", "--stdin-filename", filename] + tag_args(common_tags + tags),
+        argv: ["restic", "backup"] + host_args + ["--stdin", "--stdin-filename", filename] + tag_args(common_tags + tags),
         env: restic_env
       )
       log("backing up stream as #{filename}")
@@ -37,20 +37,23 @@ module KamalBackup
 
     def backup_file(path, filename:, tags:)
       command = CommandSpec.new(
-        argv: ["restic", "backup", "--stdin", "--stdin-filename", filename] + tag_args(common_tags + tags),
+        argv: ["restic", "backup"] + host_args + ["--stdin", "--stdin-filename", filename] + tag_args(common_tags + tags),
         env: restic_env
       )
       log("backing up file content as #{filename}")
 
       File.open(path, "rb") do |file|
+        output = Command.output
+        context = output&.command_start(command, redactor: redactor)
         Open3.popen3(command.env, *command.argv) do |stdin, stdout, stderr, wait_thread|
-          stdout_reader = Thread.new { stdout.read }
-          stderr_reader = Thread.new { stderr.read }
+          stdout_reader = Thread.new { Command.collect_stream(stdout, command_output: output, context: context, stream: :stdout, redactor: redactor) }
+          stderr_reader = Thread.new { Command.collect_stream(stderr, command_output: output, context: context, stream: :stderr, redactor: redactor) }
           IO.copy_stream(file, stdin)
           stdin.close
           out = stdout_reader.value
           err = stderr_reader.value
           status = wait_thread.value
+          output&.command_exit(context, status.exitstatus)
           raise_command_error(command, status, out, err) unless status.success?
 
           CommandResult.new(stdout: out, stderr: err, status: status.exitstatus)
@@ -66,7 +69,7 @@ module KamalBackup
       if paths.any?
         path_tags = paths.map { |path| "path:#{config.backup_path_label(path)}" }
         log("backing up #{paths.size} file path(s): #{paths.join(", ")}")
-        run(["backup"] + paths + tag_args(common_tags + tags + path_tags))
+        run(["backup"] + host_args + paths + tag_args(common_tags + tags + path_tags))
       end
     end
 
@@ -99,7 +102,7 @@ module KamalBackup
     end
 
     def snapshots_json(tags: common_tags)
-      output = run(["snapshots", "--json"] + filter_tag_args(tags)).stdout
+      output = run(["snapshots", "--json"] + filter_tag_args(tags), log_output: false).stdout
       snapshots = JSON.parse(output)
       required_tags = tags.compact
       snapshots.select do |snapshot|
@@ -116,7 +119,7 @@ module KamalBackup
     end
 
     def ls_json(snapshot)
-      output = run(["ls", "--json", snapshot]).stdout
+      output = run(["ls", "--json", snapshot], log_output: false).stdout
       output.lines.filter_map do |line|
         JSON.parse(line)
       rescue JSON::ParserError
@@ -128,13 +131,15 @@ module KamalBackup
       legacy_prefix = "databases/#{config.app_name}/#{adapter}/"
       app = config.app_name.gsub(/[^A-Za-z0-9_.-]+/, "-")
       database = database_name.to_s.gsub(/[^A-Za-z0-9_.-]+/, "-")
+      stable_prefix = database.empty? ? nil : "databases/#{app}/#{database}/#{adapter}."
       flat_prefix = "databases-#{app}-#{adapter}-"
       named_flat_prefix = database.empty? ? nil : "databases-#{app}-#{database}-#{adapter}-"
       ls_json(snapshot).find do |entry|
         next false unless entry["type"] == "file"
 
         normalized = entry["path"].to_s.sub(%r{\A/+}, "")
-        normalized.start_with?(legacy_prefix) ||
+        (stable_prefix && normalized.start_with?(stable_prefix)) ||
+          normalized.start_with?(legacy_prefix) ||
           File.basename(normalized).start_with?(flat_prefix) ||
           (named_flat_prefix && File.basename(normalized).start_with?(named_flat_prefix))
       end&.fetch("path")
@@ -151,12 +156,15 @@ module KamalBackup
       FileUtils.mkdir_p(File.dirname(target_path))
       temp_path = "#{target_path}.kamal-backup-#{$$}.tmp"
 
+      output = Command.output
+      context = output&.command_start(command, redactor: redactor)
       Open3.popen3(command.env, *command.argv) do |stdin, stdout, stderr, wait_thread|
         stdin.close
-        stderr_reader = Thread.new { stderr.read }
+        stderr_reader = Thread.new { Command.collect_stream(stderr, command_output: output, context: context, stream: :stderr, redactor: redactor) }
         File.open(temp_path, "wb") { |file| IO.copy_stream(stdout, file) }
         err = stderr_reader.value
         status = wait_thread.value
+        output&.command_exit(context, status.exitstatus)
         raise_command_error(command, status, "", err) unless status.success?
       end
       File.rename(temp_path, target_path)
@@ -174,8 +182,12 @@ module KamalBackup
       run(["restore", snapshot, "--target", target])
     end
 
-    def run(args)
-      Command.capture(CommandSpec.new(argv: ["restic"] + args, env: restic_env), redactor: redactor)
+    def run(args, log_output: true)
+      Command.capture(
+        CommandSpec.new(argv: ["restic"] + args, env: restic_env),
+        redactor: redactor,
+        log_output: log_output
+      )
     end
 
     def common_tags
@@ -213,6 +225,19 @@ module KamalBackup
         tags.compact.each_with_object([]) { |tag, args| args.concat(["--tag", tag]) }
       end
 
+      def host_args
+        ["--host", restic_host]
+      end
+
+      def restic_host
+        normalize_restic_host([config.app_name, config.accessory_name || "backup"].compact.join("-"))
+      end
+
+      def normalize_restic_host(value)
+        normalized = value.to_s.gsub(/[^A-Za-z0-9_.-]+/, "-").gsub(/\A-+|-+\z/, "")
+        normalized.empty? ? "kamal-backup" : normalized
+      end
+
       def filter_tag_args(tags)
         tags = tags.compact
         tags.empty? ? [] : ["--tag", tags.join(",")]
@@ -225,13 +250,16 @@ module KamalBackup
       end
 
       def pipe_commands(producer, consumer, producer_label:, consumer_label:)
+        output = Command.output
+        producer_context = output&.command_start(producer, redactor: redactor)
         Open3.popen3(producer.env, *producer.argv) do |producer_stdin, producer_stdout, producer_stderr, producer_wait|
           producer_stdin.close
 
+          consumer_context = output&.command_start(consumer, redactor: redactor)
           Open3.popen3(consumer.env, *consumer.argv) do |consumer_stdin, consumer_stdout, consumer_stderr, consumer_wait|
-            producer_err_reader = Thread.new { producer_stderr.read }
-            consumer_out_reader = Thread.new { consumer_stdout.read }
-            consumer_err_reader = Thread.new { consumer_stderr.read }
+            producer_err_reader = Thread.new { Command.collect_stream(producer_stderr, command_output: output, context: producer_context, stream: :stderr, redactor: redactor) }
+            consumer_out_reader = Thread.new { Command.collect_stream(consumer_stdout, command_output: output, context: consumer_context, stream: :stdout, redactor: redactor) }
+            consumer_err_reader = Thread.new { Command.collect_stream(consumer_stderr, command_output: output, context: consumer_context, stream: :stderr, redactor: redactor) }
 
             copy_error = nil
             copy_thread = Thread.new do
@@ -245,6 +273,8 @@ module KamalBackup
             copy_thread.join
             producer_status = producer_wait.value
             consumer_status = consumer_wait.value
+            output&.command_exit(producer_context, producer_status.exitstatus)
+            output&.command_exit(consumer_context, consumer_status.exitstatus)
 
             producer_err = producer_err_reader.value
             consumer_out = consumer_out_reader.value
@@ -287,7 +317,11 @@ module KamalBackup
       end
 
       def log(message)
-        $stdout.puts("[kamal-backup] #{redactor.redact_string(message)}")
+        if Command.output
+          Command.output.info(message, redactor: redactor)
+        else
+          $stdout.puts("[kamal-backup] #{redactor.redact_string(message)}")
+        end
       end
   end
 end

data/lib/kamal_backup/version.rb

@@ -1,3 +1,3 @@
 module KamalBackup
-  VERSION = "0.3.0.beta4"
+  VERSION = "0.3.0.beta6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kamal-backup
 version: !ruby/object:Gem::Version
-  version: 0.3.0.beta4
+  version: 0.3.0.beta6
 platform: ruby
 authors:
 - crmne