deployangel 0.1.18 → 0.1.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66584e07c5d50f166891f5b6779fa2fa8db383a923d074458e7bb09ff46e525a
-  data.tar.gz: 95b445b37424f7b92ab0ec5394f5fa35c10864f5738f10959dfb9822c73c0980
+  metadata.gz: 59eed3c6629b0dc5b81cbec2636583d50f0038c2f51af8011108205a1a23eb8c
+  data.tar.gz: d10e3a967bed17b69b854a5b74deba72b66ad4e204b3c007bd1958fc81e1ca66
 SHA512:
-  metadata.gz: 87ce3ddb256c2df177bb3a4c2390b2ce50a98d97bd25e654d90153b29d9474bd4208cfb80b2bca3cf61d6a5174042dbe8a4e2c966e374a38b0371bf2e3dc19ad
-  data.tar.gz: ff4a1a677217b025f7393b0c586472a57b4b232406d44e4c76b3cb37ed4fd09d265f9052f47d9d50e182c9d3ddb5892e1757dbd7293b3910cb3a248000dabb0d
+  metadata.gz: cecef6e5f9328a9b72877c16bbd51388d67a5673b98a75a56c78e6916f5bf99fd033baaf9056f101b25cd36553d0e6033a253800f571ecfab3724655f1301901
+  data.tar.gz: cb8460812b9f04eaf761e23282a644c62f4de9aaca20fcf42e1bc81478f898e096675fd1bdfc67e70aef60ac3053bce969de7310539b9261b036c262dae70bd1

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.1.20 (2026-10-09)
+
+- `deployangel exercise --url=<production URL>` sends a release's exercise
+  plan's read-only requests (GET routes without path parameters, at most
+  200, about 5 a second) so a quiet release can clear sooner, then records
+  what it sent on the release, which lists it as exercised from your side.
+  It skips and names routes that change data or need a path parameter.
+  `--dry-run` shows what it would send.
+- The agent instructions `deployangel install agents` writes now tell the
+  agent to run `deployangel exercise` when a release isn't cleared yet.
+
+## 0.1.19 (2026-10-09)
+
+- `deployangel install agents` sets up Claude Code, Cursor, and Codex in a
+  project: the MCP server in `.mcp.json`, `.cursor/mcp.json`, and
+  `.codex/config.toml` (forwarding `DEPLOYANGEL_API_TOKEN`), and instructions
+  to wait for a verdict after deploying in `AGENTS.md`, with a `CLAUDE.md`
+  that imports it. It never replaces existing entries, and re-running it only
+  updates its own instructions.
+
 ## 0.1.18 (2026-10-08)
 
 - In Rails, the agent gets its file digests when it starts, so the reporter

data/README.md

@@ -392,6 +392,7 @@ bundle exec deployangel verify --wait                  # current git HEAD, until
 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 exercise --url=https://example.com  # send the plan's read-only requests
 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>
@@ -413,6 +414,22 @@ choose with `--format=text|json`. Exit codes:
 
 ### MCP server
 
+To set up Claude Code, Cursor, and Codex for a project in one step, run this
+in the project:
+
+```bash
+bundle exec deployangel install agents
+```
+
+It adds the MCP server to `.mcp.json` (Claude Code), `.cursor/mcp.json`
+(Cursor), and `.codex/config.toml` (Codex, which reads it only in projects you
+trust), and the instructions below to `AGENTS.md`, with a `CLAUDE.md` that
+imports it. It never replaces an existing entry, and running it again updates
+only its own instructions. Commit the files; the token stays in your
+environment.
+
+Or add the server yourself:
+
 ```bash
 claude mcp add deployangel -- bundle exec deployangel mcp    # Claude Code
 ```
@@ -448,15 +465,27 @@ 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.
 
+`deployangel exercise --url=<production URL>` does the read-only part for
+you, from wherever it runs: it requests the plan's GET routes that have no
+path parameters, spreading any request shortfall across them (at most 200
+requests, about 5 a second, as `DeployAngel-Exercise`), then records what it
+sent on the release, where the page lists it under "Exercised from your
+side". It skips and names routes that change data or need a path
+parameter. A "CLI & coding agents" token can run it. `--dry-run` shows what
+it would send.
+
 ### Suggested instructions for your coding agent
 
