sidekiq 8.0.0.beta1 → 8.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7280923fe38a56b42bb33c639f9e0a365c1f585f928e8cdfd3ce06fe989fc7e
-  data.tar.gz: e8c6a01e393390f1a3ab3a48c04b3621efd5621c6b184240c3e8316602e24e9c
+  metadata.gz: e6ce813e475bd69e3cb05f0ebe216e1dcbd6b4865584a4761c889a97761d5fe1
+  data.tar.gz: 855e4b4db0b7c080f9a4347c338eff1c4b62be91e233d0e20447b15a3251756a
 SHA512:
-  metadata.gz: 076a8f70170dfdc6ec78430ca41b182ed986453bdfbcfe24b7dd5ef1d8f2321b560cb94201c2f2c3a30c2ce42a31e38ce14151f0ebbee90bc97a2463b427747a
-  data.tar.gz: 8cc4828931a73da67ae40edb14508b82624781b9732280ce9e8db615c8bed1039b89b8b50db54c35bbffd4a010f904598be2bb4aa037228bbd4b4b325b2b9421
+  metadata.gz: 20f3dfd6b5e9aba7f8d2a0ef0fb9bef6ee7918aa31a8deee0bc592dcd957e44c08ca5d6a30e16064c81a5f68bc571fe8585c2e3ba453a81db0d565862e67454b
+  data.tar.gz: cdfea6f26e591ac0fb7c4bfe8874d8272615b27bfdd91daef13d1620e902fd5ba8a3c818d70a5729a89104c6ae7ac576c0f0df65717f514999d5c1c651605bd8

data/Changes.md

