jobtick 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7db7f99928881432d43b819fb1ffa2772e6a690f659b0a54ac543bbbbed8e9db
-  data.tar.gz: 8c67224a9ae754c411914958e3e9f8a3255bf9af5b09f2d2d2bd11ddffbf72f6
+  metadata.gz: abfce9cfddae0a798d132217b9376b130afe9446f85e279d3241e7016ed1a89f
+  data.tar.gz: 36590511cdf6e5b07541cdb66589fc5efd7f2250aeb4d5e5e4b20a18976642de
 SHA512:
-  metadata.gz: 316eab73c6b4ef66752f86515113cf1f881e059c678045b47b63fc04a0dd67265753cd4c9a607db64e47b7629f71b2e107e7b0d62d959f3a1905326af42e5969
-  data.tar.gz: 65725c57b8f2b1f6f97f3b93b799d3a2e57f5f4fae15cb8f0232f7259d3ee9285a37f60fa0b3bf2212b6f5faef77c565863e4158fe9109c49d712e7ecaa29115
+  metadata.gz: a81d1bf56a1e48ed5395bd5d913b8f49aafa163095261e7f066182f138c71f00259d7e428c5ee5a4e685a4320464aecd66aedde77a1f4c41cbb8431491999a39
+  data.tar.gz: f1fc3adfece35b9253e59be4beab12c5b2e1292c8330f287a386f37a71715d9cda922ca216a5219052e7097e1db13404b23c8118a10203fdbbf4024f37651e51

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+## [0.2.0] - 2026-05-28
+
+- Performance: pings are now dispatched asynchronously on a single daemon thread, so job workers no longer block on network I/O. A persistent, keep-alive HTTPS connection is reused for all pings (no more TCP/TLS handshake per ping).
+- Performance: switch to `Process.clock_gettime(CLOCK_MONOTONIC)` for duration measurement — no `Time` object allocation per job, and immune to wall-clock jumps.
+- Performance: lazy-load parsers, hooks, middleware, and the registry — only Rails boots that have JobTick enabled pay for them.
+- Performance: the monitor map is frozen after sync, and parser allocations are trimmed on the boot path.
+- Add `Configuration#queue_limit` (default 1000) to bound the background ping queue; over-limit pings are dropped non-blockingly rather than back-pressuring the job thread.
+
+### Measured impact
+
+Benchmarked with `spec/benchmarks/monitor_bench.rb` (10,000 iterations, WebMock-stubbed endpoint so the numbers reflect gem-internal overhead, not real network latency):
+
+| Metric (per monitored job) | v0.1.4 | v0.2.0 | Change |
+|---|---:|---:|---:|
+| Job-thread blocking time | 400.6 µs | 2.0 µs | **~200× faster** |
+| Object allocations on job thread | 2,390 | 9 | **~265× fewer** |
+| End-to-end CPU time (incl. background dispatch) | 400.6 µs | 18.1 µs | **~22× less CPU** |
+
+In production, where each ping pays real network RTT, the job-thread speedup is significantly larger: a single 20 ms RTT × 2–3 pings per job is ~50 ms blocking under v0.1.4, versus ~2 µs under v0.2.0 (~25,000× on the worker thread). Run `bundle exec ruby spec/benchmarks/monitor_bench.rb [iterations]` to reproduce.
+
 ## [0.1.4] - 2026-05-05
 
 - Add `prune` configuration option — when enabled, monitors absent from the latest sync payload are permanently deleted, keeping the dashboard in sync with your schedule config

data/README.md

@@ -58,6 +58,38 @@ That's it. On next deploy, JobTick reads your schedule config, registers a monit
 
 No changes to individual job files. No manual monitor creation. No names to keep in sync.
 