-Add this to your `CLAUDE.md` or `AGENTS.md`:
+`deployangel install agents` adds instructions like these. To add them
+yourself, put this in your `CLAUDE.md` or `AGENTS.md`:
 
 ```markdown
-## Production verification
+## Production verification (DeployAngel)
 
-After deploying, run `bundle exec deployangel verify --wait --until initial`
-(or call the `wait_for_verification` MCP tool with `until: "initial"`).
+After deploying, or pushing a commit that deploys, wait for DeployAngel's
+verdict: call the `wait_for_verification` MCP tool with the commit and
+`until: "initial"`, calling again while it's in progress, or run
+`bundle exec deployangel verify --commit=<sha> --wait --until=initial`.
 
 - Exit 0 / verified: the release is cleared. Report the clearance line and
   anything DeployAngel is still watching, then move on.
@@ -466,17 +495,16 @@ After deploying, run `bundle exec deployangel verify --wait --until initial`
 - Exit 7: warnings at the initial check. Report them and review the findings.
   The release is NOT cleared.
 - Exit 2 / inconclusive: the release is NOT verified. Do not claim success.
-- Exit 1 / failed: read the findings and exceptions, investigate the likely
-  cause, and propose a fix. Do not roll back or change production without
-  explicit approval.
+- Exit 1 / failed: read the findings and exceptions (`get_exception`),
+  investigate the likely 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.
+- Not cleared yet: call `get_exercise_plan` (or `bundle exec deployangel plan`).
+  If its status is "exercisable" or "waiting_for_activity", run
+  `bundle exec deployangel exercise --url=<production URL>`: it sends the
+  plan's read-only requests and records them on the release. Offer to
+  exercise what it skips: routes that change data only with a test account
+  or after asking. If the status is "warm_up", nothing run can clear it.
 ```
 
 ## Development

data/lib/deployangel/cli.rb

@@ -11,13 +11,14 @@ require_relative "client"
 require_relative "ci_environment"
 require_relative "verification_waiter"
 require_relative "cli/formatter"
+require_relative "exerciser"
 
 module DeployAngel
   # `deployangel` command for developers, CI, and coding agents.
   # Runs without booting Rails.
   class CLI
     USAGE_ERROR = 5
-    COMMANDS = %w[release verify status exception check install mcp version help].freeze
+    COMMANDS = %w[release verify status plan exercise exception check install mcp version help].freeze
 
     HELP = <<~TEXT
       Usage: deployangel <command> [options]
@@ -30,11 +31,14 @@ module DeployAngel
         status     Latest deployment and its verification
         plan       What to exercise so a release  [--commit=SHA | --version=V | --deployment=ID]
                    clears sooner                 [--format=text|json]
+        exercise   Send the plan's read-only      --url=PRODUCTION_URL [--commit=SHA | --version=V | --deployment=ID]
+                   requests to production        [--max-requests=200] [--dry-run]
         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 Kamal deploy hook, or    deployangel install kamal
-                   bake the commit into an image  deployangel install docker
+        install    Add a Kamal deploy hook,       deployangel install kamal
+                   bake the commit into an image, deployangel install docker
+                   or set up coding agents        deployangel install agents
         mcp        Run the MCP server over stdio (for coding agents)
 
       With no target, verify, plan, and check use the current git HEAD commit.
@@ -71,6 +75,47 @@ module DeployAngel
       Kamal apps don't need this: DeployAngel reads Kamal's KAMAL_VERSION.
     HELP
 