@@ -2,29 +2,51 @@
 
 [Sidekiq Changes](https://github.com/sidekiq/sidekiq/blob/main/Changes.md) | [Sidekiq Pro Changes](https://github.com/sidekiq/sidekiq/blob/main/Pro-Changes.md) | [Sidekiq Enterprise Changes](https://github.com/sidekiq/sidekiq/blob/main/Ent-Changes.md)
 
-HEAD / main
+8.0.0
 ----------
 
 - **WARNING** The underlying class name for Active Jobs has changed from `ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper` to `Sidekiq::ActiveJob::Wrapper`.
-- **WARNING** The `created_at` and `enqueued_at` attributes are now stored as
-  integer milliseconds, rather than epoch floats. This is meant to avoid precision
-  issues with JSON and JavaScript's 53-bit Floats. Example:
-  `"created_at" => 1234567890.123456` -> `"created_at" => 1234567890123`.
+  The old name will still work in 8.x.
+- **WARNING** The `created_at`, `enqueued_at`, `failed_at` and `retried_at` attributes are now stored as epoch milliseconds, rather than epoch floats.
+  This is meant to avoid precision issues with JSON and JavaScript's 53-bit Floats.
+  Example: `"created_at" => 1234567890.123456` -> `"created_at" => 1234567890123`.
 - **NEW FEATURE** Job Profiling is now supported with [Vernier](https://vernier.prof)
   which makes it really easy to performance tune your slow jobs.
   The Web UI contains a new **Profiles** tab to view any collected profile data.
   Please read the new [Profiling](https://github.com/sidekiq/sidekiq/wiki/Profiling) wiki page for details.
+- **NEW FEATURE** Job Metrics now store up to 72 hours of data and the Web UI allows display of 24/48/72 hours. [#6614]
 - CurrentAttribute support now uses `ActiveJob::Arguments` to serialize the context object, supporting Symbols and GlobalID.
   The change should be backwards compatible. [#6510]
 - Freshen up `Sidekiq::Web` to simplify the code and improve security [#6532]
   The CSS has been rewritten from scratch to remove the Bootstrap framework.
+- Add `on_cancel` callback for iterable jobs [#6607]
+- Add `cursor` reader to get the current cursor inside iterable jobs [#6606]
 - Default error logging has been modified to use Ruby's `Exception#detailed_message` and `#full_message` APIs.
 - CI now runs against Redis, Dragonfly and Valkey.
+- Job tags now allow custom CSS display [#6595]
 - The Web UI's language picker now shows options in the native language
 - Remove global variable usage within the codebase
+- Colorize and adjust logging for easier reading
 - Adjust Sidekiq's default thread priority to -1 for a 50ms timeslice.
   This can help avoid TimeoutErrors when Sidekiq is overloaded. [#6543]
-- Support: Redis 7.2+, Ruby 3.2+, Rails 7.0+
+- Use `Logger#with_level`, remove Sidekiq's custom impl
+- Remove `base64` gem dependency
+- Support: (Dragonfly 1.27+, Valkey 7.2+, Redis 7.2+), Ruby 3.2+, Rails 7.0+
+
+7.3.10
+----------
+
+- Deprecate Redis :password as a String to avoid log disclosure. [#6625]
+  Use a Proc instead: `config.redis = { password: ->(username) { "password" } }`
+
+7.3.9
+----------
+
+- Only require activejob if necessary [#6584]
+  You might get `uninitialized constant Sidekiq::ActiveJob` if you
+  `require 'sidekiq'` before `require 'rails'`.
+- Fix iterable job cancellation [#6589]
+- Web UI accessibility improvements [#6604]
 
 7.3.8
 ----------

data/README.md

@@ -13,7 +13,7 @@ same process. Sidekiq can be used by any Ruby application.
 Requirements
 -----------------
 
-- Redis: Redis 7.2+, Valkey 7.2+ or Dragonfly 1.13+
+- Redis: Redis 7.2+, Valkey 7.2+ or Dragonfly 1.27+
 - Ruby: MRI 3.2+ or JRuby 9.4+.
 
 Sidekiq 8.0 supports Rails and Active Job 7.0+.

data/lib/sidekiq/api.rb

@@ -441,6 +441,18 @@ module Sidekiq
       self["bid"]
     end
 
+    def failed_at
+      if self["failed_at"]
+        time_from_timestamp(self["failed_at"])
+      end
+    end
+
+    def retried_at
+      if self["retried_at"]
+        time_from_timestamp(self["retried_at"])
+      end
+    end
+
     def enqueued_at
       if self["enqueued_at"]
         time_from_timestamp(self["enqueued_at"])

data/lib/sidekiq/capsule.rb

@@ -11,12 +11,12 @@ module Sidekiq
   # This capsule will pull jobs from the "single" queue and process
   # the jobs with one thread, meaning the jobs will be processed serially.
   #
-  # Sidekiq.configure_server do |config|
-  #   config.capsule("single-threaded") do |cap|
-  #     cap.concurrency = 1
-  #     cap.queues = %w(single)
+  #   Sidekiq.configure_server do |config|
+  #     config.capsule("single-threaded") do |cap|
+  #       cap.concurrency = 1
+  #       cap.queues = %w(single)
+  #     end
   #   end
-  # end
   class Capsule
     include Sidekiq::Component
     extend Forwardable

data/lib/sidekiq/component.rb

@@ -23,6 +23,16 @@ module Sidekiq
   module Component # :nodoc:
     attr_reader :config
 
+    # This is epoch milliseconds, appropriate for persistence
+    def real_ms
+      ::Process.clock_gettime(::Process::CLOCK_REALTIME, :millisecond)
+    end
+
+    # used for time difference and relative comparisons, not persistence.
+    def mono_ms
+      ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond)
+    end
+
     def watchdog(last_words)
       yield
     rescue Exception => ex

data/lib/sidekiq/iterable_job.rb

@@ -46,6 +46,7 @@ module Sidekiq
     # def on_start
     # def on_resume
     # def on_stop
+    # def on_cancel
     # def on_complete
     # def around_iteration
     #

data/lib/sidekiq/job/iterable.rb

@@ -64,6 +64,10 @@ module Sidekiq
         @_cancelled
       end
 
+      def cursor
+        @_cursor.freeze
+      end
+
       # A hook to override that will be called when the job starts iterating.
       #
       # It is called only once, for the first time.
@@ -91,6 +95,11 @@ module Sidekiq
       def on_stop
       end
 
+      # A hook to override that will be called when the job is cancelled.
+      #
+      def on_cancel
+      end
+
       # A hook to override that will be called when the job finished iterating.
       #
       def on_complete
@@ -182,6 +191,7 @@ module Sidekiq
 
       def iterate_with_enumerator(enumerator, arguments)
         if is_cancelled?
+          on_cancel
           logger.info { "Job cancelled" }
           return true
         end
@@ -200,6 +210,7 @@ module Sidekiq
             state_flushed_at = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
             if cancelled
               @_cancelled = true
+              on_cancel
               logger.info { "Job cancelled" }
               return true
             end

data/lib/sidekiq/job_logger.rb

@@ -26,16 +26,16 @@ module Sidekiq
       # If we're using a wrapper class, like ActiveJob, use the "wrapped"
       # attribute to expose the underlying thing.
       h = {
-        class: job_hash["display_class"] || job_hash["wrapped"] || job_hash["class"],
-        jid: job_hash["jid"]
+        jid: job_hash["jid"],
+        class: job_hash["display_class"] || job_hash["wrapped"] || job_hash["class"]
       }
       h[:bid] = job_hash["bid"] if job_hash.has_key?("bid")
       h[:tags] = job_hash["tags"] if job_hash.has_key?("tags")
 
       Thread.current[:sidekiq_context] = h
       level = job_hash["log_level"]
-      if level && @logger.respond_to?(:log_at)
-        @logger.log_at(level, &block)
+      if level
+        @logger.with_level(level, &block)
       else
         yield
       end

data/lib/sidekiq/job_retry.rb

@@ -139,6 +139,10 @@ module Sidekiq
 
     private
 
+    def now_ms
+      ::Process.clock_gettime(::Process::CLOCK_REALTIME, :millisecond)
+    end
+
     # Note that +jobinst+ can be nil here if an error is raised before we can
     # instantiate the job instance.  All access must be guarded and
     # best effort.
@@ -156,10 +160,10 @@ module Sidekiq
       msg["error_message"] = m
       msg["error_class"] = exception.class.name
       count = if msg["retry_count"]
-        msg["retried_at"] = Time.now.to_f
+        msg["retried_at"] = now_ms
         msg["retry_count"] += 1
       else
-        msg["failed_at"] = Time.now.to_f
+        msg["failed_at"] = now_ms
         msg["retry_count"] = 0
       end
 
@@ -177,7 +181,7 @@ module Sidekiq
       return retries_exhausted(jobinst, msg, exception) if count >= max_retry_attempts
 
       rf = msg["retry_for"]
-      return retries_exhausted(jobinst, msg, exception) if rf && ((msg["failed_at"] + rf) < Time.now.to_f)
+      return retries_exhausted(jobinst, msg, exception) if rf && (time_for(msg["failed_at"]) + rf) < Time.now
 
       strategy, delay = delay_for(jobinst, count, exception, msg)
       case strategy
@@ -197,6 +201,14 @@ module Sidekiq
       end
     end
 
+    def time_for(item)
+      if item.is_a?(Float)
+        Time.at(item)
+      else
+        Time.at(item / 1000, item % 1000)
+      end
+    end
+
     # returns (strategy, seconds)
     def delay_for(jobinst, count, exception, msg)
       rv = begin

data/lib/sidekiq/logger.rb

@@ -22,88 +22,41 @@ module Sidekiq
     end
   end
 
-  module LoggingUtils
-    LEVELS = {
-      "debug" => 0,
-      "info" => 1,
-      "warn" => 2,
-      "error" => 3,
-      "fatal" => 4
-    }
-    LEVELS.default_proc = proc do |_, level|
-      puts("Invalid log level: #{level.inspect}")
-      nil
-    end
-
-    LEVELS.each do |level, numeric_level|
-      define_method(:"#{level}?") do
-        local_level.nil? ? super() : local_level <= numeric_level
-      end
-    end
-
-    def local_level
-      Thread.current[:sidekiq_log_level]
-    end
-
-    def local_level=(level)
-      case level
-      when Integer
-        Thread.current[:sidekiq_log_level] = level
-      when Symbol, String
-        Thread.current[:sidekiq_log_level] = LEVELS[level.to_s]
-      when nil
-        Thread.current[:sidekiq_log_level] = nil
-      else
-        raise ArgumentError, "Invalid log level: #{level.inspect}"
-      end
-    end
-
-    def level
-      local_level || super
-    end
-
-    # Change the thread-local level for the duration of the given block.
-    def log_at(level)
-      old_local_level = local_level
-      self.local_level = level
-      yield
-    ensure
-      self.local_level = old_local_level
-    end
-  end
-
   class Logger < ::Logger
-    include LoggingUtils
-
     module Formatters
+      COLORS = {
+        "DEBUG" => "\e[1;32mDEBUG\e[0m", # green
+        "INFO" => "\e[1;34mINFO \e[0m", # blue
+        "WARN" => "\e[1;33mWARN \e[0m", # yellow
+        "ERROR" => "\e[1;31mERROR\e[0m", # red
+        "FATAL" => "\e[1;35mFATAL\e[0m" # pink
+      }
       class Base < ::Logger::Formatter
         def tid
           Thread.current["sidekiq_tid"] ||= (Thread.current.object_id ^ ::Process.pid).to_s(36)
         end
 
         def format_context(ctxt = Sidekiq::Context.current)
-          if ctxt.size > 0
-            ctxt.map { |k, v|
-              case v
-              when Array
-                "#{k}=#{v.join(",")}"
-              else
-                "#{k}=#{v}"
-              end
-            }.join(" ")
-          end
+          (ctxt.size == 0) ? "" : " #{ctxt.map { |k, v|
+            case v
+            when Array
+              "#{k}=#{v.join(",")}"
+            else
+              "#{k}=#{v}"
+            end
+          }.join(" ")}"
         end
       end
 
       class Pretty < Base
         def call(severity, time, program_name, message)
-          "#{time.utc.iso8601(3)} pid=#{::Process.pid} tid=#{tid} #{format_context} #{severity}: #{message}\n"
+          "#{Formatters::COLORS[severity]} #{time.utc.iso8601(3)} pid=#{::Process.pid} tid=#{tid}#{format_context}: #{message}\n"
         end
       end
 
       class WithoutTimestamp < Pretty
         def call(severity, time, program_name, message)
-          "pid=#{::Process.pid} tid=#{tid} #{format_context} #{severity}: #{message}\n"
+          "#{Formatters::COLORS[severity]} pid=#{::Process.pid} tid=#{tid} #{format_context}: #{message}\n"
         end
       end
 

data/lib/sidekiq/metrics/query.rb

@@ -10,7 +10,7 @@ module Sidekiq
     # Caller sets a set of attributes to act as filters. {#fetch} will call
     # Redis and return a Hash of results.
     #
-    # NB: all metrics and times/dates are UTC only. We specifically do not
+    # NB: all metrics and times/dates are UTC only. We explicitly do not
     # support timezones.
     class Query
       def initialize(pool: nil, now: Time.now)
@@ -19,23 +19,46 @@ module Sidekiq
         @klass = nil
       end
 
+      ROLLUPS = {
+        # minutely aggregates per minute
+        minutely: [60, ->(time) { time.strftime("j|%y%m%d|%-H:%M") }],
+        # hourly aggregates every 10 minutes so we'll have six data points per hour
+        hourly: [600, ->(time) {
+          m = time.min
+          mins = (m < 10) ? "0" : m.to_s[0]
+          time.strftime("j|%y%m%d|%-H:#{mins}")
+        }]
+      }
+
       # Get metric data for all jobs from the last hour
       #  +class_filter+: return only results for classes matching filter
-      def top_jobs(class_filter: nil, minutes: 60)
-        result = Result.new
-
+      #  +minutes+: the number of fine-grained minute buckets to retrieve
+      #  +hours+: the number of coarser-grained 10-minute buckets to retrieve, in hours
+      def top_jobs(class_filter: nil, minutes: nil, hours: nil)
         time = @time
+        minutes = 60 unless minutes || hours
+
+        # DoS protection, sanity check
+        minutes = 60 if minutes && minutes > 480
+        hours = 72 if hours && hours > 72
+
+        granularity = hours ? :hourly : :minutely
+        result = Result.new(granularity)
+        result.ends_at = time
+        count = hours ? hours * 6 : minutes
+        stride, keyproc = ROLLUPS[granularity]
+
         redis_results = @pool.with do |conn|
           conn.pipelined do |pipe|
-            minutes.times do |idx|
-              key = "j|#{time.strftime("%Y%m%d")}|#{time.hour}:#{time.min}"
+            count.times do |idx|
+              key = keyproc.call(time)
               pipe.hgetall key
-              result.prepend_bucket time
-              time -= 60
+              time -= stride
             end
           end
         end
 
+        result.starts_at = time
         time = @time
         redis_results.each do |hash|
           hash.each do |k, v|
@@ -43,63 +66,66 @@ module Sidekiq
             next if class_filter && !class_filter.match?(kls)
             result.job_results[kls].add_metric metric, time, v.to_i
           end
-          time -= 60
+          time -= stride
         end
 
-        result.marks = fetch_marks(result.starts_at..result.ends_at)
-
+        result.marks = fetch_marks(result.starts_at..result.ends_at, granularity)
         result
       end
 
-      def for_job(klass, minutes: 60)
-        result = Result.new
-
+      def for_job(klass, minutes: nil, hours: nil)
         time = @time
+        minutes = 60 unless minutes || hours
+
+        # DoS protection, sanity check
+        minutes = 60 if minutes && minutes > 480
+        hours = 72 if hours && hours > 72
+
+        granularity = hours ? :hourly : :minutely
+        result = Result.new(granularity)
+        result.ends_at = time
+        count = hours ? hours * 6 : minutes
+        stride, keyproc = ROLLUPS[granularity]
+
         redis_results = @pool.with do |conn|
           conn.pipelined do |pipe|
-            minutes.times do |idx|
-              key = "j|#{time.strftime("%Y%m%d")}|#{time.hour}:#{time.min}"
+            count.times do |idx|
+              key = keyproc.call(time)
               pipe.hmget key, "#{klass}|ms", "#{klass}|p", "#{klass}|f"
-              result.prepend_bucket time
-              time -= 60
+              time -= stride
             end
           end
         end
 
+        result.starts_at = time
         time = @time
         @pool.with do |conn|
           redis_results.each do |(ms, p, f)|
             result.job_results[klass].add_metric "ms", time, ms.to_i if ms
             result.job_results[klass].add_metric "p", time, p.to_i if p
             result.job_results[klass].add_metric "f", time, f.to_i if f
-            result.job_results[klass].add_hist time, Histogram.new(klass).fetch(conn, time).reverse
-            time -= 60
+            result.job_results[klass].add_hist time, Histogram.new(klass).fetch(conn, time).reverse if minutes
+            time -= stride
           end
         end
 
-        result.marks = fetch_marks(result.starts_at..result.ends_at)
-
+        result.marks = fetch_marks(result.starts_at..result.ends_at, granularity)
         result
       end
 
-      class Result < Struct.new(:starts_at, :ends_at, :size, :buckets, :job_results, :marks)
-        def initialize
+      class Result < Struct.new(:granularity, :starts_at, :ends_at, :size, :job_results, :marks)
+        def initialize(granularity = :minutely)
           super
-          self.buckets = []
+          self.granularity = granularity
           self.marks = []
-          self.job_results = Hash.new { |h, k| h[k] = JobResult.new }
-        end
-
-        def prepend_bucket(time)
-          buckets.unshift time.strftime("%H:%M")
-          self.ends_at ||= time
-          self.starts_at = time
+          self.job_results = Hash.new { |h, k| h[k] = JobResult.new(granularity) }
         end
       end
 
-      class JobResult < Struct.new(:series, :hist, :totals)
-        def initialize
+      class JobResult < Struct.new(:granularity, :series, :hist, :totals)
+        def initialize(granularity = :minutely)
           super
+          self.granularity = granularity
           self.series = Hash.new { |h, k| h[k] = Hash.new(0) }
           self.hist = Hash.new { |h, k| h[k] = [] }
           self.totals = Hash.new(0)
@@ -107,14 +133,14 @@ module Sidekiq
 
         def add_metric(metric, time, value)
           totals[metric] += value
-          series[metric][time.strftime("%H:%M")] += value
+          series[metric][Query.bkt_time_s(time, granularity)] += value
 
           # Include timing measurements in seconds for convenience
           add_metric("s", time, value / 1000.0) if metric == "ms"
         end
 
         def add_hist(time, hist_result)
-          hist[time.strftime("%H:%M")] = hist_result
+          hist[Query.bkt_time_s(time, granularity)] = hist_result
         end
 
         def total_avg(metric = "ms")
@@ -131,22 +157,24 @@ module Sidekiq
         end
       end
 
-      class MarkResult < Struct.new(:time, :label)
-        def bucket
-          time.strftime("%H:%M")
-        end
+      MarkResult = Struct.new(:time, :label, :bucket)
+
+      def self.bkt_time_s(time, granularity)
+        # truncate time to ten minutes ("8:40", not "8:43") or one minute
+        truncation = (granularity == :hourly) ? 600 : 60
+        Time.at(time.to_i - time.to_i % truncation).utc.iso8601
       end
 
       private
 
-      def fetch_marks(time_range)
+      def fetch_marks(time_range, granularity)
         [].tap do |result|
           marks = @pool.with { |c| c.hgetall("#{@time.strftime("%Y%m%d")}-marks") }
 
           marks.each do |timestamp, label|
             time = Time.parse(timestamp)
             if time_range.cover? time
-              result << MarkResult.new(time, label)
+              result << MarkResult.new(time, label, Query.bkt_time_s(time, granularity))
             end
           end
         end

data/lib/sidekiq/metrics/shared.rb

@@ -25,7 +25,10 @@ module Sidekiq
     #
     # To store this data, we use Redis' BITFIELD command to store unsigned 16-bit counters
     # per bucket per klass per minute. It's unlikely that most people will be executing more
-    # than 1000 job/sec for a full minute of a specific type.
+    # than 1000 job/sec for a full minute of a specific type (i.e. overflow 65,536).
+    #
+    # Histograms are only stored at the fine-grained level, they are not rolled up
+    # for longer-term buckets.
     class Histogram
       include Enumerable
 
@@ -82,15 +85,15 @@ module Sidekiq
       end
 
       def fetch(conn, now = Time.now)
-        window = now.utc.strftime("%d-%H:%-M")
-        key = "#{@klass}-#{window}"
+        window = now.utc.strftime("%-d-%-H:%-M")
+        key = "h|#{@klass}-#{window}"
         conn.bitfield_ro(key, *FETCH)
       end
 
       def persist(conn, now = Time.now)
         buckets, @buckets = @buckets, []
-        window = now.utc.strftime("%d-%H:%-M")
-        key = "#{@klass}-#{window}"
+        window = now.utc.strftime("%-d-%-H:%-M")
+        key = "h|#{@klass}-#{window}"
         cmd = [key, "OVERFLOW", "SAT"]
         buckets.each_with_index do |counter, idx|
           val = counter.value

data/lib/sidekiq/metrics/tracking.rb

@@ -19,13 +19,13 @@ module Sidekiq
       end
 
       def track(queue, klass)
-        start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond)
+        start = mono_ms
         time_ms = 0
         begin
           begin
             yield
           ensure
-            finish = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond)
+            finish = mono_ms
             time_ms = finish - start
           end
           # We don't track time for failed jobs as they can have very unpredictable
@@ -51,7 +51,7 @@ module Sidekiq
       end
 
       # LONG_TERM = 90 * 24 * 60 * 60
-      # MID_TERM = 7 * 24 * 60 * 60
+      MID_TERM = 3 * 24 * 60 * 60
       SHORT_TERM = 8 * 60 * 60
 
       def flush(time = Time.now)
@@ -62,8 +62,10 @@ module Sidekiq
 
         now = time.utc
         # nowdate = now.strftime("%Y%m%d")
-        # nowhour = now.strftime("%Y%m%d|%-H")
-        nowmin = now.strftime("%Y%m%d|%-H:%-M")
+        # "250214|8:4" is the 10 minute bucket for Feb 14 2025, 08:43
+        nowmid = now.strftime("%y%m%d|%-H:%M")[0..-2]
+        # "250214|8:43" is the 1 minute bucket for Feb 14 2025, 08:43
+        nowshort = now.strftime("%y%m%d|%-H:%M")
         count = 0
 
         redis do |conn|
@@ -81,8 +83,8 @@ module Sidekiq
           # daily or hourly rollups.
           [
             # ["j", jobs, nowdate, LONG_TERM],
-            # ["j", jobs, nowhour, MID_TERM],
-            ["j", jobs, nowmin, SHORT_TERM]
+            ["j", jobs, nowmid, MID_TERM],
+            ["j", jobs, nowshort, SHORT_TERM]
           ].each do |prefix, data, bucket, ttl|
             conn.pipelined do |xa|
               stats = "#{prefix}|#{bucket}"