deployangel 0.1.9 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2bc6936b563039a1c2caa91f3a8125f0c32582366505ab35dfabf2ec90af3c5
-  data.tar.gz: 22c805b0adef58922b3513afc19492433421358be2e75fd12513e650a7e57c9c
+  metadata.gz: 832e7ada784cf0e86d34f802ef299dfd9114b844f542444a69331b7d622e3d35
+  data.tar.gz: 31c8f9e2efc46a96325e7813c8b5902c23cbf758c55dccdb3536048af881f7a7
 SHA512:
-  metadata.gz: 361b042f1d885fc63442dff6d4f4c406b36fd14ea5c226cf04a5bea2f7537770c6b4f4ad169331b95e6f3bdacf37169f90ac70fc6567006203f4884fe021236a
-  data.tar.gz: 328b709591c7c5441390fb74dc535d0a515061fd64161bbe555ffe9f4f8602bf32f10676b6119458e44837ee539e96e5e2f4d72b97cafc05e203d3ef2eb77e7b
+  metadata.gz: a0e4683b471211a023e925fa4cbacdd57f908c0a1c1ee18af950490b291b47c9cfe9a33bb4d3a5e376e5992f8d478919167d0d32320448c5c3c362a9873e6afa
+  data.tar.gz: 2cc10162cd04a158808c71eb51fb30b36716a3d9ca8e70c231d35289de887810194bf0b172481fd0f68d5ad025e36e3b8dda6b34335b2701b7b9b6980e5ea1d0

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 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`)
+  sends exceptions with their class, fingerprint, and application frames, and
+  no message. Grouping and verdicts work the same.
+- The request's host is replaced with `<host>` in exception messages, and with
+  ros-apartment, so are the tenants the request or job switched to
+  (`<tenant>`), including one that turned out not to exist. The default tenant
+  is left alone.
+- ECS, including Fargate: the release comes from the container's image, read
+  once at boot from `ECS_CONTAINER_METADATA_URI_V4`. A tag that's a commit is
+  the commit, another tag is the version, and a moving tag such as `latest` uses
+  the image digest. `DEPLOYANGEL_REVISION` and a `REVISION` file still win.
+
 ## 0.1.9 (2026-10-04)
 
 - A 4xx response to a request no route matched, such as a bot probing

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
@@ -34,9 +36,14 @@ The agent must know which release it is running. It finds it in this order:
    didn't come from GitHub
 7. Coolify: `SOURCE_COMMIT`. Dokku: `GIT_REV`
 8. a `REVISION` file in the app root, which Capistrano writes and any build step can
+9. ECS, including Fargate: the container's image, from the metadata endpoint ECS
+   provides (one local request at boot). The image tag is the release when it's a
+   commit or a version like `v1.4.2`; with a moving tag like `latest`, the image
+   digest is
 
-For other Docker deploys (compose, Swarm, ECS, Kubernetes), bake the commit into
-the image, since `.dockerignore` usually leaves `.git` out:
+For other Docker deploys (compose, Swarm, Kubernetes), and on ECS to see each
+release by its commit, bake the commit into the image, since `.dockerignore`
+usually leaves `.git` out:
 
 ```dockerfile
 ARG GIT_SHA
@@ -63,9 +70,13 @@ says so.
   middleware. Failures that `retry_on` or `discard_on` handle still count.
 - Release identity, runtime versions, and a per-process instance ID.
 
-- Exceptions: a stable fingerprint, the exception class, a sanitized message
-  (numbers, IDs, emails, and quoted values removed), and application frames
-  only.
+- Exceptions: a stable fingerprint, the exception class, the first line of the
+  message, and application frames only. In the message, numbers, IDs, emails,
+  UUIDs, long hex strings, and quoted values are replaced with placeholders, and
+  so are the request's host and, with ros-apartment, the tenants the request or
+  job switched to. Other words are kept: `Payment failed for Jane Doe` is sent
+  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
   flows, and file digests (relative paths and hashes, never file contents) so
@@ -140,6 +151,29 @@ DeployAngel.configure do |config|
 end
 ```
 
+`DEPLOYANGEL_ENABLED=true|false` forces reporting on or off in any environment.
+`DEPLOYANGEL_URL` overrides the API endpoint (default `https://api.deployangel.com`).
+
+### Exception messages
+
+To send exceptions without any message, only their class, fingerprint, and
+application frames:
+
+```ruby
+DeployAngel.configure do |config|
+  config.exception_messages = false # or DEPLOYANGEL_EXCEPTION_MESSAGES=false
+end
+```
+
+Grouping, new-exception detection, and verdicts work the same, since the
+fingerprint never uses the message. You lose the message text in the dashboard,
+notifications, and AI investigation. With messages off, what leaves your app is
+route patterns, counts, timings, job class names, exception classes, and
+application file paths and method names, plus the route table, job classes,
+schedules, and file digests described above.
+
+### Recurring jobs
+
 DeployAngel expects declared recurring jobs on schedule. It reads Solid Queue's
 `config/recurring.yml`, sidekiq-scheduler's section of Sidekiq's config, and
 sidekiq-cron's schedule file (`config/schedule.yml` unless sidekiq-cron is
