deployangel 0.1.21 → 0.1.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a115a5a35d86c5edce65dad1cdf3947833416ea66f47c69da18b85de3047153
-  data.tar.gz: ec954e62605c6452d3e374896085343cb6a12910e0b821794342a2e0a6dc0426
+  metadata.gz: 2635666118ec2250b5414245e3ea0aa1026d30e4369788e2c82bf6e6b0a52f71
+  data.tar.gz: 0fac6aa9bf419e2ad7a93a289902c94fa94a6d0b42c1418d7370afbaf90501cd
 SHA512:
-  metadata.gz: 4c18ca61ecff8936bdfa7f4a5900fd27b96c2a787094e504593fae78f62eaee3c7d4ea11e74811b619313c1a726bce8e4644f5a6319c687450ff81629acdd2a5
-  data.tar.gz: 2754b3cc315c626df0dc57de4723721caa668f69b7b523a0ca4eaecaf4f84e2f2ec7f9f40f366be34f9a1989ff3c9b4650f1d02dc81b976218d2b3daf5e3968c
+  metadata.gz: 41f77d3e77fae4bccf35c82570582e01501246314c540d6bf6d227cdcd15e033237d62d9b0b2769e80766f53293982b4e8fe07e644ced1e99d93ca13a57b93f2
+  data.tar.gz: 674cb4c4972c88d861375904572c1048f247f041400c52b8d5380f44b3ff76d8b6f473362b404bedcf2377e1b6811cf96eea39f5cb9934b07271ddd627376afa

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.1.23 (2026-10-09)
+
+- GoodJob's cron (`config.good_job.cron`, or `GOOD_JOB_CRON`) is read from
+  the processes that run it, so its jobs are expected on schedule. Entries
+  whose schedule or class is a lambda, or that are off by default, are
+  left out; schedules without a zone are read in the server's.
+
+## 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,

data/README.md

@@ -98,7 +98,8 @@ the dashboard says so.
   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
+  declared for Solid Queue, GoodJob, sidekiq-cron, sidekiq-scheduler, or
+  whenever, critical
   flows, and file digests (relative paths and hashes, never file contents) so
   DeployAngel can tell which routes changed in a release.
   Disable digests with `DEPLOYANGEL_FILE_DIGESTS=false`.
@@ -210,6 +211,50 @@ end
 Jobs that exist only in Redis, such as ones created in code or in the
 Sidekiq web UI, aren't read.
 
+GoodJob's cron (`config.good_job.cron`, or `GOOD_JOB_CRON`) is read from the
+processes that run it, the ones with cron enabled. Schedules without a zone
+are read in the server's, as GoodJob reads them. An entry whose `cron:` or
+`class:` is a lambda, or that's `enabled_by_default: false`, isn't expected.
+The agent doesn't see entries turned off in GoodJob's dashboard, so one you
+switch off there will look missed after the next deploy.
+
+#### 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

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/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/metadata.rb

@@ -3,7 +3,7 @@
 module DeployAngel
   module Rails
     # The Rails adapter: the route table from the router, job classes from
-    # Active Job, and Solid Queue's recurring tasks. The schedule files
+    # Active Job, and Solid Queue's and GoodJob'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
@@ -44,10 +44,10 @@ module DeployAngel
         []
       end
 
-      # Solid Queue's schedule is Rails' own; the rest are read the same way
-      # on every framework.
+      # Solid Queue's and GoodJob's schedules live in the Rails app; the rest
+      # are read the same way on every framework.
       def schedules
-        solid_queue_schedules + super
+        solid_queue_schedules + good_job_schedules + super
       end
 
       # Solid Queue recurring tasks for the current environment.
@@ -69,6 +69,33 @@ module DeployAngel
         []
       end
 
+      # GoodJob's cron, from a process that runs it. GoodJob turns cron on
+      # per process (often only the worker's, with GOOD_JOB_ENABLE_CRON), and
+      # its CLI applies --enable-cron after boot, before metadata is first
+      # sent. A schedule without a zone is read in the server's, as Fugit
+      # reads it. A schedule or class given as a lambda can't be known
+      # without running app code, so it's left out.
+      def good_job_schedules
+        return [] unless defined?(::GoodJob) && ::GoodJob.respond_to?(:configuration)
+
+        configuration = ::GoodJob.configuration
+        return [] unless configuration.enable_cron?
+
+        configuration.cron.filter_map do |key, entry|
+          next unless entry.is_a?(Hash)
+
+          entry = entry.transform_keys(&:to_sym)
+          cron, job_class = entry.values_at(:cron, :class)
+          job_class = job_class.name if job_class.is_a?(Module)
+          next if entry[:enabled_by_default] == false
+          next unless cron.is_a?(String) && !cron.strip.empty? && job_class.is_a?(String) && !job_class.empty?
+
+          { "key" => key.to_s, "class" => job_class, "schedule" => cron, "source" => "good_job", "time_zone" => local_time_zone }
+        end
+      rescue StandardError
+        []
+      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

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.21"
+  VERSION = "0.1.23"
 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.21
+  version: 0.1.23
 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: []