deployangel 0.1.20 → 0.1.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59eed3c6629b0dc5b81cbec2636583d50f0038c2f51af8011108205a1a23eb8c
-  data.tar.gz: d10e3a967bed17b69b854a5b74deba72b66ad4e204b3c007bd1958fc81e1ca66
+  metadata.gz: edccb6c72eff7d259c14c59deaa403fb78c890cb091b40d59b080623945e1e9f
+  data.tar.gz: 364fd681c6199d591292fc67799cb6f7933da99736113ef382ff4ccf628697f8
 SHA512:
-  metadata.gz: cecef6e5f9328a9b72877c16bbd51388d67a5673b98a75a56c78e6916f5bf99fd033baaf9056f101b25cd36553d0e6033a253800f571ecfab3724655f1301901
-  data.tar.gz: cb8460812b9f04eaf761e23282a644c62f4de9aaca20fcf42e1bc81478f898e096675fd1bdfc67e70aef60ac3053bce969de7310539b9261b036c262dae70bd1
+  metadata.gz: 0ec79d7a8b20600e3fc57604b990749ff578a6b39bdd2caf945c8f60bf5f39ed74f3991659f8d3e26c851e8a7509cc4dabca339f36f35aaa79aca33648ba4c9d
+  data.tar.gz: 37db580510184b407f7941e6c27ad00eb956fab8df6fb59a68406753c14813bca7007de9da53ca7cf9a858f456d40f2a5da2fdd872c44bdd33997b052132ba2c

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.1.22 (2026-10-09)
+
+- Work scheduled outside the app's own scheduler is watched too.
+  `config.recurring_jobs` declares it by the name it runs under (a job
+  class, `"rake <task>"`, or a `DeployAngel.task` name) with a cron line
+  or Fugit's words, for cron, Heroku Scheduler, or a Kubernetes CronJob.
+- `DeployAngel.task("name") { ... }` records plain code that a scheduler
+  starts as a run of that name, with its duration and whether it raised.
+- Rake tasks a schedule names are recorded with no code change, when the
+  task loads the app (`:environment`).
+- The whenever gem's `config/schedule.rb` is read with whenever's own
+  parser, when whenever is in the bundle: rake tasks and runners that
+  perform a job class are expected on schedule, in the server's zone.
+
+## 0.1.21 (2026-10-09)
+
+- `deployangel exercise` stops requesting a page after its first 404, 405,
+  or 410, since a route table can list pages an app doesn't serve, and sends
+  that page's share to the pages that answered.
+
 ## 0.1.20 (2026-10-09)
 
 - `deployangel exercise --url=<production URL>` sends a release's exercise

data/README.md

@@ -210,6 +210,43 @@ end
 Jobs that exist only in Redis, such as ones created in code or in the
 Sidekiq web UI, aren't read.
 
+#### Cron, Heroku Scheduler, and whenever
+
+Work that something outside the app starts on a schedule, such as cron,
+Heroku Scheduler, or a Kubernetes CronJob, is invisible to those files.
+Declare it by the name it runs under, with a cron line or words like
+`"every day at 4am"`, in the server's time zone unless you add one
+(`"0 3 * * * America/New_York"`):
+
+```ruby
+DeployAngel.configure do |config|
+  config.recurring_jobs = {
+    "NightlyInvoiceJob" => "0 3 * * *",            # bin/rails runner "NightlyInvoiceJob.perform_now"
+    "rake invoices:send" => "every day at 4am",    # bin/rails invoices:send
+    "nightly import" => "30 2 * * *"               # DeployAngel.task("nightly import") { ... }
+  }
+end
+```
+
+- **A job class** is recorded wherever it runs, a one-off `rails runner`
+  included.
+- **A rake task** named `"rake <task>"` is recorded with no code change, as
+  long as it loads the app (depends on `:environment`).
+- **Any other code** is recorded when you wrap it, which returns the block's
+  value and re-raises what it raises:
+
+  ```ruby
+  DeployAngel.task("nightly import") { Importer.run }
+  ```
+
+The [whenever](https://github.com/javan/whenever) gem's `config/schedule.rb`
+is read automatically when whenever is in the app's bundle (it's usually in
+the Gemfile already, for deploys): its `rake` jobs, and `runner` jobs that
+perform a job class (`"NightlyInvoiceJob.perform_later"`), are expected on
+the schedule whenever writes to the crontab. Other `runner` code and
+`command` jobs can't be matched to a run; wrap them in `DeployAngel.task`
+and declare them as above.
+
 ## Checkpoints
 
 Errors and latency don't catch work that silently stops happening. Count the