@@ -156,9 +190,6 @@ end
 Jobs that exist only in Redis, such as ones created in code or in the
 Sidekiq web UI, aren't read.
 
-`DEPLOYANGEL_ENABLED=true|false` forces reporting on or off in any environment.
-`DEPLOYANGEL_URL` overrides the API endpoint (default `https://api.deployangel.com`).
-
 ## Checkpoints
 
 Errors and latency don't catch work that silently stops happening. Count the
@@ -214,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

data/lib/deployangel/agent.rb

@@ -91,7 +91,9 @@ module DeployAngel
 
       exception.instance_variable_set(SEEN, true) unless exception.frozen?
       start_reporter
-      @aggregator.record_exception(Fingerprint.for(exception, root: @root), source: source, handled: handled,
+      messages = config.exception_messages
+      details = Fingerprint.for(exception, root: @root, message: messages, redactions: messages ? Redaction.current : [])
+      @aggregator.record_exception(details, source: source, handled: handled,
         backtrace: Fingerprint.backtrace(exception, root: @root))
     rescue StandardError => e
       warn_once(:record_exception, "DeployAngel failed to record an exception: #{e.class}: #{e.message}")

data/lib/deployangel/apartment.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module DeployAngel
+  # Notes each tenant ros-apartment switches to, before switching, so even a
+  # tenant that turns out not to exist ("Could not find schema acme") is
+  # replaced in exception messages (Redaction). The default tenant, usually
+  # "public", is left alone.
+  module Apartment
+    module Switch
+      def switch!(tenant = nil)
+        begin
+          DeployAngel::Redaction.note_tenant(tenant) unless tenant.nil? || tenant.to_s == default_tenant.to_s
+        rescue StandardError
+          nil
+        end
+        super
+      end
+    end
+
+    def self.install
+      return unless defined?(::Apartment::Tenant)
+
+      require "apartment/adapters/abstract_adapter" unless defined?(::Apartment::Adapters::AbstractAdapter)
+      adapter = ::Apartment::Adapters::AbstractAdapter
+      adapter.prepend(Switch) unless adapter < Switch
+    rescue LoadError, StandardError
+      nil
+    end
+  end
+end

data/lib/deployangel/cli/formatter.rb

@@ -18,45 +18,113 @@ module DeployAngel
       module_function
 
       def verification(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(" · ")
-        if (check = v["initial_check"]) && v["verdict"].nil?
-          lines << "Initial check: #{check["result"].tr("_", " ")}. Not cleared yet."
+        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
-        lines << "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})"
+        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
 
-        findings = Array(document["findings"])
-        problems = findings.select { |f| %w[failing warning].include?(f["status"]) }
+      # 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 << "Findings:"
-          problems.each { |f| lines << "  #{f["status"].ljust(8)} #{finding_line(f)}" }
+          lines.push("", "| Status | Finding |", "| --- | --- |")
+          problems.each { |f| lines << "| #{f["status"]} | #{cell(finding_line(f))} |" }
         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?}"
+        if (gathering = gathering_line(document))
+          lines.push("", gathering)
         end
-        unless v["verdict"] == "failed"
-          section(lines, "Missing evidence", Array(clearance["missing_evidence"])) { |item| item }
+        sections(document).each do |title, items|
+          lines.push("", "**#{title}**", "")
+          items.each { |item| lines << "- #{item}" }
         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"]}"
+        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"] || {}
+        [ "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?
+          notes << "Initial check: #{check["result"].tr("_", " ")}. Not cleared yet."
         end
+        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")
+          notes << "Promoted from #{source["environment"]} #{source["version"] || source["commit"].to_s[0, 7]} (#{outcome})"
+        end
+        notes
+      end
+
+      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" }
-        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")
+        [
+          [ "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"] } ],
+          [ "Late regressions", Array(document["late_regressions"]).map { |late| late["summary"] } ]
+        ].reject { |_, items| items.empty? }
+      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
       end
 
       def exception(details)
@@ -82,10 +150,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