+### Environments
+
+**JobTick is only active in production by default.** In `development`, `staging`, or any other environment it silently does nothing — no pings are sent, no monitors are registered, no errors are raised. This means you can deploy the gem and configure it without worrying about local runs polluting your monitors or counting toward your plan.
+
+If you want to enable JobTick in a non-production environment (e.g. to test your setup on staging before going live), opt in explicitly:
+
+```ruby
+# config/initializers/jobtick.rb
+
+# Enable on staging only
+JobTick.configure do |config|
+  config.api_key  = ENV['JOBTICK_API_KEY']
+  config.enabled  = Rails.env.production? || Rails.env.staging?
+end
+```
+
+```ruby
+# Enable everywhere — useful for a quick local smoke-test
+JobTick.configure do |config|
+  config.api_key  = ENV['JOBTICK_API_KEY']
+  config.enabled  = true
+end
+```
+
+```ruby
+# Drive it from an env var so you can toggle without a deploy
+JobTick.configure do |config|
+  config.api_key  = ENV['JOBTICK_API_KEY']
+  config.enabled  = ENV['JOBTICK_ENABLED'] == 'true'
+end
+```
+
 ### Removing stale monitors automatically
 
 By default, monitors are only added — nothing is removed when you delete a job from your schedule. To have each deploy also clean up monitors that are no longer in your config, enable pruning:

data/lib/jobtick/client.rb

@@ -1,53 +1,32 @@
 # frozen_string_literal: true
 
-require "net/http"
-require "json"
-require "uri"
+require_relative "dispatcher"
 
 module JobTick
   class Client
-    TIMEOUT = 5
+    PING_PREFIX = "/ping/"
+    SYNC_PATH   = "/monitors/sync"
 
     def ping(monitor_key, status:, duration: nil, message: nil)
-      return unless JobTick.config.enabled
-      return if JobTick.config.api_key.nil?
+      config = JobTick.config
+      return unless config.enabled && !config.api_key.nil?
 
       payload = { status: status }
       payload[:duration] = duration.round(3) if duration
       payload[:message]  = message           if message
 
-      post("/ping/#{monitor_key}", payload)
+      Dispatcher.enqueue("#{PING_PREFIX}#{monitor_key}", payload)
     end
 
     def register(monitors, app_name: nil, prune: false)
-      return unless JobTick.config.enabled
-      return if JobTick.config.api_key.nil?
+      config = JobTick.config
+      return unless config.enabled && !config.api_key.nil?
 
       payload = { monitors: monitors }
       payload[:app_name] = app_name if app_name && !app_name.empty?
       payload[:prune]    = true if prune
-      post("/monitors/sync", payload)
-    end
 
-    private
-
-    def post(path, body)
-      uri  = URI("#{JobTick.config.endpoint}#{path}")
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl      = uri.scheme == "https"
-      http.open_timeout = TIMEOUT
-      http.read_timeout = TIMEOUT
-
-      request = Net::HTTP::Post.new(uri)
-      request["Content-Type"]  = "application/json"
-      request["Authorization"] = "Bearer #{JobTick.config.api_key}"
-      request["User-Agent"]    = "jobtick-ruby/#{JobTick::VERSION}"
-      request.body             = body.to_json
-
-      http.request(request)
-    rescue StandardError => e
-      JobTick.logger.warn("[JobTick] HTTP request failed (#{path}): #{e.message}")
-      nil
+      Dispatcher.send_sync(SYNC_PATH, payload)
     end
   end
 end

data/lib/jobtick/configuration.rb

@@ -2,13 +2,20 @@
 
 module JobTick
   class Configuration
-    attr_accessor :api_key, :endpoint, :environment, :enabled, :prune
+    DEFAULT_QUEUE_LIMIT = 1000
+
+    attr_accessor :api_key, :endpoint, :environment, :enabled, :prune, :queue_limit
 
     def initialize
       @endpoint    = "https://api.jobtick.app/v1"
       @environment = ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "production"
       @enabled     = @environment == "production"
       @prune       = false
+      @queue_limit = DEFAULT_QUEUE_LIMIT
+    end
+
+    def enabled?
+      @enabled && !@api_key.nil?
     end
   end
 end

