deployangel 0.1.7 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5250331c4f5a2c2715d94bbbfc62f61daae1f58a744e1430a231a23077a7c540
-  data.tar.gz: 8db08acb92e1b8923038e2f726481197eb082e308d1f59a6e18911a04d6c3301
+  metadata.gz: e2bc6936b563039a1c2caa91f3a8125f0c32582366505ab35dfabf2ec90af3c5
+  data.tar.gz: 22c805b0adef58922b3513afc19492433421358be2e75fd12513e650a7e57c9c
 SHA512:
-  metadata.gz: '0548b47a265acf82aa9cb67e566142ec4e4e648af0e828217066f8104bc24bf305fd397a1bdb2741de7bf919e10e0d8e4d76fcdd2d9e865e0aaf46ebca226acd'
-  data.tar.gz: e622c67f73c8475ff52dd8628e296de2950dce36b7a83e447d23e3a523fdf950a13801ee654972e2c60d176f8c6ddfd7230bec31159cc604b77782bb4a4757a6
+  metadata.gz: 361b042f1d885fc63442dff6d4f4c406b36fd14ea5c226cf04a5bea2f7537770c6b4f4ad169331b95e6f3bdacf37169f90ac70fc6567006203f4884fe021236a
+  data.tar.gz: 328b709591c7c5441390fb74dc535d0a515061fd64161bbe555ffe9f4f8602bf32f10676b6119458e44837ee539e96e5e2f4d72b97cafc05e203d3ef2eb77e7b

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.1.9 (2026-10-04)
+
+- A 4xx response to a request no route matched, such as a bot probing
+  `/wp-admin` or `.env`, or middleware turning a request away before
+  routing, is still recorded under `GET unmatched` but no longer counts in
+  the app's request count, status counts, or latency. It made apps look
+  busier than their real pages, and fast 404s diluted their latency. An
+  unrouted 5xx still counts.
+
+## 0.1.8 (2026-10-04)
+
+- Health checks served by a lambda or a mounted Rack app at a conventional
+  path (`/up`, `/health`, `/healthz`, `/healthcheck`, `/health_check`,
+  `/livez`, `/readyz`, `/statusz`, `/ping`) are left out, like the health-check
+  gems'. A controller at one of these paths is still recorded, since it may be
+  a real page.
+- `config.sidekiq_cron_schedule_file` reads sidekiq-cron jobs from the file an
+  app loads them from itself, such as `config/sidekiq_schedule.yml.erb` passed
+  to `Sidekiq::Cron::Job.load_from_hash!`. ERB is rendered, as in the default
+  file.
+
 ## 0.1.7 (2026-10-04)
 
 - Health checks from OkComputer, health_check, and rails-healthcheck are left

data/README.md

@@ -45,8 +45,10 @@ ENV DEPLOYANGEL_REVISION=$GIT_SHA
 
 and build with `docker build --build-arg GIT_SHA=$(git rev-parse HEAD) .`. On
 DigitalOcean App Platform, set `DEPLOYANGEL_REVISION: ${_self.COMMIT_HASH}` in