+    # The block `deployangel install agents` keeps in AGENTS.md (and CLAUDE.md
+    # when it doesn't import AGENTS.md), replaced whole on each run.
+    AGENTS_START = "<!-- deployangel:start -->"
+    AGENTS_END = "<!-- deployangel:end -->"
+    AGENT_INSTRUCTIONS = <<~MARKDOWN
+      #{AGENTS_START}
+      ## Production verification (DeployAngel)
+
+      After deploying, or pushing a commit that deploys, wait for DeployAngel's
+      verdict: call the `wait_for_verification` MCP tool with the commit and
+      `until: "initial"`, calling again while it's in progress, or run
+      `bundle exec deployangel verify --commit=<sha> --wait --until=initial`.
+
+      - Exit 0 / verified: the release is cleared. Report the clearance line and
+        anything DeployAngel is still watching, then move on.
+      - Exit 6: no problems so far, but NOT cleared. Report "no problems so far, not
+        yet cleared" and the expected clearance time. DeployAngel keeps verifying and
+        alerts on failure.
+      - Exit 7: warnings at the initial check. Report them and review the findings.
+        The release is NOT cleared.
+      - Exit 2 / inconclusive: the release is NOT verified. Do not claim success.
+      - Exit 1 / failed: read the findings and exceptions (`get_exception`),
+        investigate the likely 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: call `get_exercise_plan` (or `bundle exec deployangel plan`).
+        If its status is "exercisable" or "waiting_for_activity", run
+        `bundle exec deployangel exercise --url=<production URL>`: it sends the
+        plan's read-only requests and records them on the release. Offer to
+        exercise what it skips: routes that change data only with a test account
+        or after asking. If the status is "warm_up", nothing run can clear it.
+      #{AGENTS_END}
+    MARKDOWN
+
+    AGENTS_TOKEN_HELP = <<~HELP.chomp
+      The MCP server and CLI need DEPLOYANGEL_API_TOKEN, a "CLI & coding agents" token
+      from the app's Settings, in the environment your agent runs in (for example in
+      an .envrc with direnv). Never put it in these files: they're meant to be committed.
+      Codex reads .codex/config.toml only in projects you've marked as trusted.
+    HELP
+
     DOCKERFILE_LINES = <<~DOCKERFILE
       # The commit this image runs, for DeployAngel. Build with --build-arg GIT_SHA=$(git rev-parse HEAD).
       ARG GIT_SHA
@@ -78,7 +123,7 @@ module DeployAngel
     DOCKERFILE
 
     def initialize(argv, env: ENV, stdin: $stdin, stdout: $stdout, stderr: $stderr, client: nil,
-                   sleeper: ->(seconds) { sleep(seconds) }, clock: -> { Time.now }, git_head: nil, root: Dir.pwd)
+                   sleeper: ->(seconds) { sleep(seconds) }, clock: -> { Time.now }, git_head: nil, root: Dir.pwd, requester: nil)
       @root = root
       @argv = argv.dup
       @env = env
@@ -89,6 +134,7 @@ module DeployAngel
       @sleeper = sleeper
       @clock = clock
       @git_head = git_head
+      @requester = requester
     end
 
     def run
@@ -98,6 +144,7 @@ module DeployAngel
       when "verify" then verify
       when "status" then verify(status: true)
       when "plan" then plan
+      when "exercise" then exercise
       when "exception" then exception
       when "check" then check
       when "install" then install
@@ -197,6 +244,56 @@ module DeployAngel
         0
       end
 