data/lib/jobtick/dispatcher.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+require "openssl"
+
+module JobTick
+  # Asynchronous, single-threaded HTTP dispatcher with a persistent keep-alive
+  # connection. Job threads call .enqueue and return immediately; the dispatcher
+  # daemon thread drains the queue and posts to the JobTick API.
+  #
+  # All HTTP work (sync register + async pings) shares one Net::HTTP instance
+  # serialized by @http_mutex. The connection is reopened lazily after errors.
+  module Dispatcher
+    SHUTDOWN_SIGNAL = :__shutdown__
+    HEADER_CONTENT_TYPE = "application/json"
+    USER_AGENT = "jobtick-ruby/#{JobTick::VERSION}".freeze
+    OPEN_TIMEOUT = 5
+    READ_TIMEOUT = 5
+    KEEP_ALIVE_TIMEOUT = 30
+
+    NETWORK_ERRORS = [
+      IOError, EOFError,
+      Errno::ECONNRESET, Errno::ECONNREFUSED, Errno::ECONNABORTED,
+      Errno::EPIPE, Errno::ETIMEDOUT, Errno::EHOSTUNREACH,
+      Net::OpenTimeout, Net::ReadTimeout,
+      OpenSSL::SSL::SSLError, SocketError
+    ].freeze
+
+    class << self
+      attr_accessor :synchronous
+
+      def enqueue(path, payload)
+        return send_request(path, payload) if @synchronous
+
+        ensure_started
+        @queue.push([path, payload], true)
+        nil
+      rescue ThreadError
+        @dropped += 1
+        nil
+      end
+
+      def send_sync(path, payload)
+        send_request(path, payload)
+      end
+
+      def flush(timeout: 5)
+        return unless @running && @queue
+
+        deadline = monotonic + timeout
+        until @queue.empty? && @inflight.zero?
+          sleep 0.001
+          break if monotonic > deadline
+        end
+      end
+
+      def shutdown(timeout: 2)
+        return unless @running
+
+        @running = false
+        @queue&.push(SHUTDOWN_SIGNAL)
+        @thread&.join(timeout)
+        close_http
+        nil
+      end
+
+      def dropped
+        @dropped || 0
+      end
+
+      def reset!
+        shutdown(timeout: 1) if @running
+        @queue = nil
+        @thread = nil
+        @dropped = 0
+        @inflight = 0
+        @endpoint_uri = nil
+        @at_exit_registered = false
+        @synchronous = false
+      end
+
+      private
+
+      def ensure_started
+        return if @running
+
+        boot_mutex.synchronize do
+          return if @running
+
+          @queue   = SizedQueue.new(queue_limit)
+          @dropped = 0
+          @inflight = 0
+          @thread = Thread.new { run_loop }
+          @thread.name = "jobtick-dispatcher" if @thread.respond_to?(:name=)
+          @running = true
+          register_at_exit
+        end
+      end
+
+      def boot_mutex
+        @boot_mutex ||= Mutex.new
+      end
+
+      def http_mutex
+        @http_mutex ||= Mutex.new
+      end
+
+      def queue_limit
+        JobTick.config.queue_limit || Configuration::DEFAULT_QUEUE_LIMIT
+      end
+
+      def register_at_exit
+        return if @at_exit_registered
+
+        @at_exit_registered = true
+        at_exit { shutdown }
+      end
+
+      def run_loop
+        while (item = @queue.pop)
+          break if item == SHUTDOWN_SIGNAL
+
+          @inflight = 1
+          path, payload = item
+          send_request(path, payload)
+          @inflight = 0
+        end
+      rescue StandardError => e
+        JobTick.logger.warn("[JobTick] Dispatcher thread crashed: #{e.message}")
+      ensure
+        close_http
+      end
+
+      def send_request(path, payload)
+        body = JSON.generate(payload)
+        full_path = "#{endpoint_uri.path}#{path}"
+        http_mutex.synchronize do
+          http = http_connection
+          request = Net::HTTP::Post.new(full_path)
+          request["Content-Type"]  = HEADER_CONTENT_TYPE
+          request["Authorization"] = "Bearer #{JobTick.config.api_key}"
+          request["User-Agent"]    = USER_AGENT
+          request.body = body
+          http.request(request)
+        end
+      rescue *NETWORK_ERRORS => e
+        JobTick.logger.warn("[JobTick] HTTP request failed (#{path}): #{e.message}")
+        teardown_http
+        nil
+      rescue StandardError => e
+        JobTick.logger.warn("[JobTick] HTTP request failed (#{path}): #{e.message}")
+        nil
+      end
+
+      def endpoint_uri
+        @endpoint_uri ||= URI(JobTick.config.endpoint)
+      end
+
+      def http_connection
+        return @http if @http&.started?
+
+        uri = endpoint_uri
+        @http = Net::HTTP.new(uri.host, uri.port)
+        @http.use_ssl            = uri.scheme == "https"
+        @http.open_timeout       = OPEN_TIMEOUT
+        @http.read_timeout       = READ_TIMEOUT
+        @http.keep_alive_timeout = KEEP_ALIVE_TIMEOUT
+        @http.start
+        @http
+      end
+
+      def teardown_http
+        return unless @http
+
+        @http.finish if @http.started?
+      rescue StandardError
+        nil
+      ensure
+        @http = nil
+      end
+
+      def close_http
+        http_mutex.synchronize { teardown_http }
+      end
+
+      def monotonic
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end

