deployangel 0.1.10 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fd5de9ae625d8780f853e4ee71b662be91f6dc702f59aa15806b359c075045a
-  data.tar.gz: 5823184602177d55b1abc39dd920b01879162a335afabe3dee46c5cdbfec1295
+  metadata.gz: c3835d3c334a91d9ad7a75a3247ede4797a27e207b123f684bc1563fffd33cb0
+  data.tar.gz: c578f30dc3f828dabce95b7c4e48682b1248d306b0982d50483f17d3c3cf57c8
 SHA512:
-  metadata.gz: 5c899072c049b8854d5772c05be7cb95588d427a571324ab303134418081b3815ae39eb6efaea92b1e46f6857f24379674f9298050435638bb674baca942aeb7
-  data.tar.gz: 3ce76ca3b6232505e4d1afaa95348939a1ffcac19fe02cf296f30fdf02fd447aba85991c5d8b292ace00d19b38a0e73418a668d0cef8993a86119a1a3d2abc26
+  metadata.gz: 5a8e5b23a9d1a06732add016e3d31e813d08a10afc13016408c26944112098948476cfe51d7c39c60710c9f411cf6d0af01d145a4bd0a125ebcc90728d06b695
+  data.tar.gz: 7dea64425c2cd98cda899277a2561d67dde2d0871e38156c9efad654769fdcb6198ab94089d56fad0d72c7e15e48300d5b40d5018851491c6378043b435bb470

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.1.12 (2026-10-06)
+
+- `deployangel plan` and the MCP tool `get_exercise_plan` say what stands
+  between a release and clearance, and what to exercise against production
+  so it clears sooner. Routes that change data are marked. `deployangel
+  verify` and the GitHub Actions job summary list the first items when a
+  release isn't cleared yet. Needs a DeployAngel server that returns
+  exercise plans; older ones get a note instead.
+
+## 0.1.11 (2026-10-05)
+
+- Heroku: the commit comes from `HEROKU_BUILD_COMMIT`
+  (`heroku labs:enable runtime-dyno-build-metadata`) when it's set, and from
+  `HEROKU_SLUG_COMMIT`, which Heroku has deprecated, otherwise.
+- In GitHub Actions, `deployangel verify` and `status` also add the verdict,
+  its failing and warning findings, new exceptions, and a dashboard link to
+  the job's summary page (`GITHUB_STEP_SUMMARY`). Output and exit codes are
+  unchanged.
+
 ## 0.1.10 (2026-10-04)
 
 - `config.exception_messages = false` (or `DEPLOYANGEL_EXCEPTION_MESSAGES=false`)

data/README.md

@@ -24,6 +24,8 @@ The agent must know which release it is running. It finds it in this order:
 
 1. `DEPLOYANGEL_REVISION` (the commit SHA) and `DEPLOYANGEL_RELEASE_VERSION`, if you set them
 2. Heroku dyno metadata. Enable it with `heroku labs:enable runtime-dyno-metadata`
+   and `heroku labs:enable runtime-dyno-build-metadata` (for `HEROKU_BUILD_COMMIT`,
+   which replaces the deprecated `HEROKU_SLUG_COMMIT`); both take effect on the next deploy
 3. Kamal: `KAMAL_VERSION`, which Kamal sets in every container
 4. Render: `RENDER_GIT_COMMIT`
 5. Fly.io: the deploy's image tag, from `FLY_IMAGE_REF`. Fly.io sets no commit, so
@@ -243,6 +245,9 @@ to the run. Explicit options still win.
     DEPLOYANGEL_API_TOKEN: ${{ secrets.DEPLOYANGEL_API_TOKEN }}
 ```
 
+In GitHub Actions, `verify` also puts the verdict, its failing findings, and
+new exceptions on the job's summary page.
+
 ### When a release never reports
 
 A registered release must start reporting within 15 minutes of being
@@ -359,6 +364,7 @@ export DEPLOYANGEL_API_TOKEN=da_live_...
 bundle exec deployangel verify --wait                  # current git HEAD, until a verdict
 bundle exec deployangel verify --wait --until=initial  # return at the 15-minute initial check
 bundle exec deployangel status                         # latest deployment
+bundle exec deployangel plan                           # what to exercise so a release clears sooner
 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>
@@ -385,9 +391,23 @@ claude mcp add deployangel -- bundle exec deployangel mcp
 ```
 
 Tools: `get_verification`, `wait_for_verification` (up to 5 minutes per call),
-`list_deployments`, `get_exception`, `list_late_regressions`, and
-`register_deployment` when the token allows it. The tools are read-only with
-respect to production.
+`get_exercise_plan`, `list_deployments`, `get_exception`,
+`list_late_regressions`, and `register_deployment` when the token allows it.
+The tools are read-only with respect to production.
+
+### Clearing quiet releases sooner
+
+A quiet app can take hours to clear a release. `deployangel plan` (or the
+`get_exercise_plan` MCP tool) says what stands between a release and
+clearance, in the numbers of the rule it's judged by, and what to exercise
+against production so it clears sooner: normally active routes short of
+their runs, routes this release changed that haven't run, and critical
+flows. Requests to them count like any traffic. Routes that change data
+are marked; use a test account for them, or ask first. Report what you
+ran with the `deployangel check` command the plan gives you. A passing
+check labels what it covered; only the requests themselves count as
+evidence. A release deployed during an app's first 24 hours can't clear,
+so its plan lists nothing.
 
 ### Suggested instructions for your coding agent
 
@@ -411,6 +431,13 @@ After deploying, run `bundle exec deployangel verify --wait --until initial`
   cause, and propose a fix. Do not roll back or change production without
   explicit approval.
 - Exit 3: still verifying; run the command again.