@@ -471,8 +508,9 @@ 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.
+parameter, and stops requesting a page after its first 404, sending its
+share to the pages that answered. A "CLI & coding agents" token can run
+it. `--dry-run` shows what it would send.
 
 ### Suggested instructions for your coding agent
 

data/lib/deployangel/configuration.rb

@@ -11,7 +11,8 @@ 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, :exception_messages
+      :file_digests, :critical_flows, :ignored_routes, :sidekiq_cron_schedule_file, :exception_messages,
+      :recurring_jobs
 
     def initialize(env = ENV)
       @token = env["DEPLOYANGEL_TOKEN"]
@@ -36,6 +37,12 @@ module DeployAngel
       # 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
+      # Work scheduled outside the app's own scheduler (cron, Heroku
+      # Scheduler, a Kubernetes CronJob), by the name it runs under: a job
+      # class, "rake <task>", or a DeployAngel.task name. Each schedule is a
+      # cron line or Fugit's words ("every day at 4am"), optionally ending
+      # in a time zone.
+      @recurring_jobs = {}
     end
 
     # Reports only with a token, and by default in every environment but

data/lib/deployangel/exerciser.rb

@@ -16,6 +16,9 @@ module DeployAngel
     TIMEOUT = 10
     # Stop when the app isn't answering, rather than send the rest into it.
     MAX_CONSECUTIVE_ERRORS = 5