data/lib/jobtick/hooks/active_job.rb

@@ -5,7 +5,7 @@ module JobTick
     module ActiveJob
       def self.included(base)
         base.around_perform do |job, block|
-          key = JobTick.monitor_key_for(job.class.name)
+          key = JobTick.monitor_map[job.class.name]
           next block.call unless key
 
           JobTick::Monitor.run(key) { block.call }

data/lib/jobtick/middleware/sidekiq.rb

@@ -7,7 +7,7 @@ module JobTick
         # Active Job wrappers are handled by the around_perform hook
         return yield if job["wrapped"]
 
-        key = JobTick.monitor_key_for(job["class"])
+        key = JobTick.monitor_map[job["class"]]
         return yield unless key
 
         JobTick::Monitor.run(key, &)

data/lib/jobtick/monitor.rb

@@ -2,14 +2,18 @@
 
 module JobTick
   class Monitor
+    MONOTONIC = Process::CLOCK_MONOTONIC
+
     def self.run(key)
-      return yield unless JobTick.config.enabled
+      config = JobTick.config
+      return yield unless config.enabled && !config.api_key.nil?
 
-      started_at = Time.now
-      JobTick.client.ping(key, status: :started)
-      result   = yield
-      duration = Time.now - started_at
-      JobTick.client.ping(key, status: :completed, duration: duration)
+      client = JobTick.client
+      client.ping(key, status: :started)
+      started = Process.clock_gettime(MONOTONIC)
+      result  = yield
+      duration = Process.clock_gettime(MONOTONIC) - started
+      client.ping(key, status: :completed, duration: duration)
       result
     rescue StandardError => e
       JobTick.client.ping(key, status: :failed, message: e.message)

data/lib/jobtick/parsers/sidekiq.rb

@@ -2,8 +2,11 @@
 
 module JobTick
   module Parsers
+    SLUG_RE = /[^a-z0-9]+/
+    SLUG_TRIM_RE = /\A_+|_+\z/
+
     def self.slugify(str)
-      str.downcase.gsub(/[^a-z0-9]+/, "_").gsub(/\A_+|_+\z/, "")
+      str.downcase.gsub(SLUG_RE, "_").gsub(SLUG_TRIM_RE, "")
     end
 
     class Sidekiq

data/lib/jobtick/parsers/solid_queue.rb