+      # Sends the plan's read-only requests from here, then records what it
+      # sent on the release (spec §16, Exercise records).
+      def exercise
+        options = parse(max_requests: Exerciser::MAX_REQUESTS, dry_run: false) do |o, opts|
+          o.on("--url=URL") { |v| opts[:url] = v }
+          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("--max-requests=N", Integer) { |v| opts[:max_requests] = v }
+          o.on("--dry-run") { opts[:dry_run] = true }
+        end
+        return usage_error("exercise needs --url, the app's production URL, like https://example.com") unless options[:url].to_s.match?(%r{\Ahttps?://[^/\s]+})
+
+        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
+        plan = document["exercise_plan"] || {}
+        unless %w[exercisable waiting_for_activity].include?(plan["status"])
+          @stdout.puts("Nothing to exercise. #{plan["summary"]}".rstrip)
+          return 0
+        end
+
+        exerciser = Exerciser.new(base_url: options[:url], max_requests: options[:max_requests].clamp(1, Exerciser::MAX_REQUESTS),
+          sleeper: @sleeper, requester: @requester)
+        if options[:dry_run]
+          targets, skipped = exerciser.plan(plan)
+          @stdout.puts("Would send #{targets.sum(&:count)} requests:", *targets.map { |t| "  #{exerciser.url_for(t.path)} ×#{t.count}" })
+          @stdout.puts("Skipped:", *skipped.map { |s| "  #{s["key"]} (#{s["reason"]})" }) if skipped.any?
+          return 0
+        end
+
+        result = exerciser.run(plan)
+        @stdout.puts("Sent #{result.sent} requests to #{options[:url]}:",
+          *result.routes.map { |r| "  #{r["key"]} ×#{r["requests"]}: #{r["statuses"].map { |kind, n| "#{n} #{kind}" }.join(", ")}" })
+        @stdout.puts("Skipped:", *result.skipped.map { |s| "  #{s["key"]} (#{s["reason"]})" }) if result.skipped.any?
+        @stdout.puts("Stopped early: #{options[:url]} isn't answering.") if result.unreachable
+        if result.routes.any?
+          client.record_exercise(document.dig("deployment", "id"), routes: result.routes, skipped: result.skipped, ran_at: @clock.call.utc.iso8601)
+          @stdout.puts("Recorded on the release. Wait for the verdict with: deployangel verify --wait")
+        end
+        result.unreachable ? USAGE_ERROR : 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]
@@ -230,7 +327,8 @@ module DeployAngel
         case (target = @argv.shift)
         when "kamal" then install_kamal
         when "docker" then install_docker
-        else usage_error("install needs a target: deployangel install kamal, or deployangel install docker")
+        when "agents" then install_agents
+        else usage_error("install needs a target: deployangel install kamal, docker, or agents")
         end
       end
 
@@ -256,6 +354,93 @@ module DeployAngel
         0
       end
 
+      # Sets up Claude Code, Cursor, and Codex in this project: the MCP server
+      # in each one's project config, and instructions to wait for a verdict
+      # after deploying. Never overwrites what's there: an existing entry is
+      # kept, and a file it can't read is left for you to edit.
+      def install_agents
+        command = %w[bundle exec deployangel mcp]
+        lines = [
+          install_json_mcp(".mcp.json", command, "Claude Code"),
+          install_json_mcp(File.join(".cursor", "mcp.json"), command, "Cursor"),
+          install_codex_mcp(command),
+          *install_agent_instructions
+        ]
+        @stdout.puts(*lines, "", AGENTS_TOKEN_HELP)
+        0
+      end
+
+      def install_json_mcp(relative, command, agent)
+        path = File.join(@root, relative)
+        config = File.exist?(path) ? JSON.parse(File.read(path)) : {}
+        raise JSON::ParserError, "not a JSON object" unless config.is_a?(Hash)
+
+        servers = (config["mcpServers"] ||= {})
+        return "#{relative} already has a deployangel MCP server (#{agent})." if servers.key?("deployangel")
+
+        created = !File.exist?(path)
+        servers["deployangel"] = { "command" => command.first, "args" => command.drop(1) }
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, "#{JSON.pretty_generate(config)}\n")
+        "#{created ? "Created" : "Updated"} #{relative}: the DeployAngel MCP server for #{agent}."
+      rescue JSON::ParserError
+        "Couldn't read #{relative}, so it's unchanged. Add a \"deployangel\" server to its mcpServers: " \
+          "command \"#{command.first}\", args #{command.drop(1).to_json}."
+      end
+
+      def install_codex_mcp(command)
+        relative = File.join(".codex", "config.toml")
+        path = File.join(@root, relative)
+        existing = File.exist?(path) ? File.read(path) : nil
+        return "#{relative} already has a deployangel MCP server (Codex)." if existing&.include?("[mcp_servers.deployangel]")
+
+        table = <<~TOML
+          [mcp_servers.deployangel]
+          command = #{command.first.to_json}
+          args = #{command.drop(1).to_json.gsub(",", ", ")}
+          env_vars = ["DEPLOYANGEL_API_TOKEN", "DEPLOYANGEL_URL"]
+        TOML
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, existing ? "#{existing.sub(/\n*\z/, "\n")}\n#{table}" : table)
+        "#{existing ? "Updated" : "Created"} #{relative}: the DeployAngel MCP server for Codex."
+      end
+
+      # AGENTS.md serves Codex and Cursor. Claude Code reads CLAUDE.md, so it
+      # gets the block too, unless it already imports AGENTS.md; a project
+      # without one gets a CLAUDE.md that does.
+      def install_agent_instructions
+        lines = [ upsert_instructions("AGENTS.md") ]
+        claude = File.join(@root, "CLAUDE.md")
+        if !File.exist?(claude)
+          File.write(claude, "@AGENTS.md\n")
+          lines << "Created CLAUDE.md, which imports AGENTS.md for Claude Code."
+        elsif !File.read(claude).match?(/^@AGENTS\.md\s*$/)
+          lines << upsert_instructions("CLAUDE.md")
+        end
+        lines
+      end
+
+      def upsert_instructions(relative)
+        path = File.join(@root, relative)
+        unless File.exist?(path)
+          File.write(path, AGENT_INSTRUCTIONS)
+          return "Created #{relative} with instructions to wait for DeployAngel's verdict after deploying."
+        end
+
+        content = File.read(path)
+        block = /#{Regexp.escape(AGENTS_START)}.*?#{Regexp.escape(AGENTS_END)}\n?/m
+        if content.match?(block)
+          updated = content.sub(block, AGENT_INSTRUCTIONS)
+          return "#{relative} already has DeployAngel's instructions." if updated == content
+
+          File.write(path, updated)
+          "Updated DeployAngel's instructions in #{relative}."
+        else
+          File.write(path, "#{content.sub(/\n*\z/, "\n")}\n#{AGENT_INSTRUCTIONS}")
+          "Added instructions to wait for DeployAngel's verdict after deploying to #{relative}."
+        end
+      end
+
       # Adds DEPLOYANGEL_REVISION, from a GIT_SHA build arg, to the Dockerfile.
       # It never edits CI workflows; it says what to pass instead.
       def install_docker

data/lib/deployangel/client.rb

@@ -49,6 +49,12 @@ module DeployAngel
         { name: name, status: status, covers: covers, details_url: details_url }.compact)
     end
 