+- Not cleared yet and you can reach production: run
+  `bundle exec deployangel plan --format=json` (or `get_exercise_plan`). If
+  its status is "exercisable" or "waiting_for_activity", exercise the listed
+  items against production: read-only routes freely, routes marked mutating
+  only with a test account or after asking. Then run its `report_with`
+  command and wait again. If the status is "warm_up", don't exercise
+  anything: the release can't clear until DeployAngel has a day of history.
 ```
 
 ## Development

data/lib/deployangel/cli/formatter.rb

@@ -13,50 +13,174 @@ module DeployAngel
         "checkpoint_rate" => "Checkpoint"
       }.freeze
       DURATIONS = %w[p95_latency job_duration queue_latency].freeze
+      # Exercise plan statuses with something worth running now.
+      EXERCISABLE = %w[exercisable waiting_for_activity].freeze
+      REASONS = { "normally_active" => "normally active", "changed_in_release" => "changed in this release",
+                  "rarely_used" => "rarely used", "critical_flow" => "critical flow" }.freeze
       COUNTS = %w[new_fingerprint checkpoint_rate].freeze
 
       module_function
 
       def verification(document)
+        lines = [ statement(document), status_line(document), *notes(document) ]
+        problems = problems(document)
+        if problems.any?
+          lines << "Findings:"
+          problems.each { |f| lines << "  #{f["status"].ljust(8)} #{finding_line(f)}" }
+        end
+        if (gathering = gathering_line(document))
+          lines << "#{gathering} (--format=json for details)"
+        end
+        sections(document).each { |title, items| section(lines, title, items) }
+        lines << document["dashboard_url"] if document["dashboard_url"]
+        lines.compact.join("\n")
+      end
+
+      # The same document as GitHub-flavored Markdown, for a CI job's
+      # summary page.
+      def markdown(document)
+        lines = [ "### DeployAngel: #{release_name(document)} #{outcome(document)}", "", statement(document).to_s,
+                  "", status_line(document), *notes(document).map { |note| "\n#{note}" } ]
+        problems = problems(document)
+        if problems.any?
+          lines.push("", "| Status | Finding |", "| --- | --- |")
+          problems.each { |f| lines << "| #{f["status"]} | #{cell(finding_line(f))} |" }
+        end
+        if (gathering = gathering_line(document))
+          lines.push("", gathering)
+        end
+        sections(document).each do |title, items|
+          lines.push("", "**#{title}**", "")
+          items.each { |item| lines << "- #{item}" }
+        end
+        lines.push("", "[Open in DeployAngel](#{document["dashboard_url"]})") if document["dashboard_url"]
+        lines.compact.join("\n") + "\n"
+      end
+
+      def statement(document)
+        (document["clearance"] || {})["statement"] || document["summary"]
+      end
+
+      def status_line(document)
         v = document["verification"] || {}
-        clearance = document["clearance"] || {}
-        lines = [ clearance["statement"] || document["summary"] ]
-        lines << [ "State: #{v["state"]}", ("Verdict: #{v["verdict"]}" if v["verdict"]),
-                   ("Confidence: #{v["confidence"]}" if v["confidence"]),
-                   ("Coverage: #{(v["coverage"] * 100).round}%" if v["coverage"]) ].compact.join(" · ")
+        [ "State: #{v["state"]}", ("Verdict: #{v["verdict"]}" if v["verdict"]),
+          ("Confidence: #{v["confidence"]}" if v["confidence"]),
+          ("Coverage: #{(v["coverage"] * 100).round}%" if v["coverage"]) ].compact.join(" · ")
+      end
+
+      def notes(document)
+        v = document["verification"] || {}
+        notes = []
         if (check = v["initial_check"]) && v["verdict"].nil?
-          lines << "Initial check: #{check["result"].tr("_", " ")}. Not cleared yet."
+          notes << "Initial check: #{check["result"].tr("_", " ")}. Not cleared yet."
         end
-        lines << "Expected clearance: #{v["expected_clearance_at"]}" if v["expected_clearance_at"] && v["verdict"].nil?
+        notes << "Expected clearance: #{v["expected_clearance_at"]}" if v["expected_clearance_at"] && v["verdict"].nil?
         if (source = document.dig("deployment", "promoted_from"))
           outcome = { "verified" => "cleared", "failed" => "failed", "inconclusive" => "not cleared" }.fetch(source["verdict"], "still verifying")
-          lines << "Promoted from #{source["environment"]} #{source["version"] || source["commit"].to_s[0, 7]} (#{outcome})"
+          notes << "Promoted from #{source["environment"]} #{source["version"] || source["commit"].to_s[0, 7]} (#{outcome})"
         end
+        notes
+      end
 
-        findings = Array(document["findings"])
-        problems = findings.select { |f| %w[failing warning].include?(f["status"]) }
-        if problems.any?
-          lines << "Findings:"
-          problems.each { |f| lines << "  #{f["status"].ljust(8)} #{finding_line(f)}" }
+      def problems(document)
+        Array(document["findings"]).select { |f| %w[failing warning].include?(f["status"]) }
+      end
+
+      def gathering_line(document)
+        gathering = Array(document["findings"]).count { |f| f["status"] == "insufficient_data" }
+        "#{gathering} signal#{"s" unless gathering == 1} still gathering data" if gathering.positive?
+      end
+
+      # Titled lists that follow the findings, each item already a line.
+      def sections(document)
+        v = document["verification"] || {}
+        clearance = document["clearance"] || {}
+        changed = Array(document["rare_items_pending"]).select { |item| item["changed_in_release"] == "changed" }
+        [
+          [ "New exceptions", Array(document["exceptions"]).map do |e|
+            "#{e["exception_class"]} in #{e["top_frame"]} (#{e["count"]}x)#{" #{e["sources"].keys.join(", ")}" if e["sources"].is_a?(Hash) && e["sources"].any?}"
+          end ],
+          [ "Missing evidence", v["verdict"] == "failed" ? [] : Array(clearance["missing_evidence"]) ],
+          [ "Not observable", Array(clearance["not_observable"]).map { |item| "#{item["label"]} (#{item["reason"]})" } ],
+          [ "Still watching", Array(clearance["still_watching"]).map { |e| "#{e["job_class"]} (expected by #{e["expected_by"]})" } ],
+          [ "Critical flows", Array(document["critical_flows"]).map do |flow|
+            "#{flow["name"]}: #{flow["status"].tr("_", " ")}#{" (changed in this release)" if flow["changed_in_release"]}"
+          end ],
+          [ "Changed but not yet exercised", changed.map { |item| item["key"] } ],
+          [ "To clear sooner, exercise (deployangel plan for details)", exercisable_items(document).first(5) ],
+          [ "Late regressions", Array(document["late_regressions"]).map { |late| late["summary"] } ]
+        ].reject { |_, items| items.empty? }
+      end
+
+      # The release's exercise plan, for `deployangel plan`.
+      def exercise_plan(document)
+        plan = document["exercise_plan"] || {}
+        lines = [ "#{release_name(document)}: #{plan["summary"] || "No exercise plan in this response; update the server."}" ]
+        shortfall = shortfall_lines(plan["shortfall"] || {})
+        if shortfall.any?
+          lines << "Short of:"
+          shortfall.each { |line| lines << "  #{line}" }
         end
-        gathering = findings.count { |f| f["status"] == "insufficient_data" }
-        lines << "#{gathering} signal#{"s" unless gathering == 1} still gathering data (--format=json for details)" if gathering.positive?
-        section(lines, "New exceptions", Array(document["exceptions"])) do |e|
-          "#{e["exception_class"]} in #{e["top_frame"]} (#{e["count"]}x)#{" #{e["sources"].keys.join(", ")}" if e["sources"].is_a?(Hash) && e["sources"].any?}"
+        items = Array(plan["items"])
+        if items.any?
+          lines << (EXERCISABLE.include?(plan["status"]) ? "Exercise against production:" : "Optional:")
+          items.each { |item| lines << "  #{item_line(item)}" }
+          lines << "Use a test account, or ask first, for routes marked [changes data]." if items.any? { |item| item["mutating"] }
         end
-        unless v["verdict"] == "failed"
-          section(lines, "Missing evidence", Array(clearance["missing_evidence"])) { |item| item }
+        lines << "Then report it: #{plan["report_with"]}" if plan["report_with"]
+        lines.join("\n")
+      end
+
+      def exercisable_items(document)
+        plan = document["exercise_plan"] || {}
+        EXERCISABLE.include?(plan["status"]) ? Array(plan["items"]).map { |item| item_line(item) } : []
+      end
+
+      def shortfall_lines(shortfall)
+        lines = []
+        if (requests = shortfall["requests"])
+          lines << "requests: #{requests["have"]} of #{requests["need"]}#{" (low-traffic rule)" if shortfall["rule"] == "low_volume"}"
         end
-        section(lines, "Not observable", Array(clearance["not_observable"])) { |item| "#{item["label"]} (#{item["reason"]})" }
-        section(lines, "Still watching", Array(clearance["still_watching"])) { |e| "#{e["job_class"]} (expected by #{e["expected_by"]})" }
-        section(lines, "Critical flows", Array(document["critical_flows"])) do |flow|
-          "#{flow["name"]}: #{flow["status"].tr("_", " ")}#{" (changed in this release)" if flow["changed_in_release"]}"
+        shortfall.each do |key, value|
+          next unless key.start_with?("routes_run_")
+
+          lines << "routes run #{key[/\d+/]}+ times: #{value["have"]} of the #{value["need"]} needed (#{value["of"]} normally active)"
+        end
+        lines << "coverage: #{(shortfall.dig("coverage", "have").to_f * 100).round}% of #{(shortfall.dig("coverage", "need").to_f * 100).round}%" if shortfall["coverage"]
+        if (jobs = shortfall["jobs"])
+          lines << (jobs["classes_not_run"] ? "jobs not run yet: #{Array(jobs["classes_not_run"]).join(", ")}" :
+            "job attempts: #{jobs.dig("attempts", "have")} of #{jobs.dig("attempts", "need")}")
+        end
+        lines << "elevated, review before exercising more: #{Array(shortfall["elevated"]).join(", ")}" if shortfall["elevated"]
+        lines << "critical flows not run: #{Array(shortfall["critical_flows"]).join(", ")}" if shortfall["critical_flows"]
+        lines
+      end
+
+      def item_line(item)
+        runs = item["runs_needed"].to_i > 1 ? "run #{item["runs"]} of #{item["runs_needed"]}" : "not run yet"
+        runs = "runs when the app starts it" if item["triggered_by"] == "app_behavior"
+        [ item["key"], "(#{REASONS.fetch(item["reason"], item["reason"])}, #{runs})",
+          ("[changes data]" if item["mutating"]), ("checked by #{Array(item["checked_by"]).join(", ")}" if item["checked_by"]) ].compact.join(" ")
+      end
+
+      def release_name(document)
+        deployment = document["deployment"] || {}
+        deployment["version"] || deployment["commit"].to_s[0, 7]
+      end
+
+      def outcome(document)
+        v = document["verification"] || {}
+        case v["verdict"]
+        when "verified" then "cleared"
+        when "failed" then "failed"
+        when "inconclusive" then "not cleared"
+        else
+          case v.dig("initial_check", "result")
+          when "warnings" then "has warnings, not cleared yet"
+          when nil then "is still being verified"
+          else "has no problems so far, not cleared yet"
+          end
         end
-        changed = Array(document["rare_items_pending"]).select { |item| item["changed_in_release"] == "changed" }
-        section(lines, "Changed but not yet exercised", changed) { |item| item["key"] }
-        section(lines, "Late regressions", Array(document["late_regressions"])) { |late| late["summary"] }
-        lines << document["dashboard_url"] if document["dashboard_url"]
-        lines.compact.join("\n")
       end
 
       def exception(details)
@@ -82,10 +206,12 @@ module DeployAngel
       end
 
       def section(lines, title, items)
-        return if items.empty?
-
         lines << "#{title}:"
-        items.each { |item| lines << "  #{yield(item)}" }
+        items.each { |item| lines << "  #{item}" }
+      end
+
+      def cell(text)
+        text.gsub("|", "\\|")
       end
 
       def value(finding, raw)

data/lib/deployangel/cli.rb

@@ -28,13 +28,15 @@ module DeployAngel
                                                  [--wait] [--until=initial|verdict|closed] [--timeout=30m]
                                                  [--format=text|json] [--all-findings]
         status     Latest deployment and its verification
+        plan       What to exercise so a release  [--commit=SHA | --version=V | --deployment=ID]
+                   clears sooner                 [--format=text|json]
         exception  Details for a fingerprint     deployangel exception FINGERPRINT
         check      Report a smoke test result    --name=NAME --status=pass|fail [--covers=a,b]
                                                  [--commit=SHA | --deployment=ID] [--details-url=URL]
         install    Add a deploy hook             deployangel install kamal
         mcp        Run the MCP server over stdio (for coding agents)
 
-      With no target, verify and check use the current git HEAD commit.
+      With no target, verify, plan, and check use the current git HEAD commit.
       In GitHub Actions, GitLab CI, CircleCI, and Buildkite, release fills in the
       commit, a build label (e.g. run-123), and a link to the run automatically.
       In a Kamal hook, it registers Kamal's release (KAMAL_VERSION).
@@ -75,6 +77,7 @@ module DeployAngel
       when "release" then release
       when "verify" then verify
       when "status" then verify(status: true)
+      when "plan" then plan
       when "exception" then exception
       when "check" then check
       when "install" then install
@@ -139,15 +142,41 @@ module DeployAngel
         outcome = waiter.wait(target, until_mode: options[:until_mode], timeout: options[:timeout], wait: options[:wait])
         if outcome.not_found
           @stderr.puts("deployangel: no deployment found for #{target.values.first}")
+          step_summary("### DeployAngel: no deployment found for #{target.values.first}\n")
           return outcome.exit_code
         end
 
         document = options[:all_findings] ? client.verification(outcome.document.dig("deployment", "id"), all_findings: true) : outcome.document
         output(document, options[:format]) { Formatter.verification(document) }
+        step_summary(Formatter.markdown(document))
         @stderr.puts("deployangel: timed out; verification is still in progress") if outcome.timed_out
         outcome.exit_code
       end
 
+      # The release's exercise plan: what stands between it and clearance,
+      # and what to exercise against production so it clears sooner.
+      def plan
+        options = parse(format: nil) do |o, opts|
+          o.on("--commit=SHA") { |v| opts[:commit] = v }
+          o.on("--version=VERSION") { |v| opts[:version] = v }
+          o.on("--deployment=ID") { |v| opts[:deployment_id] = v }
+          o.on("--format=FORMAT", %w[text json]) { |v| opts[:format] = v }
+        end
+        target = target_from(options)
+        return usage_error("no target: pass --commit, --version, or --deployment, or run inside a git repository") unless target
+
+        outcome = VerificationWaiter.new(client: client, sleeper: @sleeper, clock: @clock).wait(target, wait: false)
+        if outcome.not_found
+          @stderr.puts("deployangel: no deployment found for #{target.values.first}")
+          return outcome.exit_code
+        end
+
+        document = outcome.document
+        json = { "deployment" => document["deployment"], "exercise_plan" => document["exercise_plan"] }
+        output(json, options[:format]) { Formatter.exercise_plan(document) }
+        0
+      end
+
       def exception
         fingerprint = @argv.shift or return usage_error("exception needs a FINGERPRINT")
         format = parse(format: nil) { |o, opts| o.on("--format=FORMAT", %w[text json]) { |v| opts[:format] = v } }[:format]
@@ -228,6 +257,16 @@ module DeployAngel
         @stdout.puts(format == "json" ? JSON.pretty_generate(document) : yield)
       end
 
+      # In GitHub Actions, the verdict also goes on the run's summary page.
+      def step_summary(markdown)
+        path = @env["GITHUB_STEP_SUMMARY"].to_s
+        return if path.empty?
+
+        File.open(path, "a") { |file| file.puts(markdown) }
+      rescue SystemCallError => e
+        @stderr.puts("deployangel: couldn't write the job summary (#{e.message})")
+      end
+
       def parse_duration(value)
         match = value.to_s.match(/\A(\d+)(s|m|h)?\z/) or raise OptionParser::InvalidArgument, "--timeout=#{value}"
         match[1].to_i * { nil => 1, "s" => 1, "m" => 60, "h" => 3600 }.fetch(match[2])

data/lib/deployangel/core/release.rb

@@ -19,8 +19,8 @@ module DeployAngel
     def self.resolve(config:, env: ENV, root: nil, http: method(:fetch_metadata))
       if present?(config.release_version) || present?(config.revision)
         build(config.release_version, config.revision, "config")
-      elsif present?(env["HEROKU_RELEASE_VERSION"]) || present?(env["HEROKU_SLUG_COMMIT"])
-        build(env["HEROKU_RELEASE_VERSION"], env["HEROKU_SLUG_COMMIT"], "heroku_dyno_metadata")
+      elsif present?(env["HEROKU_RELEASE_VERSION"]) || present?(heroku_commit(env))
+        build(env["HEROKU_RELEASE_VERSION"], heroku_commit(env), "heroku_dyno_metadata")
       elsif present?(env["KAMAL_VERSION"])
         kamal(env["KAMAL_VERSION"])
       elsif present?(env["RENDER_GIT_COMMIT"])
@@ -114,6 +114,12 @@ module DeployAngel
         source)
     end
 
+    # HEROKU_BUILD_COMMIT (runtime-dyno-build-metadata) replaces the
+    # deprecated HEROKU_SLUG_COMMIT (runtime-dyno-metadata).
+    def self.heroku_commit(env)
+      present?(env["HEROKU_BUILD_COMMIT"]) ? env["HEROKU_BUILD_COMMIT"] : env["HEROKU_SLUG_COMMIT"]
+    end
+
     def self.present?(value)
       !value.to_s.strip.empty?
     end

data/lib/deployangel/mcp.rb

@@ -21,6 +21,10 @@ module DeployAngel
         failed means production regressed: read the findings and exceptions and investigate.
         Findings are deterministic evidence; any "investigation" field is AI inference. These tools cannot
         change production. Do not roll back or change production without explicit approval.
+        If a release isn't cleared yet, get_exercise_plan says what to exercise against production so it
+        clears sooner. Only act on status "exercisable" or "waiting_for_activity"; for "warm_up" or
+        "no_baseline" nothing you run can clear it. Exercise routes marked mutating only with a test account
+        or after asking. Report what you ran with the plan's report_with command (deployangel check).
       TEXT
 
       TARGET_PROPERTIES = {
@@ -96,6 +100,11 @@ module DeployAngel
               "until" => { "type" => "string", "enum" => %w[initial verdict], "default" => "initial" },
               "timeout_seconds" => { "type" => "integer", "minimum" => 1, "maximum" => MAX_WAIT_SECONDS, "default" => MAX_WAIT_SECONDS }
             )),
+          tool("get_exercise_plan", "What stands between a release and clearance, and what to exercise against " \
+            "production so it clears sooner: normally active routes short of their runs, routes this release changed " \
+            "that haven't run, and critical flows. Routes marked mutating change data: use a test account or ask first. " \
+            "Your requests count as ordinary traffic; report what you ran with report_with. Defaults to the current git HEAD.",
+            TARGET_PROPERTIES),
           tool("list_deployments", "Recent deployments with their verification state and verdict.",
             { "limit" => { "type" => "integer", "minimum" => 1, "maximum" => 50, "default" => 10 } }),
           tool("get_exception", "Sanitized details and the application stack trace for an exception fingerprint.",
@@ -127,6 +136,7 @@ module DeployAngel
             case name
             when "get_verification" then waiter.wait(target(arguments), wait: false).then { |o| verification_content(o) }
             when "wait_for_verification" then wait_content(arguments)
+            when "get_exercise_plan" then waiter.wait(target(arguments), wait: false).then { |o| plan_content(o) }
             when "list_deployments" then @client.deployments(limit: arguments.fetch("limit", 10))
             when "get_exception" then @client.exception(arguments.fetch("fingerprint") { raise ArgumentError, "fingerprint is required" })
             when "list_late_regressions" then @client.late_regressions(since: arguments["since"], limit: arguments.fetch("limit", 10))
@@ -157,6 +167,14 @@ module DeployAngel
             "in_progress" => outcome.exit_code == VerificationWaiter::TIMED_OUT, "verification" => outcome.document }
         end
 
+        def plan_content(outcome)
+          return { "found" => false, "note" => "No matching deployment is registered yet." } if outcome.not_found
+
+          { "deployment" => outcome.document["deployment"],
+            "exercise_plan" => outcome.document["exercise_plan"] ||
+              { "note" => "This DeployAngel server doesn't return exercise plans yet." } }
+        end
+
         def meaning(code)
           {
             0 => "verified: the release is cleared",

data/lib/deployangel/metadata.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "digest"
+require "erb"
+require "yaml"
+
+module DeployAngel
+  # What the application contains, sent once per process: the route table,
+  # job classes, declared recurring schedules, critical flows, and file
+  # digests. Paths and hashes only; source code never leaves the
+  # application.
+  #
+  # Routes and job classes are the framework's to answer, so this base
+  # reports none and DeployAngel::Rails::Metadata adds them. What no
+  # framework owns is gathered here: the schedule files sidekiq-cron and
+  # sidekiq-scheduler read, and the file digests.
+  class Metadata
+    # A Rails-style layout, which most Ruby apps share. An adapter for a
+    # framework laid out differently overrides digest_globs.
+    DIGEST_GLOBS = %w[app/**/* config/**/* lib/**/* db/migrate/**/* Gemfile.lock].freeze
+    MAX_FILES = 20_000
+    DIGEST_LENGTH = 16
+
+    # environment names the deployment ("production"), which the schedulers
+    # read to tell whether a job runs here. The agent already knows it, so
+    # nothing in this class reaches for a framework to ask.
+    def initialize(config:, root:, environment:)
+      @config = config
+      @root = root
+      @environment = environment.to_s
+    end
+
+    def to_protocol
+      {
+        "routes" => routes,
+        "job_classes" => job_classes,
+        "schedules" => schedules,
+        "critical_flows" => @config.critical_flows.transform_keys(&:to_s).transform_values { |items| Array(items).map(&:to_s) },
+        "file_manifest" => file_manifest.slice("hash", "count", "truncated")
+      }
+    end
+
+    def files
+      file_manifest["files"]
+    end
+
+    # The routes the app serves, as { "key", "controller", "action" }.
+    def routes
+      []
+    end
+
+    # The job classes the app defines, by name.
+    def job_classes
+      []
+    end
+
+    # The files digested to tell which routes a release changed, as globs
+    # relative to the app's root. Only paths and hashes are sent.
+    def digest_globs
+      DIGEST_GLOBS
+    end
+
+    # Declared recurring jobs. Each source is read on its own, so a file that
+    # can't be read leaves the others' schedules in place.
+    def schedules
+      sidekiq_cron_schedules + sidekiq_scheduler_schedules
+    end
+
+    # sidekiq-cron jobs from its schedule file (config/schedule.yml unless
+    # configured otherwise), which it loads when Sidekiq starts, or from
+    # the file in config.sidekiq_cron_schedule_file for an app that loads
+    # them itself. Jobs created in code live only in Redis, which the agent
+    # doesn't read.
+    def sidekiq_cron_schedules
+      return [] unless defined?(::Sidekiq::Cron)
+
+      path = yaml_path(sidekiq_cron_schedule_file) or return []
+      jobs = load_yaml(path)
+      jobs = jobs.map { |name, job| job.is_a?(Hash) ? job.merge("name" => name) : job } if jobs.is_a?(Hash)
+      Array(jobs).filter_map do |job|
+        next unless job.is_a?(Hash) && job["cron"] && job["status"].to_s != "disabled"
+
+        { "key" => job["name"].to_s, "class" => (job["klass"] || job["class"])&.to_s, "schedule" => job["cron"].to_s,
+          "source" => "sidekiq_cron", "time_zone" => local_time_zone }
+      end
+    rescue StandardError
+      []
+    end
+
+    def sidekiq_cron_schedule_file
+      configured = @config.sidekiq_cron_schedule_file
+      configured ||= ::Sidekiq::Cron.configuration.cron_schedule_file if ::Sidekiq::Cron.respond_to?(:configuration)
+      File.expand_path(configured || "config/schedule.yml", @root)
+    rescue StandardError
+      File.join(@root, "config", "schedule.yml")
+    end
+
+    # sidekiq-scheduler jobs from Sidekiq's config file, where it reads
+    # them under :scheduler: :schedule: (or :schedule: in older versions).
+    # A cron runs at set times; every and interval repeat from when the
+    # scheduler starts, which a deploy restarts. One-off at and in jobs
+    # aren't recurring, so they're left out.
+    def sidekiq_scheduler_schedules
+      return [] unless defined?(::SidekiqScheduler)
+
+      path = sidekiq_config_file or return []
+      config = normalize_keys(load_yaml(path) || {})
+      config = config.merge(config.delete(@environment) || {}) if config.is_a?(Hash)
+      jobs = config.dig("scheduler", "schedule") || config["schedule"]
+      return [] unless jobs.is_a?(Hash)
+
+      jobs.filter_map do |name, job|
+        next unless job.is_a?(Hash) && job["enabled"] != false && scheduled_in_this_environment?(job)
+
+        type = %w[cron every at in interval].find { |key| Array(job[key]).first.to_s.strip != "" }
+        next unless %w[cron every interval].include?(type)
+
+        value = Array(job[type]).first.to_s
+        schedule = { "key" => name.to_s, "class" => (job["class"] || name).to_s, "source" => "sidekiq_scheduler",
+          "time_zone" => local_time_zone }
+        type == "cron" ? schedule.merge("schedule" => value) : schedule.merge("schedule" => nil, "every" => value)
+      end
+    rescue StandardError
+      []
+    end
+
+    # The file Sidekiq loads: the -C path in the Procfile's sidekiq
+    # command, else config/sidekiq.yml.
+    def sidekiq_config_file
+      procfile = File.join(@root, "Procfile")
+      named = File.read(procfile)[/\bsidekiq\b[^\n]*?\s(?:-C|--config)[\s=]+(\S+)/, 1] if File.file?(procfile)
+      named ? yaml_path(File.expand_path(named, @root)) : yaml_path(File.join(@root, "config", "sidekiq.yml"))
+    rescue StandardError
+      nil
+    end
+
+    # sidekiq-scheduler skips a job whose rails_env doesn't list this one.
+    def scheduled_in_this_environment?(job)
+      job["rails_env"].nil? || job["rails_env"].to_s.gsub(/\s/, "").split(",").include?(@environment)
+    end
+
+    # The zone sidekiq-cron and sidekiq-scheduler read a schedule in when it
+    # names none: the process's local zone, as Fugit and rufus-scheduler
+    # find it. nil if that can't be told.
+    def local_time_zone
+      ::EtOrbi.determine_local_tzone&.name if defined?(::EtOrbi)
+    rescue StandardError
+      nil
+    end
+
+    # The path, or the same name with .yaml if only that exists.
+    def yaml_path(path)
+      [ path, path.sub(/\.yml\z/, ".yaml") ].find { |candidate| File.file?(candidate) }
+    end
+
+    def load_yaml(path)
+      YAML.safe_load(ERB.new(File.read(path), trim_mode: "-").result, permitted_classes: [ Symbol ], aliases: true)
+    end
+
+    # Sidekiq's config uses symbol keys (:scheduler:); compare them as
+    # plain strings.
+    def normalize_keys(object)
+      case object
+      when Hash then object.to_h { |key, value| [ key.to_s.delete_prefix(":"), normalize_keys(value) ] }
+      when Array then object.map { |value| normalize_keys(value) }
+      else object
+      end
+    end
+
+    def file_manifest
+      @file_manifest ||= begin
+        if @config.file_digests
+          paths = digest_globs.flat_map { |glob| Dir.glob(File.join(@root, glob)) }.select { |path| File.file?(path) }.uniq.sort
+          truncated = paths.size > MAX_FILES
+          files = paths.first(MAX_FILES).to_h do |path|
+            [ path.delete_prefix(@root).delete_prefix("/"), Digest::SHA256.file(path).hexdigest[0, DIGEST_LENGTH] ]
+          end
+          hash = Digest::SHA256.hexdigest(files.map { |path, digest| "#{path}:#{digest}" }.join("\n"))
+          { "hash" => hash, "count" => files.size, "truncated" => truncated, "files" => files }
+        else
+          { "hash" => nil, "count" => 0, "truncated" => false, "files" => {} }
+        end
+      end
+    rescue StandardError
+      { "hash" => nil, "count" => 0, "truncated" => false, "files" => {} }
+    end
+  end
+end

data/lib/deployangel/rack/http.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module DeployAngel
+  # Rack adapters. Inside this namespace a bare Rack means DeployAngel::Rack,
+  # so reach for the Rack gem itself as ::Rack.
+  module Rack
+    # The base for a framework's request middleware, not a middleware to use
+    # on its own: without an adapter naming routes, every successful request
+    # is unrouted and skipped, and only errors are recorded, as "unmatched".
+    # An adapter subclasses it, answers route_pattern (and rendered_exception
+    # if the framework renders exceptions itself), and is inserted at the top
+    # of the stack, so it sees the final status after the framework's own
+    # error pages. DeployAngel::Rails::Http is the Rails adapter.
+    #
+    # A request is only counted against a route pattern the framework
+    # matched, never the raw path, which keeps IDs out of route keys.
+    class Http
+      # Health checks served by a lambda or a mounted Rack app at a
+      # conventional path. Load balancers and uptime monitors call them all
+      # the time and they answer fast, so counting them would make any app
+      # look busy and healthy. Others can be left out with
+      # config.ignored_routes.
+      HEALTH_CHECK_PATHS = %w[up health healthz healthcheck health_check livez readyz statusz ping].freeze
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        return @app.call(env) unless DeployAngel.recording?
+
+        started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        Redaction.request_host = env["HTTP_HOST"]
+        begin
+          status, headers, body = @app.call(env)
+        rescue Exception => e # rubocop:disable Lint/RescueException -- recorded, then re-raised untouched
+          record(env, 500, started, unhandled: true, exception: e)
+          raise
+        end
+        # A framework that renders an exception itself swallows it before it
+        # reaches this middleware, and renders some as 4xx; only those that
+        # end in a 5xx count as unhandled.
+        exception = rendered_exception(env) if status.to_i >= 500
+        record(env, status, started, unhandled: !exception.nil?, exception: exception)
+        [ status, headers, body ]
+      end
+
+      private
+        # The route the framework matched, as a pattern with placeholders
+        # ("/users/:id"), or nil when nothing matched. Placeholders may be
+        # spelled :name, *name, or {name}; health_check? reads them, and
+        # otherwise the pattern is only ever compared with itself.
+        def route_pattern(env)
+          nil
+        end
+
+        # An exception the framework caught and rendered itself, or nil. Only
+        # asked for on a 5xx.
+        def rendered_exception(env)
+          nil
+        end
+
+        def route_key(env)
+          pattern = route_pattern(env) or return nil
+
+          "#{env["REQUEST_METHOD"]} #{pattern}"
+        end
+
+        # A static route ending in a health-check name, such as "/healthz" or
+        # "/api/livez". A route with a placeholder, such as
+        # "/patients/:id/health", is a real page about something, so it's
+        # recorded.
+        def health_check?(env)
+          pattern = route_pattern(env) or return false
+
+          segments = pattern.split("/").reject(&:empty?)
+          HEALTH_CHECK_PATHS.include?(segments.last) && segments.none? { |segment| placeholder?(segment) }
+        end
+
+        def placeholder?(segment)
+          segment.start_with?(":", "*") || segment.include?("{")
+        end
+
+        def record(env, status, started, unhandled:, exception: nil)
+          return if health_check?(env)
+
+          route = route_key(env)
+          return if route && DeployAngel.configuration.ignored_route?(route)
+          # Unrouted successes are static files and similar; unrouted
+          # errors (such as routing 404s) are still recorded.
+          return if route.nil? && status.to_i < 400
+
+          key = route || "#{env["REQUEST_METHOD"]} unmatched"
+          DeployAngel.record_exception(exception, source: "route:#{key}") if exception
+          DeployAngel.record_request(
+            route_key: key,
+            status: status.to_i,
+            duration_ms: (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000.0,
+            unhandled: unhandled,
+            # A 4xx no route matched is mostly bots probing paths like
+            # /wp-admin, or middleware turning requests away. It stays
+            # visible under "unmatched", but out of the app's totals, so it
+            # doesn't add to the evidence or dilute real pages' latency. An
+            # unrouted 5xx still counts: something broke.
+            in_totals: !route.nil? || status.to_i >= 500
+          )
+        rescue StandardError
+          nil
+        end
+    end
+  end
+end

data/lib/deployangel/rails/http.rb

@@ -2,92 +2,53 @@
 
 module DeployAngel
   module Rails
-    # Rack middleware at the top of the stack, so it sees the final status
-    # after Rails renders exceptions. Records the matched route pattern,
-    # never the raw path, which keeps IDs out of route keys.
-    class Http
+    # The Rails adapter: route identity from Action Dispatch, and the
+    # exceptions Rails renders itself. Everything else about recording a
+    # request is in DeployAngel::Rack::Http.
+    class Http < ::DeployAngel::Rack::Http
       FORMAT_SUFFIX = "(.:format)"
       # Health checks: Rails' own (/up by default), OkComputer, health_check,
-      # and rails-healthcheck, wherever they're mounted. Load balancers and
-      # uptime monitors call them all the time and they answer fast, so
-      # counting them would make any app look busy and healthy. Others can
-      # be left out with config.ignored_routes.
+      # and rails-healthcheck, wherever they're mounted. A lambda or a
+      # mounted Rack app at a conventional path is left out by the Rack
+      # adapter's HEALTH_CHECK_PATHS.
       HEALTH_CHECK_CONTROLLERS = %w[rails/health ok_computer/ok_computer health_check/health_check healthcheck/healthchecks].freeze
-      # Health checks served by a lambda or a mounted Rack app rather than a
-      # controller, at a conventional path such as /healthz.
-      HEALTH_CHECK_PATHS = %w[up health healthz healthcheck health_check livez readyz statusz ping].freeze
-
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        return @app.call(env) unless DeployAngel.recording?
-
-        started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        Redaction.request_host = env["HTTP_HOST"]
-        begin
-          status, headers, body = @app.call(env)
-        rescue Exception => e # rubocop:disable Lint/RescueException -- recorded, then re-raised untouched
-          record(env, 500, started, unhandled: true, exception: e)
-          raise
-        end
-        # Rails renders some exceptions as 4xx (routing errors, RecordNotFound,
-        # ParameterMissing); only those that end in a 5xx count as unhandled.
-        exception = env["action_dispatch.exception"] if status.to_i >= 500
-        record(env, status, started, unhandled: !exception.nil?, exception: exception)
-        [ status, headers, body ]
-      end
 
       private
-        def record(env, status, started, unhandled:, exception: nil)
-          return if health_check?(env)
-
-          route = route_key(env)
-          return if route && DeployAngel.configuration.ignored_route?(route)
-          # Unrouted successes are static files and similar; unrouted
-          # errors (such as routing 404s) are still recorded.
-          return if route.nil? && status.to_i < 400
+        def route_pattern(env)
+          pattern = env["action_dispatch.route_uri_pattern"] || env["action_dispatch.route"]&.path&.spec&.to_s
+          pattern&.delete_suffix(FORMAT_SUFFIX)
+        end
 
-          key = route || "#{env["REQUEST_METHOD"]} unmatched"
-          DeployAngel.record_exception(exception, source: "route:#{key}") if exception
-          DeployAngel.record_request(
-            route_key: key,
-            status: status.to_i,
-            duration_ms: (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000.0,
-            unhandled: unhandled,
-            # A 4xx no route matched is mostly bots probing paths like
-            # /wp-admin, or middleware turning requests away. It stays
-            # visible under "unmatched", but out of the app's totals, so it
-            # doesn't add to the evidence or dilute real pages' latency. An
-            # unrouted 5xx still counts: something broke.
-            in_totals: !route.nil? || status.to_i >= 500
-          )
-        rescue StandardError
-          nil
+        # Rails renders some exceptions as 4xx (routing errors,
+        # RecordNotFound, ParameterMissing), which is why only a 5xx asks.
+        def rendered_exception(env)
+          env["action_dispatch.exception"]
         end
 
         # A controller at a health-check path may be a real page, so only
-        # controllerless routes are judged by their path.
+        # controllerless routes (a lambda or a mounted Rack app) are judged by
+        # their path, by its last segment as in 0.1.8. A controller decides
+        # anything else, so Rails needs none of the Rack base's placeholder
+        # rule.
         def health_check?(env)
-          controller = env["action_dispatch.request.path_parameters"]&.dig(:controller)
+          controller = controller_name(env)
           return HEALTH_CHECK_CONTROLLERS.include?(controller) if controller
 
           pattern = route_pattern(env) or return false
-          HEALTH_CHECK_PATHS.include?(pattern.delete_suffix(FORMAT_SUFFIX).split("/").last)
+          HEALTH_CHECK_PATHS.include?(pattern.split("/").last)
         end
 
+        # The matched pattern, else the controller and action, which a route
+        # reached without one still has.
         def route_key(env)
-          method = env["REQUEST_METHOD"]
-          if (pattern = route_pattern(env))
-            "#{method} #{pattern.delete_suffix(FORMAT_SUFFIX)}"
-          elsif (params = env["action_dispatch.request.path_parameters"]) && params[:controller]
-            "#{method} #{params[:controller]}##{params[:action]}"
+          super || begin
+            controller = controller_name(env)
+            "#{env["REQUEST_METHOD"]} #{controller}##{env["action_dispatch.request.path_parameters"][:action]}" if controller
           end
         end
 
-        def route_pattern(env)
-          env["action_dispatch.route_uri_pattern"] || env["action_dispatch.route"]&.path&.spec&.to_s
+        def controller_name(env)
+          env["action_dispatch.request.path_parameters"]&.dig(:controller)
         end
     end
   end

data/lib/deployangel/rails/metadata.rb

@@ -1,39 +1,24 @@
 # frozen_string_literal: true
 
-require "digest"
-require "erb"
-require "yaml"
-
 module DeployAngel
   module Rails
-    # What the application contains, sent once per process: the route table,
-    # job classes, declared recurring schedules, critical flows, and file
-    # digests. Paths and hashes only; source code never leaves the
-    # application.
-    class Metadata
-      DIGEST_GLOBS = %w[app/**/* config/**/* lib/**/* db/migrate/**/* Gemfile.lock].freeze
-      MAX_FILES = 20_000
-      DIGEST_LENGTH = 16
+    # The Rails adapter: the route table from the router, job classes from
+    # Active Job, and Solid Queue'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
       FORMAT_SUFFIX = "(.:format)"
 
-      def initialize(app:, config:, root:)
+      def initialize(app:, config:, root:, environment: nil)
+        super(config: config, root: root, environment: environment || rails_environment)
         @app = app
-        @config = config
-        @root = root
-      end
-
-      def to_protocol
-        {
-          "routes" => routes,
-          "job_classes" => job_classes,
-          "schedules" => schedules,
-          "critical_flows" => @config.critical_flows.transform_keys(&:to_s).transform_values { |items| Array(items).map(&:to_s) },
-          "file_manifest" => file_manifest.slice("hash", "count", "truncated")
-        }
       end
 
-      def files
-        file_manifest["files"]
+      # Rails names the deployment, but this can be built with Rails not
+      # loaded (the bench does), and an unknown environment is better than a
+      # constructor that raises.
+      def rails_environment
+        defined?(::Rails) && ::Rails.respond_to?(:env) ? ::Rails.env.to_s : ""
       end
 
       def routes
@@ -59,11 +44,10 @@ module DeployAngel
         []
       end
 
-      # Declared recurring jobs from Solid Queue, sidekiq-cron, and
-      # sidekiq-scheduler. Each source is read on its own, so a file that
-      # can't be read leaves the others' schedules in place.
+      # Solid Queue's schedule is Rails' own; the rest are read the same way
+      # on every framework.
       def schedules
-        solid_queue_schedules + sidekiq_cron_schedules + sidekiq_scheduler_schedules
+        solid_queue_schedules + super
       end
 
       # Solid Queue recurring tasks for the current environment.
@@ -72,7 +56,7 @@ module DeployAngel
         return [] unless File.file?(path)
 
         config = YAML.safe_load(ERB.new(File.read(path)).result, aliases: true) || {}
-        tasks = config.key?(::Rails.env) ? config[::Rails.env] : config
+        tasks = config.key?(@environment) ? config[@environment] : config
         Array(tasks).filter_map do |key, task|
           next unless task.is_a?(Hash) && task["schedule"]
 
@@ -85,107 +69,6 @@ module DeployAngel
         []
       end
 
-      # sidekiq-cron jobs from its schedule file (config/schedule.yml unless
-      # configured otherwise), which it loads when Sidekiq starts, or from
-      # the file in config.sidekiq_cron_schedule_file for an app that loads
-      # them itself. Jobs created in code live only in Redis, which the agent
-      # doesn't read.
-      def sidekiq_cron_schedules
-        return [] unless defined?(::Sidekiq::Cron)
-
-        path = yaml_path(sidekiq_cron_schedule_file) or return []
-        jobs = load_yaml(path)
-        jobs = jobs.map { |name, job| job.is_a?(Hash) ? job.merge("name" => name) : job } if jobs.is_a?(Hash)
-        Array(jobs).filter_map do |job|
-          next unless job.is_a?(Hash) && job["cron"] && job["status"].to_s != "disabled"
-
-          { "key" => job["name"].to_s, "class" => (job["klass"] || job["class"])&.to_s, "schedule" => job["cron"].to_s,
-            "source" => "sidekiq_cron", "time_zone" => local_time_zone }
-        end
-      rescue StandardError
-        []
-      end
-
-      def sidekiq_cron_schedule_file
-        configured = @config.sidekiq_cron_schedule_file
-        configured ||= ::Sidekiq::Cron.configuration.cron_schedule_file if ::Sidekiq::Cron.respond_to?(:configuration)
-        File.expand_path(configured || "config/schedule.yml", @root)
-      rescue StandardError
-        File.join(@root, "config", "schedule.yml")
-      end
-
-      # sidekiq-scheduler jobs from Sidekiq's config file, where it reads
-      # them under :scheduler: :schedule: (or :schedule: in older versions).
-      # A cron runs at set times; every and interval repeat from when the
-      # scheduler starts, which a deploy restarts. One-off at and in jobs
-      # aren't recurring, so they're left out.
-      def sidekiq_scheduler_schedules
-        return [] unless defined?(::SidekiqScheduler)
-
-        path = sidekiq_config_file or return []
-        config = normalize_keys(load_yaml(path) || {})
-        config = config.merge(config.delete(::Rails.env.to_s) || {}) if config.is_a?(Hash)
-        jobs = config.dig("scheduler", "schedule") || config["schedule"]
-        return [] unless jobs.is_a?(Hash)
-
-        jobs.filter_map do |name, job|
-          next unless job.is_a?(Hash) && job["enabled"] != false && scheduled_in_this_environment?(job)
-
-          type = %w[cron every at in interval].find { |key| Array(job[key]).first.to_s.strip != "" }
-          next unless %w[cron every interval].include?(type)
-
-          value = Array(job[type]).first.to_s
-          schedule = { "key" => name.to_s, "class" => (job["class"] || name).to_s, "source" => "sidekiq_scheduler",
-            "time_zone" => local_time_zone }
-          type == "cron" ? schedule.merge("schedule" => value) : schedule.merge("schedule" => nil, "every" => value)
-        end
-      rescue StandardError
-        []
-      end
-
-      # The file Sidekiq loads: the -C path in the Procfile's sidekiq
-      # command, else config/sidekiq.yml.
-      def sidekiq_config_file
-        procfile = File.join(@root, "Procfile")
-        named = File.read(procfile)[/\bsidekiq\b[^\n]*?\s(?:-C|--config)[\s=]+(\S+)/, 1] if File.file?(procfile)
-        named ? yaml_path(File.expand_path(named, @root)) : yaml_path(File.join(@root, "config", "sidekiq.yml"))
-      rescue StandardError
-        nil
-      end
-
-      # sidekiq-scheduler skips a job whose rails_env doesn't list this one.
-      def scheduled_in_this_environment?(job)
-        job["rails_env"].nil? || job["rails_env"].to_s.gsub(/\s/, "").split(",").include?(::Rails.env.to_s)
-      end
-
-      # The zone sidekiq-cron and sidekiq-scheduler read a schedule in when it
-      # names none: the process's local zone, as Fugit and rufus-scheduler
-      # find it. nil if that can't be told.
-      def local_time_zone
-        ::EtOrbi.determine_local_tzone&.name if defined?(::EtOrbi)
-      rescue StandardError
-        nil
-      end
-
-      # The path, or the same name with .yaml if only that exists.
-      def yaml_path(path)
-        [ path, path.sub(/\.yml\z/, ".yaml") ].find { |candidate| File.file?(candidate) }
-      end
-
-      def load_yaml(path)
-        YAML.safe_load(ERB.new(File.read(path), trim_mode: "-").result, permitted_classes: [ Symbol ], aliases: true)
-      end
-
-      # Sidekiq's config uses symbol keys (:scheduler:); compare them as
-      # plain strings.
-      def normalize_keys(object)
-        case object
-        when Hash then object.to_h { |key, value| [ key.to_s.delete_prefix(":"), normalize_keys(value) ] }
-        when Array then object.map { |value| normalize_keys(value) }
-        else object
-        end
-      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
@@ -205,24 +88,6 @@ module DeployAngel
       rescue StandardError
         nil
       end
-
-      def file_manifest
-        @file_manifest ||= begin
-          if @config.file_digests
-            paths = DIGEST_GLOBS.flat_map { |glob| Dir.glob(File.join(@root, glob)) }.select { |path| File.file?(path) }.sort
-            truncated = paths.size > MAX_FILES
-            files = paths.first(MAX_FILES).to_h do |path|
-              [ path.delete_prefix(@root).delete_prefix("/"), Digest::SHA256.file(path).hexdigest[0, DIGEST_LENGTH] ]
-            end
-            hash = Digest::SHA256.hexdigest(files.map { |path, digest| "#{path}:#{digest}" }.join("\n"))
-            { "hash" => hash, "count" => files.size, "truncated" => truncated, "files" => files }
-          else
-            { "hash" => nil, "count" => 0, "truncated" => false, "files" => {} }
-          end
-        end
-      rescue StandardError
-        { "hash" => nil, "count" => 0, "truncated" => false, "files" => {} }
-      end
     end
   end
 end

data/lib/deployangel/rails/railtie.rb

@@ -29,7 +29,7 @@ module DeployAngel
           framework_version: ::Rails.version,
           logger: ::Rails.logger
         )
-        agent&.metadata = DeployAngel::Rails::Metadata.new(app: app, config: DeployAngel.configuration, root: ::Rails.root.to_s)
+        agent&.metadata = DeployAngel::Rails::Metadata.new(app: app, config: DeployAngel.configuration, root: ::Rails.root.to_s, environment: ::Rails.env)
       end
     end
   end

data/lib/deployangel/version.rb

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

data/lib/deployangel.rb

@@ -111,9 +111,11 @@ module DeployAngel
   end
 end
 
+require_relative "deployangel/rack/http"
 require_relative "deployangel/rails/http"
 require_relative "deployangel/rails/active_job"
 require_relative "deployangel/rails/error_subscriber"
+require_relative "deployangel/metadata"
 require_relative "deployangel/rails/metadata"
 require_relative "deployangel/sidekiq"
 require_relative "deployangel/apartment"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deployangel
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.12
 platform: ruby
 authors:
 - Jordan Owens
@@ -9,9 +9,11 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: Aggregates HTTP request behavior in-process and reports one small payload
-  per process per minute to DeployAngel, which verifies each deployment and tells
-  you when it is safe to stop watching it.
+description: Aggregates HTTP requests, background jobs, exceptions, and recurring
+  schedules in-process and reports one small payload per process per minute to DeployAngel,
+  which verifies each deployment and tells you, or your coding agent, when a release
+  is cleared and safe to stop watching. It never sends request bodies, parameters,
+  SQL, or user data.
 email:
 - jordan@deployangel.com
 executables:
@@ -45,6 +47,8 @@ files:
 - lib/deployangel/core/transport.rb
 - lib/deployangel/fork_hook.rb
 - lib/deployangel/mcp.rb
+- lib/deployangel/metadata.rb
+- lib/deployangel/rack/http.rb
 - lib/deployangel/rails/active_job.rb
 - lib/deployangel/rails/error_subscriber.rb
 - lib/deployangel/rails/http.rb