-the app spec. If the agent finds none of these, its telemetry can't be tied to a
-deploy, and the dashboard says so.
+the app spec. On Elastic Beanstalk, see
+[Deploying to Elastic Beanstalk](#deploying-to-elastic-beanstalk). If the agent
+finds none of these, its telemetry can't be tied to a deploy, and the dashboard
+says so.
 
 ## What it sends
 
@@ -73,6 +75,17 @@ deploy, and the dashboard says so.
 It does not send request bodies, parameters, headers, cookies, SQL, logs, or
 user data.
 
+## Data and pricing
+
+- Everything goes to DeployAngel's hosted service, which runs on DigitalOcean
+  in the United States. There's no self-hosted version, and no choice of
+  region.
+- Telemetry is kept for 21 days, and release history for 7, 30, or 90 days
+  depending on the plan. The [privacy policy](https://deployangel.com/privacy)
+  has the details and the services DeployAngel uses.
+- DeployAngel is free during the beta, with notice before paid plans start.
+  See [pricing](https://deployangel.com/pricing).
+
 ## Safety
 
 - Nothing runs on the network during a request. Requests only update
@@ -115,8 +128,11 @@ Health checks aren't recorded: load balancers and uptime monitors call them
 all the time and they always answer fast, so they would make your app look
 busier and healthier than its real pages. The agent recognizes Rails' own
 (`/up`), OkComputer, health_check, and rails-healthcheck, wherever they're
-mounted. If your health check is your own controller, list its route the way
-the dashboard shows it. HEAD requests to it are left out too:
+mounted, and a lambda or Rack app at a conventional path (`/up`, `/health`,
+`/healthz`, `/healthcheck`, `/health_check`, `/livez`, `/readyz`, `/statusz`,
+`/ping`), such as `get "healthz", to: ->(_) { [200, {}, ["ok"]] }`. If your
+health check is your own controller, list its route the way the dashboard
+shows it. HEAD requests to it are left out too:
 
 ```ruby
 DeployAngel.configure do |config|
@@ -124,6 +140,22 @@ DeployAngel.configure do |config|
 end
 ```
 
+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
+configured otherwise), rendering ERB in each. If your app loads sidekiq-cron
+jobs itself from another file, for example with `Sidekiq::Cron::Job.load_from_hash!`,
+point the agent at that file:
+
+```ruby
+DeployAngel.configure do |config|
+  config.sidekiq_cron_schedule_file = "config/sidekiq_schedule.yml.erb"
+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`).
 
@@ -182,6 +214,28 @@ to the run. Explicit options still win.
     DEPLOYANGEL_API_TOKEN: ${{ secrets.DEPLOYANGEL_API_TOKEN }}
 ```
 
+### When a release never reports
+
+A registered release must start reporting within 15 minutes of being
+registered. If no instance reports it by then, the verdict is
+**inconclusive** with reason `no_release_telemetry`, and the dashboard says
+"Not cleared: this release never reported". The usual causes are a release
+that never booted (a failed migration or a crash on start), an agent with no
+token, or a release identity the agent can't find. If the app kept reporting
+an earlier release instead, the verdict names it ("while v41 kept running").
+`deployangel verify --wait` exits 2, so the CI step above fails the job.
+
+If the release does start reporting within 24 hours, as after a slow rolling
+deploy, DeployAngel withdraws that verdict and verifies the release from then,
+unless a newer release has rolled out first. A CI job that already failed stays
+failed; run `deployangel verify --wait` again to wait for the new verdict.
+
+Only registered releases are caught this way. DeployAngel learns about an
+unregistered release when the agent first reports it, so a release that never
+boots is never seen. If a release that dies on boot is a risk for you, register
+deploys from CI. The 15 minutes count from registration, so register when the
+deploy finishes, not when it starts.
+
 ### Deploying with Kamal
 
 The agent reads `KAMAL_VERSION`, so it knows its release with no setup. Pass
@@ -234,6 +288,35 @@ set :deployangel_register, false      # turn it off, e.g. for a stage without De
 With `:deployangel_wait`, `cap` exits with an error if the release fails
 verification, which CI can act on. It never rolls anything back.
 
+### Deploying to Elastic Beanstalk
+
+Elastic Beanstalk doesn't tell the app which commit it's running. Set
+`DEPLOYANGEL_REVISION` in the same `update-environment` call that deploys the
+new version, so the two always change together. This works on every platform,
+Docker included, with no build args. Then wait for the environment and register
+the release:
+
+```bash
+aws elasticbeanstalk update-environment \
+  --environment-name "$EB_ENV" \
+  --version-label "$VERSION_LABEL" \
+  --option-settings "Namespace=aws:elasticbeanstalk:application:environment,OptionName=DEPLOYANGEL_REVISION,Value=$GITHUB_SHA"
+aws elasticbeanstalk wait environment-updated --environment-names "$EB_ENV"
+
+bundle exec deployangel release --commit="$GITHUB_SHA" --version="$VERSION_LABEL"
+bundle exec deployangel verify --wait --until=initial
+```
+
+`update-environment` returns as soon as the deploy starts, so don't skip the
+wait: registering early starts the
+[15-minute clock](#when-a-release-never-reports) before the new version is
+running. If the deploy fails and Beanstalk rolls back, the environment still
+returns to Ready, but the new commit never reports, so `verify` exits 2.
+
+Leave `DEPLOYANGEL_RELEASE_VERSION` unset here. When the agent reports a
+version, the release is matched by it, so it would have to equal `--version`
+exactly. Matching by commit avoids that.
+
 ## CLI and coding agents
 
 The gem ships a `deployangel` command. It doesn't boot Rails. Give it a token

data/lib/deployangel/agent.rb

@@ -42,12 +42,12 @@ module DeployAngel
       @active
     end
 
-    def record_request(route_key:, status:, duration_ms:, unhandled: false)
+    def record_request(route_key:, status:, duration_ms:, unhandled: false, in_totals: true)
       return unless @active
 
       after_fork! if Process.pid != @pid
       start_reporter
-      @aggregator.record(route_key: route_key, status: status, duration_ms: duration_ms, unhandled: unhandled)
+      @aggregator.record(route_key: route_key, status: status, duration_ms: duration_ms, unhandled: unhandled, in_totals: in_totals)
     rescue StandardError => e
       warn_once(:record, "DeployAngel failed to record a request: #{e.class}: #{e.message}")
     end

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
+      :file_digests, :critical_flows, :ignored_routes, :sidekiq_cron_schedule_file
 
     def initialize(env = ENV)
       @token = env["DEPLOYANGEL_TOKEN"]
@@ -30,6 +30,9 @@ module DeployAngel
       @critical_flows = {}
       # Route keys as the dashboard shows them, such as "GET /healthz".
       @ignored_routes = []
+      # For an app that loads sidekiq-cron's jobs itself (load_from_hash!)
+      # from its own file, such as "config/sidekiq_schedule.yml.erb".
+      @sidekiq_cron_schedule_file = nil
     end
 
     # Reports only with a token. By default only in the listed

data/lib/deployangel/core/aggregator.rb

@@ -89,11 +89,13 @@ module DeployAngel
         (@job_classes[key] ||= JobStats.empty).record_discard
       end
 
-      def record(route_key, status, duration_ms, unhandled, max_routes)
-        @requests += 1
-        @status_counts[status.to_s] += 1 if status >= 400
-        @unhandled_exceptions += 1 if unhandled
-        @histogram.record(duration_ms)
+      def record(route_key, status, duration_ms, unhandled, max_routes, in_totals)
+        if in_totals
+          @requests += 1
+          @status_counts[status.to_s] += 1 if status >= 400
+          @unhandled_exceptions += 1 if unhandled
+          @histogram.record(duration_ms)
+        end
 
         key = @routes.key?(route_key) || @routes.size < max_routes - 1 ? route_key : OTHER_ROUTE
         route = (@routes[key] ||= RouteStats.empty)
@@ -112,11 +114,13 @@ module DeployAngel
       @mutex = Mutex.new
     end
 
-    def record(route_key:, status:, duration_ms:, unhandled: false)
+    # in_totals: false records the request under its route only, leaving it
+    # out of the app-wide counts and latency.
+    def record(route_key:, status:, duration_ms:, unhandled: false, in_totals: true)
       started_at = period_start(@clock.call)
       @mutex.synchronize do
         (@periods[started_at] ||= Period.new(started_at))
-          .record(route_key, status.to_i, duration_ms, unhandled, @max_routes)
+          .record(route_key, status.to_i, duration_ms, unhandled, @max_routes, in_totals)
       end
     end
 

data/lib/deployangel/rails/http.rb

@@ -13,6 +13,9 @@ module DeployAngel
       # counting them would make any app look busy and healthy. Others can
       # be left out with config.ignored_routes.
       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
@@ -37,12 +40,12 @@ module DeployAngel
 
       private
         def record(env, status, started, unhandled:, exception: nil)
-          return if HEALTH_CHECK_CONTROLLERS.include?(env["action_dispatch.request.path_parameters"]&.dig(:controller))
+          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) still count.
+          # errors (such as routing 404s) are still recorded.
           return if route.nil? && status.to_i < 400
 
           key = route || "#{env["REQUEST_METHOD"]} unmatched"
@@ -51,12 +54,28 @@ module DeployAngel
             route_key: key,
             status: status.to_i,
             duration_ms: (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000.0,
-            unhandled: unhandled
+            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
 
+        # A controller at a health-check path may be a real page, so only
+        # controllerless routes are judged by their path.
+        def health_check?(env)
+          controller = env["action_dispatch.request.path_parameters"]&.dig(:controller)
+          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)
+        end
+
         def route_key(env)
           method = env["REQUEST_METHOD"]
           if (pattern = route_pattern(env))

data/lib/deployangel/rails/metadata.rb

@@ -86,8 +86,10 @@ module DeployAngel
       end
 
       # sidekiq-cron jobs from its schedule file (config/schedule.yml unless
-      # configured otherwise), which it loads when Sidekiq starts. Jobs
-      # created in code live only in Redis, which the agent doesn't read.
+      # 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)
 
@@ -105,7 +107,8 @@ module DeployAngel
       end
 
       def sidekiq_cron_schedule_file
-        configured = ::Sidekiq::Cron.configuration.cron_schedule_file if ::Sidekiq::Cron.respond_to?(:configuration)
+        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")

data/lib/deployangel/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deployangel
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.9
 platform: ruby
 authors:
 - Jordan Owens