+    # What `deployangel exercise` sent (spec §16, Exercise records). A
+    # "CLI & coding agents" token may record one: it only labels the release.
+    def record_exercise(deployment_id, routes:, skipped:, ran_at:)
+      post("/api/v1/deployments/#{deployment_id}/exercises", { routes: routes, skipped: skipped, ran_at: ran_at })
+    end
+
     private
       def get(path, params = {})
         uri = URI("#{@endpoint}#{path}")

data/lib/deployangel/exerciser.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module DeployAngel
+  # `deployangel exercise`: sends a release's exercise plan's read-only
+  # requests to production from the customer's side, then records what it
+  # sent, so the release page says which routes were exercised that way.
+  # Only GET routes with no path parameters and not marked as changing data;
+  # the rest are skipped and named, for the agent or a smoke test with a test
+  # account. The requests count like any traffic through the app's agent.
+  class Exerciser
+    MAX_REQUESTS = 200
+    INTERVAL = 0.2 # about 5 requests a second
+    TIMEOUT = 10
+    # Stop when the app isn't answering, rather than send the rest into it.
+    MAX_CONSECUTIVE_ERRORS = 5
+    # Rails' :id and *path, Django's <int:pk>, FastAPI's {id}.
+    PARAMETER = /\/[:*{<]/
+
+    Target = Struct.new(:key, :path, :count)
+    Result = Struct.new(:routes, :skipped, :sent, :unreachable, keyword_init: true)
+
+    def initialize(base_url:, max_requests: MAX_REQUESTS, sleeper: ->(seconds) { sleep(seconds) }, requester: nil)
+      @base = URI(base_url)
+      @max_requests = max_requests
+      @sleeper = sleeper
+      @requester = requester || method(:get)
+    end
+
+    # What would be sent: [targets, skipped].
+    def plan(exercise_plan)
+      skipped = []
+      targets = []
+      Array(exercise_plan["items"]).each do |item|
+        next unless item["kind"] == "route"
+
+        method, path = item["key"].to_s.split(" ", 2)
+        reason =
+          if item["mutating"] || method != "GET" then "changes data"
+          elsif path.nil? || path.match?(PARAMETER) then "needs a path parameter"
+          end
+        next skipped << { "key" => item["key"], "reason" => reason } if reason
+
+        needed = item["runs_needed"] ? item["runs_needed"].to_i - item["runs"].to_i : 1
+        targets << Target.new(item["key"], path, [ needed, 1 ].max)
+      end
+      spread_shortfall(targets, exercise_plan.dig("shortfall", "requests"))
+      cap(targets)
+      [ targets, skipped ]
+    end
+
+    def run(exercise_plan)
+      targets, skipped = plan(exercise_plan)
+      routes = []
+      errors_in_a_row = 0
+      sent = 0
+      targets.each do |target|
+        statuses = Hash.new(0)
+        target.count.times do
+          break if errors_in_a_row >= MAX_CONSECUTIVE_ERRORS
+
+          @sleeper.call(INTERVAL) if sent.positive?
+          status = @requester.call(url_for(target.path))
+          sent += 1
+          kind = status ? "#{status / 100}xx" : "error"
+          statuses[kind] += 1
+          errors_in_a_row = kind == "error" ? errors_in_a_row + 1 : 0
+        end
+        requests = statuses.values.sum
+        routes << { "key" => target.key, "requests" => requests, "statuses" => statuses.to_h } if requests.positive?
+      end
+      Result.new(routes: routes, skipped: skipped, sent: sent, unreachable: errors_in_a_row >= MAX_CONSECUTIVE_ERRORS)
+    end
+
+    def url_for(path)
+      uri = @base.dup
+      uri.path = "#{@base.path.chomp("/")}#{path}"
+      uri.query = nil
+      uri.to_s
+    end
+
+    private
+      # Requests the release is short of overall, spread across the routes,
+      # or sent to the home page when the plan names no route to send them to.
+      def spread_shortfall(targets, requests)
+        return unless requests
+
+        extra = requests["need"].to_i - requests["have"].to_i - targets.sum(&:count)
+        return unless extra.positive?
+
+        targets << Target.new("GET /", "/", 0) if targets.empty?
+        extra.times { |i| targets[i % targets.size].count += 1 }
+      end
+
+      def cap(targets)
+        targets.max_by(&:count).count -= 1 while targets.sum(&:count) > @max_requests
+      end
+
+      # The status code, or nil when there was no answer. Redirects aren't
+      # followed: the request already reached the app.
+      def get(url)
+        uri = URI(url)
+        request = Net::HTTP::Get.new(uri)
+        request["User-Agent"] = "DeployAngel-Exercise/#{DeployAngel::VERSION} (+https://www.deployangel.com/docs#exercise)"
+        request["Accept"] = "text/html,application/json;q=0.9,*/*;q=0.8"
+        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https", open_timeout: TIMEOUT, read_timeout: TIMEOUT) do |http|
+          http.request(request).code.to_i
+        end
+      rescue StandardError
+        nil
+      end
+  end
+end

data/lib/deployangel/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deployangel
 version: !ruby/object:Gem::Version
-  version: 0.1.18
+  version: 0.1.20
 platform: ruby
 authors:
 - Jordan Owens
@@ -46,6 +46,7 @@ files:
 - lib/deployangel/core/redaction.rb
 - lib/deployangel/core/release.rb
 - lib/deployangel/core/transport.rb
+- lib/deployangel/exerciser.rb
 - lib/deployangel/fork_hook.rb
 - lib/deployangel/mcp.rb
 - lib/deployangel/metadata.rb
@@ -82,7 +83,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.0
+rubygems_version: 4.0.10
 specification_version: 4
 summary: 'DeployAngel agent for Rails: production verification for every deployment.'
 test_files: []