tj-scale 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76a39f424b8bf07fbe1cd0812fa63833e403ce9c5983639e6f2644db2700b798
-  data.tar.gz: 78b517bd5a20e91d617dfbeddea44d085e1808442c24840034252b2140af286f
+  metadata.gz: a15d2cfe793359d5678938c3f6cf974f496ac716b173acbf4f9b408668b88da4
+  data.tar.gz: '0490a176f40d292a3868a135ddd8ecdddfad30025a5d7458163c7159f2dbe144'
 SHA512:
-  metadata.gz: 8995d5a220b907b77126f766c9f2c7b382cd445c8bd4f3da3b20509e072ef26e84092ee16462a0218693c211d44ad3f65769a10b421c639bdf0d02386a844a59
-  data.tar.gz: d534b2ceb99df75e41b4ee9b2495e00d5e0a105e2cdf9d3c579ef6202242d8ec953a1f71d8026a9f06359d6a03ba8c16dbc4123ac4dde9768dd34cb685d4a686
+  metadata.gz: d5978c29aeaac97ade3368b4c693ab5d445c9c43716490d8299fe22c2785a0014b335df040c3836db385de4f28093aa4c74b0abe2642f731eeb4295e69f4bbbc
+  data.tar.gz: 4e3ff1c12ff935b3f211c9698a718e54f1e5b41501dcf565cbdc8a64c08f7df1e50258cb4444b029040f117fce5cac9385e36a995dbe8b714c8f684baf6b52fb

data/CHANGELOG.md

@@ -7,6 +7,41 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+
+## [1.1.1] (tj-scale) - 2026-07-20
+
+### Fixed
+
+- **Web `queue_time_ms` is now captured on Heroku.** The Rack queue-time
+  middleware only parsed the nginx-style `X-Request-Start: t=<seconds>` form, but
+  Heroku's router sends a **bare millisecond epoch** (e.g. `1731523200000`). The
+  header is now parsed in both formats, so `queue_time_ms` is actually produced on
+  Heroku when `TJ_SCALE_ENABLE_QUEUE_TIME_MIDDLEWARE=1` (previously always `nil`).
+- **Stale `queue_time_ms` is no longer re-reported.** The captured router
+  queue-time snapshot is now consumed each ingest tick, so after web traffic stops
+  the gem stops resending the last elevated value (which kept the web dyno scaled
+  up and blocked downscaling on the `queue_time_ms` metric).
+- **Delayed Job counting no longer depends on PostgreSQL.** The runnable-jobs
+  query used a Postgres-only `interval '5 seconds'` SQL literal that raises on
+  MySQL/SQLite; the exception was swallowed to `0`, silently masking the entire
+  worker backlog. The 5-second buffer is now computed in Ruby (`run_at < now - 5`),
+  so counting works on any Delayed Job-supported database.
+
+### Added
+
+- Integration coverage for the Sidekiq backend against the real `Sidekiq::Queue`
+  API and a live Redis, alongside the existing double-based specs — those only
+  asserted our assumptions about `size` and `latency`, so an upstream API change
+  would have surfaced as broken autoscaling in a host app rather than a red test.
+  `sidekiq` is now a development dependency. The specs use
+  `TJ_SCALE_TEST_REDIS_URL` (default `redis://localhost:6379/15`), `FLUSHDB`
+  between examples, and skip themselves when no Redis is reachable, so
+  `rake spec` still passes without one.
+- An explicit test that enqueued counts exclude the retry and scheduled sets,
+  pinning that as a deliberate limitation: a backlog waiting in `retry` or
+  `schedule` does not by itself scale workers up.
+
+
 ## [1.1.0] (tj-scale) - 2026-06-12
 
 ### Changed

data/lib/tj_scale_ruby/configuration.rb

@@ -111,6 +111,17 @@ module TjScaleRuby
       web_queue_mutex.synchronize { @web_queue_time_ms }
     end
 
+    # Reads and clears the latest captured router queue time (ms). Consuming it each
+    # ingest tick prevents a stale elevated value from being re-reported (and keeping
+    # the web dyno scaled up) after traffic stops. Thread-safe.
+    def flush_web_queue_time_ms!
+      web_queue_mutex.synchronize do
+        v = @web_queue_time_ms
+        @web_queue_time_ms = nil
+        v
+      end
+    end
+
     def clear_web_queue_time_snapshot!
       web_queue_mutex.synchronize { @web_queue_time_ms = nil }
     end

data/lib/tj_scale_ruby/job_backends/delayed_job.rb

@@ -16,7 +16,10 @@ module TjScaleRuby
           min_priority = TjScaleRuby.configuration.min_priority
           max_priority = TjScaleRuby.configuration.max_priority
 
-          query = ::Delayed::Job.where("run_at + interval '5 seconds' < ?", now)
+          # 5-second buffer past run_at. Compute the cutoff in Ruby (run_at < now - 5s)
+          # instead of a SQL "interval" literal, which is PostgreSQL-only and would raise
+          # on MySQL/SQLite — silently masking the whole backlog as 0.
+          query = ::Delayed::Job.where("run_at < ?", now - 5)
           query = query.where("failed_at IS NULL")
           query = query.where("locked_at IS NULL")
           query = query.where("priority >= ?", min_priority) unless min_priority.zero?

data/lib/tj_scale_ruby/models/tj_scale_ruby.rb

@@ -80,7 +80,7 @@ module TjScaleRuby
       private
 
       def web_queue_time_ms_for_payload
-        snap = TjScaleRuby.last_web_queue_time_ms
+        snap = TjScaleRuby.flush_web_queue_time_ms!
         return snap unless snap.nil?
 
         env = ENV["TJ_SCALE_QUEUE_TIME_MS"]

data/lib/tj_scale_ruby/rack_queue_time_middleware.rb

@@ -29,14 +29,27 @@ module TjScaleRuby
       [now_ms - start_ms, 0].max
     end
 
+    # Heroku's router sends a bare unix-millisecond integer ("1751376000123"); nginx
+    # sends a "t=" prefixed value in seconds ("t=1751376000.123"). Match the prefixed
+    # form first, then fall back to a bare leading number, so the primary deployment
+    # target (Heroku) is not silently unparsed — a nil here means +queue_time_ms+ is
+    # never reported and web autoscaling on that metric can never fire.
     def self.request_start_epoch_ms(env)
       raw = env["HTTP_X_REQUEST_START"]
-      return nil if raw.nil? || raw.strip.empty?
+      return nil if raw.nil?
 
-      m = raw.to_s.match(/t=(\d+(?:\.\d+)?)/i)
+      s = raw.to_s.strip
+      return nil if s.empty?
+
+      # Heroku's router sends a bare millisecond epoch ("1731523200000"); nginx and
+      # some proxies send "t=<seconds>[.<frac>]". Accept both — prefer the +t=+ capture
+      # when present, otherwise fall back to the leading numeric timestamp.
+      m = s.match(/t=(\d+(?:\.\d+)?)/i) || s.match(/(\d+(?:\.\d+)?)/)
       return nil unless m
 
       v = m[1].to_f
+      return nil unless v.positive?
+
       v *= 1000 if v < 1_000_000_000_000 # seconds (or fractional) -> ms
       v.round
     end

data/lib/tj_scale_ruby/version.rb

@@ -2,5 +2,5 @@
 
 # Version module for TjScaleRuby gem
 module TjScaleRuby
-  VERSION = "1.1.0"
+  VERSION = "1.1.1"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: tj-scale
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Tanuj
 bindir: exe
 cert_chain: []
-date: 2026-06-12 00:00:00.000000000 Z
+date: 2026-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -57,6 +57,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.3'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement