deployangel 0.1.22 → 0.1.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: edccb6c72eff7d259c14c59deaa403fb78c890cb091b40d59b080623945e1e9f
-  data.tar.gz: 364fd681c6199d591292fc67799cb6f7933da99736113ef382ff4ccf628697f8
+  metadata.gz: 2304a80caf17ea6df84a2487145d51438244f15e38528e817fb93ed45a07dff0
+  data.tar.gz: b28c3f544144e1b4a8cd9417fbdb4407bd814d814fe88522073e4d463d25f11a
 SHA512:
-  metadata.gz: 0ec79d7a8b20600e3fc57604b990749ff578a6b39bdd2caf945c8f60bf5f39ed74f3991659f8d3e26c851e8a7509cc4dabca339f36f35aaa79aca33648ba4c9d
-  data.tar.gz: 37db580510184b407f7941e6c27ad00eb956fab8df6fb59a68406753c14813bca7007de9da53ca7cf9a858f456d40f2a5da2fdd872c44bdd33997b052132ba2c
+  metadata.gz: ba778f41f2922f597a225d2bbdefc58ffce09443ec7f4c342f8df2729103e36a49115bcd76502222a95717eace53b4c737cc836fccff3a865bb52e835501fc0a
+  data.tar.gz: 98abb8b69f7cf9e61980a68befcff22dee0ede110019a2b6e398a92efaef155e2c700ce3eaf426fb9f3346fcbe0ce320b7bd3ef78979c0459a91bc4a6f0cd263

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.1.24 (2026-10-10)
+
+- `deployangel doctor` checks the setup: the agent in the bundle, the
+  schedules in this checkout's files, and how production will know the
+  release; then, with a token, what DeployAngel has seen (processes
+  reporting and their releases, what the agent reported, and setup
+  problems with fixes). Only errors fail it. Run where the app runs, it
+  uses the agent's `DEPLOYANGEL_TOKEN` and shows the release that process
+  reports. Needs a DeployAngel server with `GET /api/v1/setup`.
+
+## 0.1.23 (2026-10-09)
+
+- GoodJob's cron (`config.good_job.cron`, or `GOOD_JOB_CRON`) is read from
+  the processes that run it, so its jobs are expected on schedule. Entries
+  whose schedule or class is a lambda, or that are off by default, are
+  left out; schedules without a zone are read in the server's.
+
 ## 0.1.22 (2026-10-09)
 
 - Work scheduled outside the app's own scheduler is watched too.

data/README.md

@@ -98,7 +98,8 @@ the dashboard says so.
   as it is. If your app's messages might hold personal or health data, [turn
   messages off](#exception-messages).
 - Once per process: the route table, job classes, recurring schedules
-  declared for Solid Queue, sidekiq-cron, or sidekiq-scheduler, critical
+  declared for Solid Queue, GoodJob, sidekiq-cron, sidekiq-scheduler, or
+  whenever, critical
   flows, and file digests (relative paths and hashes, never file contents) so
   DeployAngel can tell which routes changed in a release.
   Disable digests with `DEPLOYANGEL_FILE_DIGESTS=false`.
@@ -210,6 +211,13 @@ end
 Jobs that exist only in Redis, such as ones created in code or in the
 Sidekiq web UI, aren't read.
 
+GoodJob's cron (`config.good_job.cron`, or `GOOD_JOB_CRON`) is read from the
+processes that run it, the ones with cron enabled. Schedules without a zone
+are read in the server's, as GoodJob reads them. An entry whose `cron:` or
+`class:` is a lambda, or that's `enabled_by_default: false`, isn't expected.
+The agent doesn't see entries turned off in GoodJob's dashboard, so one you
+switch off there will look missed after the next deploy.
+
 #### Cron, Heroku Scheduler, and whenever
 
 Work that something outside the app starts on a schedule, such as cron,
@@ -433,8 +441,20 @@ bundle exec deployangel exercise --url=https://example.com  # send the plan's re
 bundle exec deployangel release --commit=$SHA          # register a deploy (manual or CI)
 bundle exec deployangel check --name="smoke: signup" --status=pass --covers=registration
 bundle exec deployangel exception <fingerprint>
+bundle exec deployangel doctor                         # check the setup
 ```
 
+`deployangel doctor` checks this checkout (the agent in the bundle, the
+schedules in its files, how production will know the release) and, with a
+token, what DeployAngel has seen of the app: which processes report and the
+release each runs, the routes, job classes, and scheduled jobs the agent
+reported, and setup problems with what to do about each. Only errors (a
+rejected token, an unreachable server, no agent in the bundle) exit 5;
+warnings exit 0, so it's safe in CI. It reads `DEPLOYANGEL_API_TOKEN`, or
+`DEPLOYANGEL_TOKEN` where the app runs, so
+`heroku run bundle exec deployangel doctor` also shows the release that
+process reports.
+
 Output is text on a terminal and JSON (the verdict document) when piped, or
 choose with `--format=text|json`. Exit codes:
 

data/lib/deployangel/cli.rb

@@ -12,13 +12,14 @@ require_relative "ci_environment"
 require_relative "verification_waiter"
 require_relative "cli/formatter"
 require_relative "exerciser"
+require_relative "doctor"
 
 module DeployAngel
   # `deployangel` command for developers, CI, and coding agents.
   # Runs without booting Rails.
   class CLI
     USAGE_ERROR = 5
-    COMMANDS = %w[release verify status plan exercise exception check install mcp version help].freeze
+    COMMANDS = %w[release verify status plan exercise exception check install doctor mcp version help].freeze
 
     HELP = <<~TEXT
       Usage: deployangel <command> [options]
@@ -39,6 +40,8 @@ module DeployAngel
         install    Add a Kamal deploy hook,       deployangel install kamal
                    bake the commit into an image, deployangel install docker
                    or set up coding agents        deployangel install agents
+        doctor     Check the setup: this checkout  [--format=text|json]
+                   and what DeployAngel has seen
         mcp        Run the MCP server over stdio (for coding agents)
 
       With no target, verify, plan, and check use the current git HEAD commit.
@@ -148,6 +151,7 @@ module DeployAngel
       when "exception" then exception
       when "check" then check
       when "install" then install
+      when "doctor" then doctor
       when "mcp" then mcp
       when "version", "--version", "-v" then @stdout.puts(DeployAngel::VERSION) || 0
       when nil, "help", "--help", "-h" then @stdout.puts(HELP) || 0
@@ -323,6 +327,36 @@ module DeployAngel
         0
       end
 
+      # What this checkout will report and what DeployAngel has seen of the
+      # app. Warnings are advice, so only errors (a rejected token, an
+      # unreachable server, no agent in the bundle) fail it.
+      def doctor
+        format = parse(format: nil) { |o, opts| o.on("--format=FORMAT", %w[text json]) { |v| opts[:format] = v } }[:format]
+        doctor = Doctor.new(root: @root, client: doctor_client, env: @env)
+        output(doctor.to_h, format) { doctor_text(doctor.checks) }
+        doctor.failed? ? USAGE_ERROR : 0
+      end
+
+      DOCTOR_MARKS = { ok: "✓", warn: "!", error: "✗", info: "·" }.freeze
+
+      def doctor_text(checks)
+        lines = [ "DeployAngel doctor" ]
+        checks.each do |check|
+          lines << "  #{DOCTOR_MARKS.fetch(check.status)} #{check.message}"
+          lines << "      #{check.fix}" if check.fix
+        end
+        lines.join("\n")
+      end
+
+      # Either token works: the setup endpoint answers any of the app's. The
+      # agent's own token is for running it where the app runs.
+      def doctor_client
+        return @client if @client
+
+        token = [ @env["DEPLOYANGEL_API_TOKEN"], @env["DEPLOYANGEL_TOKEN"] ].find { |value| !value.to_s.empty? } or return
+        Client.new(token: token, endpoint: @env["DEPLOYANGEL_URL"] || Configuration::DEFAULT_ENDPOINT)
+      end
+
       def install
         case (target = @argv.shift)
         when "kamal" then install_kamal

data/lib/deployangel/client.rb

@@ -31,6 +31,7 @@ module DeployAngel
     end
 
     def token_info = get("/api/v1/token")
+    def setup = get("/api/v1/setup")
     def latest_deployment = get("/api/v1/deployments/latest")
     def deployments(**filters) = get("/api/v1/deployments", filters.compact)["deployments"]
     def exception(fingerprint) = get("/api/v1/exceptions/#{URI.encode_www_form_component(fingerprint)}")

data/lib/deployangel/doctor.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "configuration"
+require_relative "metadata"
+require_relative "rails/metadata"
+require_relative "core/release"
+
+module DeployAngel
+  # `deployangel doctor`: what this checkout will report, and what
+  # DeployAngel has seen of the app so far (GET /api/v1/setup), as checks
+  # with what to do about each. It runs without booting the app, so it
+  # reads only the schedules kept in files.
+  class Doctor
+    # status is ok, warn, error, or info. Only errors fail the command.
+    Check = Struct.new(:status, :message, :fix, keyword_init: true) do
+      def to_h = { "status" => status.to_s, "message" => message, "fix" => fix }.compact
+    end
+
+    SOURCES = { "solid_queue" => "Solid Queue", "sidekiq_cron" => "sidekiq-cron", "sidekiq_scheduler" => "sidekiq-scheduler",
+                "whenever" => "whenever", "good_job" => "GoodJob", "config" => "agent config" }.freeze
+    TOKEN_HELP = "Set DEPLOYANGEL_API_TOKEN (a \"CLI & coding agents\" token from the app's Settings) or DEPLOYANGEL_TOKEN " \
+                 "(the app's agent token), then run this again."
+    MAX_HOSTS = 5
+
+    attr_reader :setup
+
+    # client is nil when no token is set; the local checks still run.
+    def initialize(root:, client:, env: {})
+      @root = root
+      @client = client
+      @env = env
+    end
+
+    def checks
+      @checks ||= begin
+        @setup, server = server_checks
+        [ *agent_checks, here_check, schedule_check, *server, release_check, *comparison_checks ].compact
+      end
+    end
+
+    def failed?
+      checks.any? { |check| check.status == :error }
+    end
+
+    def to_h
+      { "checks" => checks.map(&:to_h), "setup" => setup }
+    end
+
+    private
+      def agent_checks
+        lock = read("Gemfile.lock") or return []
+        version = lock[/^    deployangel \(([^)]+)\)/, 1]
+        return [ Check.new(status: :ok, message: "Agent: deployangel #{version} in Gemfile.lock") ] if version
+
+        [ Check.new(status: :error, message: "The agent isn't in the bundle", fix: "Add gem \"deployangel\" to the Gemfile and run bundle install.") ]
+      end
+
+      def schedule_check
+        counts = local_schedules.group_by { |schedule| schedule["source"] }.map { |source, list| "#{SOURCES.fetch(source, source)} #{list.size}" }
+        later = [ ("GoodJob's cron" if read("Gemfile.lock").to_s.include?(" good_job (")), "config.recurring_jobs" ].compact
+        note = "#{later.join(" and ")} #{later.one? ? "is" : "are"} read when the app runs."
+        if counts.any?
+          Check.new(status: :ok, message: "#{count(local_schedules.size, "scheduled job")} in this checkout (#{counts.join(", ")}). #{note}")
+        else
+          Check.new(status: :info, message: "No scheduled jobs in this checkout's schedule files. #{note}")
+        end
+      end
+
+      # The token's app and what DeployAngel has seen of it.
+      def server_checks
+        return [ nil, [ Check.new(status: :warn, message: "No token, so only this checkout was checked", fix: TOKEN_HELP) ] ] unless @client
+
+        setup = @client.setup
+        checks = [ app_check(setup), agent_check(setup), metadata_check(setup), *gap_checks(setup), progress_check(setup) ]
+        [ setup, checks.compact ]
+      rescue Client::Unauthorized => e
+        [ nil, [ Check.new(status: :error, message: "DeployAngel rejected the token (#{e.message})", fix: TOKEN_HELP) ] ]
+      rescue Client::NotFound
+        [ nil, [ Check.new(status: :warn, message: "This DeployAngel server doesn't support doctor yet; only this checkout was checked") ] ]
+      rescue Client::Error => e
+        [ nil, [ Check.new(status: :error, message: "Couldn't reach DeployAngel: #{e.message}") ] ]
+      end
+
+      def app_check(setup)
+        app = setup["app"] || {}
+        Check.new(status: :ok, message: "App: #{app["name"]} (#{app["environment"]})")
+      end
+
+      def agent_check(setup)
+        agent = setup["agent"] || {}
+        processes = Array(agent["processes"])
+        if agent["reporting"]
+          releases = processes.map { |process| process["release"] }.uniq
+          release = releases.compact.one? && releases.size == 1 ? ", release #{releases.first}" : ""
+          from = processes.any? ? " from #{hosts(processes)}" : ""
+          Check.new(status: :ok, message: "Agent reporting#{from}#{release}")
+        elsif agent["last_received_at"]
+          Check.new(status: :warn, message: "The agent last reported #{time(agent["last_received_at"])}, and nothing since",
+            fix: "Check the app is running, and that DEPLOYANGEL_TOKEN is still set on its processes.")
+        else
+          Check.new(status: :warn, message: "The agent hasn't reported yet",
+            fix: "Deploy with DEPLOYANGEL_TOKEN set to the app's agent token (Settings, Tokens: \"Deployed application\").")
+        end
+      end
+
+      def metadata_check(setup)
+        metadata = setup["metadata"] or return
+        jobs = Array(setup["scheduled_jobs"])
+        problems = jobs.select { |job| %w[overdue failed].include?(job["status"]) }
+        problem_text = problems.any? ? ", #{problems.size} needing attention (#{problems.first(3).map { |job| "#{job["label"]} #{job["status"]}" }.join(", ")})" : ""
+        Check.new(status: problems.any? ? :warn : :ok,
+          message: "Reported: #{count(metadata["routes"], "route")}, #{count(metadata["job_classes"], "job class", "job classes")}, " \
+                   "#{count(metadata["schedules"], "scheduled job")}#{problem_text}",
+          fix: ("See them on the app page, under Scheduled jobs." if problems.any?))
+      end
+
+      def gap_checks(setup)
+        Array(setup["gaps"]).map { |gap| Check.new(status: :warn, message: gap["title"], fix: gap["fix"]) }
+      end
+
+      def progress_check(setup)
+        deployments = setup["deployments"] || {}
+        latest = deployments["latest"]
+        message = if setup["warm_up_ends_at"]
+          "Learning what's normal for this app until #{time(setup["warm_up_ends_at"])}; deploys before then are checked, not cleared"
+        elsif latest
+          "#{count(deployments["count"], "deploy")} so far; the latest, #{latest["label"]}, is #{latest["verdict"] || latest["state"]}"
+        elsif setup.dig("agent", "last_received_at")
+          "No deploys yet: your next deploy gets the first verdict"
+        end
+        message && Check.new(status: :info, message: message)
+      end
+
+      # Run where the app runs (`heroku run`, a container shell), the release
+      # this process would report. On a developer machine it would only be
+      # the checkout's git HEAD, which says nothing about production, so
+      # it's left out there.
+      def here_check
+        release = Release.resolve(config: Configuration.new(@env), env: @env, root: @root)
+        if release.unknown?
+          return unless where_the_app_runs?
+
+          Check.new(status: :warn, message: "Here, the agent can't tell which release is running",
+            fix: "Set DEPLOYANGEL_REVISION to the deployed commit, or see https://deployangel.com/docs#containers.")
+        elsif release.source != "git_head"
+          Check.new(status: :ok, message: "Here, the agent would report release #{release.version || release.commit} (from #{release.source})")
+        end
+      rescue StandardError
+        nil
+      end
+
+      def where_the_app_runs?
+        !@env["DEPLOYANGEL_TOKEN"].to_s.empty? && @env["DEPLOYANGEL_API_TOKEN"].to_s.empty?
+      end
+
+      # How production will know the release, judged from what's reporting
+      # once anything is, and from this checkout's deploy files before then.
+      def release_check
+        return if Array(setup&.dig("agent", "processes")).any?
+
+        if file?("config/deploy.yml")
+          Check.new(status: :ok, message: "Kamal deploys: the agent reads the release from KAMAL_VERSION")
+        elsif file?("render.yaml")
+          Check.new(status: :ok, message: "Render deploys: the agent reads the commit from RENDER_GIT_COMMIT")
+        elsif read(".do/app.yaml").to_s.include?("DEPLOYANGEL_REVISION")
+          Check.new(status: :ok, message: "The DigitalOcean app spec passes the commit in DEPLOYANGEL_REVISION")
+        elsif (dockerfile = read("Dockerfile"))
+          if dockerfile.include?("DEPLOYANGEL_REVISION")
+            Check.new(status: :ok, message: "The Dockerfile passes the commit in DEPLOYANGEL_REVISION")
+          else
+            # Platforms can pass it another way, so this is advice until the
+            # agent reports: then the release it names settles it.
+            Check.new(status: :info, message: "The Dockerfile doesn't set DEPLOYANGEL_REVISION; unless your platform passes the commit, " \
+              "releases won't be named by commit",
+              fix: "Run `deployangel install docker`, then build with --build-arg GIT_SHA=$(git rev-parse HEAD).")
+          end
+        elsif file?("Capfile")
+          Check.new(status: :ok, message: "Capistrano deploys: the agent reads the REVISION file Capistrano writes")
+        elsif file?("Procfile") || file?("app.json")
+          Check.new(status: :info, message: "On Heroku, turn on dyno metadata so the agent knows the commit",
+            fix: "heroku labs:enable runtime-dyno-metadata && heroku labs:enable runtime-dyno-build-metadata")
+        end
+      end
+
+      # Schedules in this checkout that the running agent hasn't reported:
+      # not deployed yet, or an agent too old to read them.
+      def comparison_checks
+        reported = setup&.dig("metadata", "schedules") or return []
+        return [] unless local_schedules.size > reported
+
+        [ Check.new(status: :warn, message: "This checkout declares #{count(local_schedules.size, "scheduled job")}; the running agent reported #{reported}",
+          fix: "Deploy this code, or update the agent: whenever schedules need deployangel 0.1.22 or later, GoodJob's 0.1.23.") ]
+      end
+
+      def local_schedules
+        @local_schedules ||= begin
+          config = Configuration.new({})
+          metadata = if file?("config/application.rb")
+            Rails::Metadata.new(app: nil, config: config, root: @root, environment: "production")
+          else
+            DeployAngel::Metadata.new(config: config, root: @root, environment: "production")
+          end
+          metadata.schedules
+        rescue StandardError, ScriptError
+          []
+        end
+      end
+
+      def hosts(processes)
+        names = processes.map { |process| process["processes"].to_i > 1 ? "#{process["host"]} ×#{process["processes"]}" : process["host"] }
+        total = processes.sum { |process| process["processes"].to_i }
+        listed = names.first(MAX_HOSTS).join(", ")
+        listed += ", and others" if names.size > MAX_HOSTS
+        "#{count(total, "process", "processes")} (#{listed})"
+      end
+
+      def time(iso)
+        Time.iso8601(iso).utc.strftime("%b %-d, %H:%M UTC")
+      rescue ArgumentError, TypeError
+        iso.to_s
+      end
+
+      def count(number, singular, plural = "#{singular}s")
+        "#{number.to_i} #{number.to_i == 1 ? singular : plural}"
+      end
+
+      def file?(relative) = File.file?(File.join(@root, relative))
+
+      def read(relative)
+        path = File.join(@root, relative)
+        File.read(path) if File.file?(path)
+      rescue SystemCallError
+        nil
+      end
+  end
+end

data/lib/deployangel/rails/metadata.rb

@@ -3,7 +3,7 @@
 module DeployAngel
   module Rails
     # The Rails adapter: the route table from the router, job classes from
-    # Active Job, and Solid Queue's recurring tasks. The schedule files
+    # Active Job, and Solid Queue's and GoodJob's recurring tasks. The schedule files
     # sidekiq-cron and sidekiq-scheduler read, and the file digests, are
     # gathered in DeployAngel::Metadata.
     class Metadata < ::DeployAngel::Metadata
@@ -44,10 +44,10 @@ module DeployAngel
         []
       end
 
-      # Solid Queue's schedule is Rails' own; the rest are read the same way
-      # on every framework.
+      # Solid Queue's and GoodJob's schedules live in the Rails app; the rest
+      # are read the same way on every framework.
       def schedules
-        solid_queue_schedules + super
+        solid_queue_schedules + good_job_schedules + super
       end
 
       # Solid Queue recurring tasks for the current environment.
@@ -69,6 +69,33 @@ module DeployAngel
         []
       end
 
+      # GoodJob's cron, from a process that runs it. GoodJob turns cron on
+      # per process (often only the worker's, with GOOD_JOB_ENABLE_CRON), and
+      # its CLI applies --enable-cron after boot, before metadata is first
+      # sent. A schedule without a zone is read in the server's, as Fugit
+      # reads it. A schedule or class given as a lambda can't be known
+      # without running app code, so it's left out.
+      def good_job_schedules
+        return [] unless defined?(::GoodJob) && ::GoodJob.respond_to?(:configuration)
+
+        configuration = ::GoodJob.configuration
+        return [] unless configuration.enable_cron?
+
+        configuration.cron.filter_map do |key, entry|
+          next unless entry.is_a?(Hash)
+
+          entry = entry.transform_keys(&:to_sym)
+          cron, job_class = entry.values_at(:cron, :class)
+          job_class = job_class.name if job_class.is_a?(Module)
+          next if entry[:enabled_by_default] == false
+          next unless cron.is_a?(String) && !cron.strip.empty? && job_class.is_a?(String) && !job_class.empty?
+
+          { "key" => key.to_s, "class" => job_class, "schedule" => cron, "source" => "good_job", "time_zone" => local_time_zone }
+        end
+      rescue StandardError
+        []
+      end
+
       # A command task runs as a job of this class, so its runs show up in
       # job telemetry under that name.
       def command_job_class

data/lib/deployangel/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeployAngel
-  VERSION = "0.1.22"
+  VERSION = "0.1.24"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deployangel
 version: !ruby/object:Gem::Version
-  version: 0.1.22
+  version: 0.1.24
 platform: ruby
 authors:
 - Jordan Owens
@@ -46,6 +46,7 @@ files:
 - lib/deployangel/core/redaction.rb
 - lib/deployangel/core/release.rb
 - lib/deployangel/core/transport.rb
+- lib/deployangel/doctor.rb
 - lib/deployangel/exerciser.rb
 - lib/deployangel/fork_hook.rb
 - lib/deployangel/mcp.rb