deployangel 0.1.21 → 0.1.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a115a5a35d86c5edce65dad1cdf3947833416ea66f47c69da18b85de3047153
-  data.tar.gz: ec954e62605c6452d3e374896085343cb6a12910e0b821794342a2e0a6dc0426
+  metadata.gz: edccb6c72eff7d259c14c59deaa403fb78c890cb091b40d59b080623945e1e9f
+  data.tar.gz: 364fd681c6199d591292fc67799cb6f7933da99736113ef382ff4ccf628697f8
 SHA512:
-  metadata.gz: 4c18ca61ecff8936bdfa7f4a5900fd27b96c2a787094e504593fae78f62eaee3c7d4ea11e74811b619313c1a726bce8e4644f5a6319c687450ff81629acdd2a5
-  data.tar.gz: 2754b3cc315c626df0dc57de4723721caa668f69b7b523a0ca4eaecaf4f84e2f2ec7f9f40f366be34f9a1989ff3c9b4650f1d02dc81b976218d2b3daf5e3968c
+  metadata.gz: 0ec79d7a8b20600e3fc57604b990749ff578a6b39bdd2caf945c8f60bf5f39ed74f3991659f8d3e26c851e8a7509cc4dabca339f36f35aaa79aca33648ba4c9d
+  data.tar.gz: 37db580510184b407f7941e6c27ad00eb956fab8df6fb59a68406753c14813bca7007de9da53ca7cf9a858f456d40f2a5da2fdd872c44bdd33997b052132ba2c

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # 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,

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

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/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.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.21
+  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: []