deployangel 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5169af9bd2d83ec8ec1446d4ddf641a8908428bc8d50be14fc124a76cfdca936
-  data.tar.gz: 466bff7d697f32e27362394130e2e1e0fc0f4e7c62a098740b3c38598443b0fe
+  metadata.gz: 7d7f056df70ef5a14b11ff88312b8dd9e48330567b9f653cf57d6ddd9caf8050
+  data.tar.gz: 7d8c30865b517b59e76cea6cc61d5c0d6853ea7766b41378b790f98983a23d37
 SHA512:
-  metadata.gz: 5be25747e622d3556d6f2b6d04351f1d3402f910045ad36e15b1e181b393955acee510906c37abafde57f7cfdde4b41d4742bcf6bcf6e90c549914a033f1205d
-  data.tar.gz: ed4075d93e23c0a96b813bb385384de53cd05ca878e3e77140af6cae1eeb827e52c5fef5bb8fcfd40e162cac62ead212ea74a019c93bae629ad55fc1dbbd0365
+  metadata.gz: 4223fbd9e23df830ab6538e927550cbf79057856112427df383da9a77a9a1a0af2f22b5461a4934e1bd945bef60dc8160644632fba1cacd99be0183a29f40295
+  data.tar.gz: 790766bea10aa1c12f8e6212fb9d0b10a127f4f7a809bee9434c2952f4ad725c491c20fc2767a606142ec4f9d8d748a50197b6a52861e417f7bb87e0df40a6fa

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.1.5 (2026-10-03)
+
+- Declared recurring jobs from sidekiq-cron and sidekiq-scheduler, alongside
+  Solid Queue's. sidekiq-cron jobs come from its schedule file
+  (`config/schedule.yml` unless configured otherwise); sidekiq-scheduler jobs
+  from the `:scheduler: :schedule:` section of Sidekiq's config file (the
+  `-C` file in the Procfile's sidekiq command, else `config/sidekiq.yml`),
+  with that environment's section applied. A repeating `every` or `interval`
+  is sent as `every`. Both carry the process's local time zone, which the
+  schedulers read a schedule in when it names none. Disabled jobs, jobs for
+  other environments, and one-off `at` and `in` jobs are left out. Jobs that
+  exist only in Redis aren't read.
+
+## 0.1.4 (2026-10-03)
+
+- A Solid Queue recurring task that runs a `command:` instead of a job class
+  reports the job class it runs as (`runs_as`, `SolidQueue::RecurringJob`
+  unless the app changes Solid Queue's default). DeployAngel can then expect
+  it on schedule and show it by its name in `config/recurring.yml`, instead
+  of guessing an interval from history and showing Solid Queue's wrapper.
+
 ## 0.1.3 (2026-10-02)
 
 - Each process sends its minute of telemetry 1 to 50 seconds after the

data/README.md

@@ -64,9 +64,10 @@ deploy, and the dashboard says so.
 - Exceptions: a stable fingerprint, the exception class, a sanitized message
   (numbers, IDs, emails, and quoted values removed), and application frames
   only.
-- Once per process: the route table, job classes, Solid Queue recurring
-  schedules, critical flows, and file digests (relative paths and hashes, never
-  file contents) so DeployAngel can tell which routes changed in a release.
+- Once per process: the route table, job classes, recurring schedules
+  declared for Solid Queue, sidekiq-cron, or sidekiq-scheduler, 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`.
 
 It does not send request bodies, parameters, headers, cookies, SQL, logs, or

data/lib/deployangel/rails/metadata.rb

@@ -58,8 +58,15 @@ module DeployAngel
         []
       end
 
-      # Solid Queue recurring tasks for the current environment.
+      # Declared recurring jobs from Solid Queue, sidekiq-cron, and
+      # sidekiq-scheduler. Each source is read on its own, so a file that
+      # can't be read leaves the others' schedules in place.
       def schedules
+        solid_queue_schedules + sidekiq_cron_schedules + sidekiq_scheduler_schedules
+      end
+
+      # Solid Queue recurring tasks for the current environment.
+      def solid_queue_schedules
         path = File.join(@root, "config", "recurring.yml")
         return [] unless File.file?(path)
 
@@ -68,13 +75,123 @@ module DeployAngel
         Array(tasks).filter_map do |key, task|
           next unless task.is_a?(Hash) && task["schedule"]
 
-          { "key" => key.to_s, "class" => task["class"]&.to_s, "schedule" => task["schedule"].to_s, "source" => "solid_queue",
+          schedule = { "key" => key.to_s, "class" => task["class"]&.to_s, "schedule" => task["schedule"].to_s, "source" => "solid_queue",
             "time_zone" => scheduler_time_zone }
+          schedule["runs_as"] = command_job_class if task["class"].nil? && task["command"]
+          schedule
+        end
+      rescue StandardError
+        []
+      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.
+      def sidekiq_cron_schedules
+        return [] unless defined?(::Sidekiq::Cron)
+
+        path = yaml_path(sidekiq_cron_schedule_file) or return []
+        jobs = load_yaml(path)
+        jobs = jobs.map { |name, job| job.is_a?(Hash) ? job.merge("name" => name) : job } if jobs.is_a?(Hash)
+        Array(jobs).filter_map do |job|
+          next unless job.is_a?(Hash) && job["cron"] && job["status"].to_s != "disabled"
+
+          { "key" => job["name"].to_s, "class" => (job["klass"] || job["class"])&.to_s, "schedule" => job["cron"].to_s,
+            "source" => "sidekiq_cron", "time_zone" => local_time_zone }
         end
       rescue StandardError
         []
       end
 
+      def 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")
+      end
+
+      # sidekiq-scheduler jobs from Sidekiq's config file, where it reads
+      # them under :scheduler: :schedule: (or :schedule: in older versions).
+      # A cron runs at set times; every and interval repeat from when the
+      # scheduler starts, which a deploy restarts. One-off at and in jobs
+      # aren't recurring, so they're left out.
+      def sidekiq_scheduler_schedules
+        return [] unless defined?(::SidekiqScheduler)
+
+        path = sidekiq_config_file or return []
+        config = normalize_keys(load_yaml(path) || {})
+        config = config.merge(config.delete(::Rails.env.to_s) || {}) if config.is_a?(Hash)
+        jobs = config.dig("scheduler", "schedule") || config["schedule"]
+        return [] unless jobs.is_a?(Hash)
+
+        jobs.filter_map do |name, job|
+          next unless job.is_a?(Hash) && job["enabled"] != false && scheduled_in_this_environment?(job)
+
+          type = %w[cron every at in interval].find { |key| Array(job[key]).first.to_s.strip != "" }
+          next unless %w[cron every interval].include?(type)
+
+          value = Array(job[type]).first.to_s
+          schedule = { "key" => name.to_s, "class" => (job["class"] || name).to_s, "source" => "sidekiq_scheduler",
+            "time_zone" => local_time_zone }
+          type == "cron" ? schedule.merge("schedule" => value) : schedule.merge("schedule" => nil, "every" => value)
+        end
+      rescue StandardError
+        []
+      end
+
+      # The file Sidekiq loads: the -C path in the Procfile's sidekiq
+      # command, else config/sidekiq.yml.
+      def sidekiq_config_file
+        procfile = File.join(@root, "Procfile")
+        named = File.read(procfile)[/\bsidekiq\b[^\n]*?\s(?:-C|--config)[\s=]+(\S+)/, 1] if File.file?(procfile)
+        named ? yaml_path(File.expand_path(named, @root)) : yaml_path(File.join(@root, "config", "sidekiq.yml"))
+      rescue StandardError
+        nil
+      end
+
+      # sidekiq-scheduler skips a job whose rails_env doesn't list this one.
+      def scheduled_in_this_environment?(job)
+        job["rails_env"].nil? || job["rails_env"].to_s.gsub(/\s/, "").split(",").include?(::Rails.env.to_s)
+      end
+
+      # The zone sidekiq-cron and sidekiq-scheduler read a schedule in when it
+      # names none: the process's local zone, as Fugit and rufus-scheduler
+      # find it. nil if that can't be told.
+      def local_time_zone
+        ::EtOrbi.determine_local_tzone&.name if defined?(::EtOrbi)
+      rescue StandardError
+        nil
+      end
+
+      # The path, or the same name with .yaml if only that exists.
+      def yaml_path(path)
+        [ path, path.sub(/\.yml\z/, ".yaml") ].find { |candidate| File.file?(candidate) }
+      end
+
+      def load_yaml(path)
+        YAML.safe_load(ERB.new(File.read(path), trim_mode: "-").result, permitted_classes: [ Symbol ], aliases: true)
+      end
+
+      # Sidekiq's config uses symbol keys (:scheduler:); compare them as
+      # plain strings.
+      def normalize_keys(object)
+        case object
+        when Hash then object.to_h { |key, value| [ key.to_s.delete_prefix(":"), normalize_keys(value) ] }
+        when Array then object.map { |value| normalize_keys(value) }
+        else object
+        end
+      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
+        if defined?(::SolidQueue::RecurringTask) && ::SolidQueue::RecurringTask.respond_to?(:default_job_class)
+          ::SolidQueue::RecurringTask.default_job_class&.name
+        end || "SolidQueue::RecurringJob"
+      rescue StandardError
+        "SolidQueue::RecurringJob"
+      end
+
       # The zone Solid Queue reads a schedule in when the schedule names
       # none: its own setting, config.time_zone by default. nil when that's
       # the system's local time or Solid Queue predates the setting, and

data/lib/deployangel/version.rb

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

metadata

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