@@ -16,16 +16,16 @@ module JobTick
         tasks = yaml[env] || yaml["default"] || yaml
         return [] unless tasks.is_a?(Hash)
 
-        tasks.map do |key, config|
+        tasks.each_with_object([]) do |(key, config), out|
           next unless config.is_a?(Hash)
 
-          {
+          out << {
             key: "solid_queue.#{key}",
             schedule: config["schedule"],
             source: "solid_queue",
             task: config["class"]
           }
-        end.compact
+        end
       rescue StandardError => e
         JobTick.logger.warn("[JobTick] Solid Queue parser failed: #{e.message}")
         []

data/lib/jobtick/railtie.rb

@@ -6,6 +6,13 @@ module JobTick
       ActiveSupport.on_load(:after_initialize) do
         next unless JobTick.config.enabled
 
+        require_relative "parsers/whenever"
+        require_relative "parsers/solid_queue"
+        require_relative "parsers/sidekiq"
+        require_relative "registry"
+        require_relative "hooks/active_job"
+        require_relative "middleware/sidekiq"
+
         JobTick::Registry.sync
 
         ::ActiveJob::Base.include(JobTick::Hooks::ActiveJob) if defined?(::ActiveJob::Base)

data/lib/jobtick/registry.rb

@@ -9,9 +9,9 @@ module JobTick
         Parsers::Sidekiq.parse
       ].flatten.compact
 
-      JobTick.monitor_map = monitors.each_with_object({}) do |m, map|
-        map[m[:task]] = m[:key] if m[:task]
-      end
+      map = {}
+      monitors.each { |m| map[m[:task]] = m[:key] if m[:task] }
+      JobTick.monitor_map = map.freeze
 
       return [] if monitors.empty?
 

data/lib/jobtick/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JobTick
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end

data/lib/jobtick.rb

@@ -5,15 +5,11 @@ require_relative "jobtick/version"
 require_relative "jobtick/configuration"
 require_relative "jobtick/client"
 require_relative "jobtick/monitor"
-require_relative "jobtick/parsers/whenever"
-require_relative "jobtick/parsers/solid_queue"
-require_relative "jobtick/parsers/sidekiq"
-require_relative "jobtick/registry"
-require_relative "jobtick/hooks/active_job"
-require_relative "jobtick/middleware/sidekiq"
 require_relative "jobtick/railtie" if defined?(Rails::Railtie)
 
 module JobTick
+  EMPTY_MAP = {}.freeze
+
   class Error < StandardError; end
 
   class << self
@@ -34,7 +30,7 @@ module JobTick
     end
 
     def monitor_map
-      @monitor_map ||= {}
+      @monitor_map ||= EMPTY_MAP
     end
 
     attr_writer :monitor_map
@@ -44,9 +40,10 @@ module JobTick
     end
 
     def reset!
+      Dispatcher.reset! if defined?(Dispatcher)
       @config = nil
       @client = nil
-      @monitor_map = {}
+      @monitor_map = EMPTY_MAP
     end
   end
 end

data/lib/tasks/jobtick.rake

@@ -3,6 +3,11 @@
 namespace :jobtick do
   desc "Sync discovered jobs with jobtick.app"
   task sync: :environment do
+    require "jobtick/parsers/whenever"
+    require "jobtick/parsers/solid_queue"
+    require "jobtick/parsers/sidekiq"
+    require "jobtick/registry"
+
     monitors = JobTick::Registry.sync
     count    = monitors&.length || 0
     puts "[JobTick] Synced #{count} monitor(s)"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jobtick
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Clearstack Labs
@@ -38,6 +38,7 @@ files:
 - lib/jobtick.rb
 - lib/jobtick/client.rb
 - lib/jobtick/configuration.rb
+- lib/jobtick/dispatcher.rb
 - lib/jobtick/hooks/active_job.rb
 - lib/jobtick/middleware/sidekiq.rb
 - lib/jobtick/monitor.rb