@@ -139,11 +139,13 @@ 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
@@ -228,6 +230,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/configuration.rb

@@ -11,7 +11,7 @@ module DeployAngel
 
     attr_accessor :token, :endpoint, :enabled, :environments, :release_version, :revision,
       :flush_interval, :open_timeout, :read_timeout, :max_queued_payloads, :max_routes, :logger,
-      :file_digests, :critical_flows, :ignored_routes, :sidekiq_cron_schedule_file
+      :file_digests, :critical_flows, :ignored_routes, :sidekiq_cron_schedule_file, :exception_messages
 
     def initialize(env = ENV)
       @token = env["DEPLOYANGEL_TOKEN"]
@@ -27,6 +27,9 @@ module DeployAngel
       @max_routes = 100
       @logger = Logger.new($stderr, level: Logger::WARN, progname: "deployangel")
       @file_digests = parse_boolean(env["DEPLOYANGEL_FILE_DIGESTS"]) != false
+      # Off, exceptions are sent with their class and frames only, never a
+      # message, for apps whose messages may hold personal or health data.
+      @exception_messages = parse_boolean(env["DEPLOYANGEL_EXCEPTION_MESSAGES"]) != false
       @critical_flows = {}
       # Route keys as the dashboard shows them, such as "GET /healthz".
       @ignored_routes = []

data/lib/deployangel/core/fingerprint.rb

@@ -21,13 +21,15 @@ module DeployAngel
 
     module_function
 
-    def for(exception, root:)
+    # message: false leaves the message out entirely. redactions are
+    # [value, placeholder] pairs replaced first (Redaction).
+    def for(exception, root:, message: true, redactions: [])
       frame = top_frame(exception, root: root)
       {
         "fingerprint" => Digest::SHA256.hexdigest([ "v#{VERSION}", exception.class.name, frame ].join("|"))[0, 32],
         "fingerprint_version" => VERSION,
         "exception_class" => exception.class.name,
-        "message" => normalize_message(exception.message),
+        "message" => (normalize_message(exception.message, redactions) if message),
         "top_frame" => frame,
         "app_frame" => app_frame?(frame)
       }
@@ -50,8 +52,13 @@ module DeployAngel
         .map { |path, label| "#{normalize_path(path, root)}##{label}" }
     end
 
-    def normalize_message(message)
+    # Only quoted values, numbers, emails, UUIDs, and long hex are replaced;
+    # unquoted words, such as a name in a message the app builds, are kept.
+    def normalize_message(message, redactions = [])
       text = message.to_s.lines.first.to_s.strip
+      redactions.each do |value, placeholder|
+        text = text.gsub(/(?<![[:alnum:]])#{Regexp.escape(value)}(?![[:alnum:]])/i, placeholder)
+      end
       MESSAGE_PLACEHOLDERS.each { |pattern, placeholder| text = text.gsub(pattern, placeholder) }
       text[0, MAX_MESSAGE]
     end

data/lib/deployangel/core/redaction.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module DeployAngel
+  # Values that name a customer of the app rather than its code, replaced in
+  # exception messages before they're cleaned: the request's host and, with
+  # ros-apartment, the tenants this thread last switched to. Kept per thread
+  # (per fiber), where the request or job that raised ran.
+  module Redaction
+    HOST = :deployangel_request_host
+    TENANTS = :deployangel_tenants
+    MAX_TENANTS = 5
+    # Shorter names would replace ordinary words.
+    MIN_LENGTH = 3
+
+    module_function
+
+    def request_host=(host)
+      Thread.current[HOST] = host
+    end
+
+    def note_tenant(tenant)
+      name = tenant.to_s.strip
+      return if name.length < MIN_LENGTH
+
+      tenants = (Thread.current[TENANTS] ||= [])
+      tenants.delete(name)
+      tenants.unshift(name)
+      tenants.pop while tenants.size > MAX_TENANTS
+    end
+
+    # [value, placeholder] pairs, longest first, so a host is replaced before
+    # a tenant name inside it.
+    def current
+      host = Thread.current[HOST].to_s.sub(/:\d+\z/, "")
+      pairs = Array(Thread.current[TENANTS]).map { |tenant| [ tenant, "<tenant>" ] }
+      pairs << [ host, "<host>" ] if host.length >= MIN_LENGTH
+      pairs.sort_by { |value, _| -value.length }
+    end
+  end
+end

data/lib/deployangel/core/release.rb

@@ -1,19 +1,26 @@
 # frozen_string_literal: true
 
+require "json"
+require "net/http"
+require "uri"
+
 module DeployAngel
   # Which release this process is running, resolved once at boot so that
   # telemetry can be attributed to a deployment.
   class Release < Struct.new(:version, :commit, :source)
     COMMIT_FORMAT = /\A[0-9a-f]{7,40}\z/
 
+    # Tags that move from build to build, so they can't identify a release.
+    MOVING_TAGS = %w[latest main master production prod staging stable release].freeze
+
     # Order: explicit configuration, Heroku dyno metadata, the hosting
     # platform's own variables (Kamal, Render, Fly.io, Railway, Coolify, and
-    # Dokku's GIT_REV), then a REVISION file.
-    def self.resolve(config:, env: ENV, root: nil)
+    # Dokku's GIT_REV), a REVISION file, then ECS container metadata.
+    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"])
@@ -29,6 +36,8 @@ module DeployAngel
         build(nil, env["GIT_REV"], "git_rev")
       elsif root && File.file?(revision_path = File.join(root, "REVISION"))
         build(nil, File.read(revision_path, 100), "revision_file")
+      elsif present?(env["ECS_CONTAINER_METADATA_URI_V4"]) && (release = ecs(http.call(env["ECS_CONTAINER_METADATA_URI_V4"])))
+        release
       else
         new(nil, nil, "unknown")
       end
@@ -64,6 +73,38 @@ module DeployAngel
       tag unless tag.empty?
     end
 
+    # ECS (Fargate, and EC2 with a recent agent) serves each container's
+    # metadata at ECS_CONTAINER_METADATA_URI_V4. The image tag identifies the
+    # release, and is the commit when it looks like one. A moving tag such
+    # as "latest" can't, so the image digest does instead.
+    def self.ecs(body)
+      data = JSON.parse(body.to_s)
+      return unless data.is_a?(Hash)
+
+      tag = data["Image"].to_s.split("@", 2).first.to_s.split("/").last.to_s.split(":", 2)[1].to_s.strip
+      if tag.downcase.match?(COMMIT_FORMAT)
+        build(nil, tag, "ecs")
+      elsif present?(tag) && !MOVING_TAGS.include?(tag.downcase)
+        build(tag, nil, "ecs")
+      elsif (digest = data["ImageID"].to_s[/\Asha256:(\h{12})/, 1])
+        build("sha256:#{digest}", nil, "ecs")
+      end
+    rescue JSON::ParserError
+      nil
+    end
+
+    # One request at boot to the container's own metadata endpoint, which
+    # is local, so the timeouts are short. Nil on any failure.
+    def self.fetch_metadata(uri)
+      uri = URI.parse(uri)
+      Net::HTTP.start(uri.host, uri.port, open_timeout: 0.5, read_timeout: 1) do |http|
+        response = http.get(uri.request_uri)
+        response.body if response.is_a?(Net::HTTPSuccess)
+      end
+    rescue StandardError
+      nil
+    end
+
     # The cloud rejects malformed commits, which would drop every payload,
     # so anything that is not a hex SHA is left out.
     def self.build(version, commit, source)
@@ -73,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/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,91 +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)
-        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

@@ -21,6 +21,7 @@ module DeployAngel
       end
 
       config.after_initialize do |app|
+        DeployAngel::Apartment.install if DeployAngel.configuration.exception_messages
         agent = DeployAngel.start(
           environment: ::Rails.env,
           root: ::Rails.root.to_s,
@@ -28,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.9"
+  VERSION = "0.1.11"
 end

data/lib/deployangel.rb

@@ -3,6 +3,7 @@
 require_relative "deployangel/version"
 require_relative "deployangel/configuration"
 require_relative "deployangel/core/histogram"
+require_relative "deployangel/core/redaction"
 require_relative "deployangel/core/fingerprint"
 require_relative "deployangel/core/release"
 require_relative "deployangel/core/instance"
@@ -110,9 +111,12 @@ 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"
 require_relative "deployangel/rails/railtie" if defined?(::Rails::Railtie)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deployangel
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.11
 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:
@@ -25,6 +27,7 @@ files:
 - exe/deployangel
 - lib/deployangel.rb
 - lib/deployangel/agent.rb
+- lib/deployangel/apartment.rb
 - lib/deployangel/capistrano.rb
 - lib/deployangel/capistrano/steps.rb
 - lib/deployangel/capistrano/tasks.rake
@@ -39,10 +42,13 @@ files:
 - lib/deployangel/core/histogram.rb
 - lib/deployangel/core/instance.rb
 - lib/deployangel/core/protocol.rb
+- lib/deployangel/core/redaction.rb
 - lib/deployangel/core/release.rb
 - 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