+    # A route table can list pages an app doesn't serve, like the edit page
+    # of a resource that has none. One answer like this is enough to know.
+    NOT_SERVED = [ 404, 405, 410 ].freeze
     # Rails' :id and *path, Django's <int:pk>, FastAPI's {id}.
     PARAMETER = /\/[:*{<]/
 
@@ -51,27 +54,34 @@ module DeployAngel
       [ targets, skipped ]
     end
 
+    # A route whose first request says it isn't served gets no more; its
+    # share goes to the routes that answered.
     def run(exercise_plan)
       targets, skipped = plan(exercise_plan)
-      routes = []
-      errors_in_a_row = 0
-      sent = 0
+      @statuses = Hash.new { |hash, key| hash[key] = Hash.new(0) }
+      @sent = 0
+      @errors_in_a_row = 0
+      leftover = 0
+      answered = []
       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
+        target.count.times do |i|
+          break if unreachable?
+
+          status = send_request(target)
+          if i.zero? && NOT_SERVED.include?(status)
+            leftover += target.count - 1
+            break
+          end
         end
-        requests = statuses.values.sum
-        routes << { "key" => target.key, "requests" => requests, "statuses" => statuses.to_h } if requests.positive?
+        answered << target if @statuses[target.key].keys.intersect?(%w[2xx 3xx])
+      end
+      leftover.times { |i| send_request(answered[i % answered.size]) unless unreachable? } if answered.any?
+
+      routes = targets.filter_map do |target|
+        statuses = @statuses.fetch(target.key, nil) or next
+        { "key" => target.key, "requests" => statuses.values.sum, "statuses" => statuses.to_h }
       end
-      Result.new(routes: routes, skipped: skipped, sent: sent, unreachable: errors_in_a_row >= MAX_CONSECUTIVE_ERRORS)
+      Result.new(routes: routes, skipped: skipped, sent: @sent, unreachable: unreachable?)
     end
 
     def url_for(path)
@@ -82,6 +92,20 @@ module DeployAngel
     end
 
     private
+      def send_request(target)
+        @sleeper.call(INTERVAL) if @sent.positive?
+        status = @requester.call(url_for(target.path))
+        @sent += 1
+        kind = status ? "#{status / 100}xx" : "error"
+        @statuses[target.key][kind] += 1
+        @errors_in_a_row = kind == "error" ? @errors_in_a_row + 1 : 0
+        status
+      end
+
+      def unreachable?
+        @errors_in_a_row >= MAX_CONSECUTIVE_ERRORS
+      end
+
       # 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)

data/lib/deployangel/metadata.rb

@@ -63,7 +63,73 @@ module DeployAngel
     # 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
+      sidekiq_cron_schedules + sidekiq_scheduler_schedules + whenever_schedules + configured_schedules
+    end
+
+    # config.recurring_jobs: work scheduled outside the app, by the name it
+    # runs under. A schedule without a zone is read in the server's.
+    def configured_schedules
+      Array(@config.recurring_jobs).filter_map do |name, schedule|
+        next if name.to_s.strip.empty? || schedule.to_s.strip.empty?
+
+        { "key" => name.to_s, "class" => name.to_s, "schedule" => schedule.to_s, "source" => "config", "time_zone" => local_time_zone }
+      end
+    rescue StandardError
+      []
+    end
+
+    WHENEVER_FILE = "config/schedule.rb"
+    WHENEVER_JOB = /\A\s*(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)(?:\.set\(.*?\))?\.(?:perform_now|perform_later|perform_async|perform_inline)\b/m
+
+    # The whenever gem's config/schedule.rb, which it turns into the server's
+    # crontab on deploy. Read with whenever's own parser, so times come out
+    # as cron reads them, in the server's zone. Rake tasks are recorded by
+    # name (Tasks.install_rake); a runner that performs a job class is
+    # matched by that class. Other commands can't be told apart, so they're
+    # left to config.recurring_jobs and DeployAngel.task.
+    def whenever_schedules
+      path = File.join(@root, WHENEVER_FILE)
+      return [] unless File.file?(path) && whenever_loaded?
+
+      list = ::Whenever::JobList.new(file: path)
+      chronic = list.instance_variable_get(:@chronic_options) || {}
+      by_time = (list.instance_variable_get(:@jobs) || {}).values.flat_map(&:to_a)
+      by_time.flat_map do |time, jobs|
+        Array(jobs).flat_map { |job| whenever_entries(time, job, chronic) }
+      end.uniq { |schedule| schedule["key"] }
+    rescue StandardError, ScriptError
+      []
+    end
+
+    def whenever_loaded?
+      require "whenever"
+      true
+    rescue LoadError
+      false
+    end
+
+    def whenever_entries(time, job, chronic)
+      name = whenever_job_name(job) or return []
+      crons = ::Whenever::Output::Cron.enumerate(time).flat_map do |each|
+        ::Whenever::Output::Cron.enumerate(job.at, false).map do |at|
+          ::Whenever::Output::Cron.new(each, nil, at, chronic_options: chronic).time_in_cron_syntax.to_s
+        end
+      end.uniq.reject { |cron| cron.empty? || cron == "@reboot" }
+      crons.map do |cron|
+        { "key" => crons.one? ? name : "#{name} (#{cron})", "class" => name, "schedule" => cron, "source" => "whenever",
+          "time_zone" => local_time_zone }
+      end
+    end
+
+    def whenever_job_name(job)
+      template = job.instance_variable_get(:@template).to_s
+      task = job.instance_variable_get(:@options)&.dig(:task).to_s.strip
+      if template.match?(/\brake :task\b/)
+        rake = task.split.first.to_s
+        "#{Tasks::RAKE_PREFIX}#{rake}" unless rake.empty?
+      elsif template.include?(":runner_command")
+        task[WHENEVER_JOB, 1]
+      end
     end
 
     # sidekiq-cron jobs from its schedule file (config/schedule.yml unless

data/lib/deployangel/rails/railtie.rb

@@ -24,14 +24,24 @@ module DeployAngel
         DeployAngel::Apartment.install if DeployAngel.configuration.exception_messages
         # The metadata goes in at start, before the reporter thread can run:
         # the code fingerprint is built from its file digests.
+        metadata = DeployAngel::Rails::Metadata.new(app: app, config: DeployAngel.configuration, root: ::Rails.root.to_s, environment: ::Rails.env)
         DeployAngel.start(
           environment: ::Rails.env,
           root: ::Rails.root.to_s,
           framework: "rails",
           framework_version: ::Rails.version,
           logger: ::Rails.logger,
-          metadata: DeployAngel::Rails::Metadata.new(app: app, config: DeployAngel.configuration, root: ::Rails.root.to_s, environment: ::Rails.env)
+          metadata: metadata
         )
+        # A rake task cron starts loads the app (its :environment
+        # prerequisite) before it runs, so the hook is in place in time.
+        DeployAngel::Tasks.install_rake(metadata.schedules) if DeployAngel.recording? && Railtie.rake_process?
+      end
+
+      def self.rake_process?
+        defined?(::Rake.application) && ::Rake.application.top_level_tasks.any?
+      rescue StandardError
+        false
       end
     end
   end

data/lib/deployangel/tasks.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "set"
+
+module DeployAngel
+  # Work that runs on a schedule but isn't a job, such as a rake task that
+  # cron, Heroku Scheduler, or whenever starts. Recorded as a job run under
+  # its name, with its duration and whether it raised, so DeployAngel can
+  # expect it on schedule like any recurring job.
+  module Tasks
+    NAME = /\A[[:graph:]][[:print:]]{0,199}\z/
+    RAKE_PREFIX = "rake "
+
+    module_function
+
+    def run(name)
+      name = name.to_s
+      return yield unless DeployAngel.recording? && valid?(name)
+
+      DeployAngel.add_capability("jobs")
+      previous = ExecutionContext.enter(ExecutionContext::JOB)
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      failed = false
+      begin
+        yield
+      rescue Exception => e # rubocop:disable Lint/RescueException -- recorded, then re-raised untouched
+        failed = true
+        DeployAngel.record_exception(e, source: "job_class:#{name}")
+        raise
+      ensure
+        ExecutionContext.restore(previous)
+        DeployAngel.record_job(job_class: name, duration_ms: (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000.0,
+          failed: failed)
+      end
+    end
+
+    def valid?(name)
+      return true if name.match?(NAME)
+
+      unless @warned
+        DeployAngel.configuration.logger&.warn("DeployAngel didn't record task #{name.inspect}: use a name of up to 200 printable characters")
+        @warned = true
+      end
+      false
+    end
+
+    # Records the rake tasks a schedule names ("rake invoices:send"), so a
+    # task cron starts needs no code change. Only those tasks: others, like
+    # db:migrate at deploy time, aren't recurring work.
+    def install_rake(schedules)
+      return unless defined?(::Rake::Task)
+
+      names = Array(schedules).filter_map { |schedule| schedule["class"].to_s.delete_prefix(RAKE_PREFIX) if schedule["class"].to_s.start_with?(RAKE_PREFIX) }
+      return if names.empty?
+
+      @rake_tasks = names.to_set
+      ::Rake::Task.prepend(RakeTask) unless ::Rake::Task <= RakeTask
+    rescue StandardError
+      nil
+    end
+
+    def scheduled_rake_task?(name)
+      @rake_tasks&.include?(name) || false
+    end
+
+    module RakeTask
+      def execute(args = nil)
+        return super unless DeployAngel::Tasks.scheduled_rake_task?(name)
+
+        DeployAngel::Tasks.run("#{DeployAngel::Tasks::RAKE_PREFIX}#{name}") { super }
+      end
+    end
+  end
+end

data/lib/deployangel/version.rb

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

data/lib/deployangel.rb

@@ -61,6 +61,15 @@ module DeployAngel
       agent&.record_exception(exception, **options)
     end
 
+    # Records a block as a run of scheduled work, for code that cron or a
+    # scheduler outside the app starts and that isn't a job:
+    #   DeployAngel.task("invoices:send") { Invoice.send_due }
+    # It returns the block's value and re-raises what it raises. Declare the
+    # schedule in config.recurring_jobs so a missed run is noticed.
+    def task(name, &)
+      Tasks.run(name, &)
+    end
+
     CHECKPOINT_NAME = /\A[a-z0-9][a-z0-9_.:-]{0,99}\z/i
 
     # Counts a business event, such as DeployAngel.checkpoint("order.fulfilled").
@@ -116,6 +125,7 @@ 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/tasks"
 require_relative "deployangel/metadata"
 require_relative "deployangel/rails/metadata"
 require_relative "deployangel/sidekiq"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deployangel
 version: !ruby/object:Gem::Version
-  version: 0.1.20
+  version: 0.1.22
 platform: ruby
 authors:
 - Jordan Owens
@@ -57,6 +57,7 @@ files:
 - lib/deployangel/rails/metadata.rb
 - lib/deployangel/rails/railtie.rb
 - lib/deployangel/sidekiq.rb
+- lib/deployangel/tasks.rb
 - lib/deployangel/verification_waiter.rb
 - lib/deployangel/version.rb
 homepage: https://www.deployangel.com
@@ -83,7 +84,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.0
 specification_version: 4
 summary: 'DeployAngel agent for Rails: production verification for every deployment.'
 test_files: []