jobtick 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9fbf13c9887fe65ec082ad5a3515ec3d2767330318e9fbeafca2731f6ea7e1f3
-  data.tar.gz: 7c1624eaa666bdec4318d087f7d4bd264f6abbe03091ad9746d88a001f2e1bf2
+  metadata.gz: abfce9cfddae0a798d132217b9376b130afe9446f85e279d3241e7016ed1a89f
+  data.tar.gz: 36590511cdf6e5b07541cdb66589fc5efd7f2250aeb4d5e5e4b20a18976642de
 SHA512:
-  metadata.gz: 7b1b71c36e97bd70144c69118d7af1af461424529fc92bfa7926bc2289fcecd65e92ad7ac49652dcd413244e4258dbdf9087424dd44ee5b392909fb4be771f8d
-  data.tar.gz: 7f32abaf56da135c05d76dd5f1b77043d29bf6f99c919059b138367a1e21abd06460eaa5496f42655026e23f17f740b044e6c46f249849cf27fde2f9c46deea5
+  metadata.gz: a81d1bf56a1e48ed5395bd5d913b8f49aafa163095261e7f066182f138c71f00259d7e428c5ee5a4e685a4320464aecd66aedde77a1f4c41cbb8431491999a39
+  data.tar.gz: f1fc3adfece35b9253e59be4beab12c5b2e1292c8330f287a386f37a71715d9cda922ca216a5219052e7097e1db13404b23c8118a10203fdbbf4024f37651e51

data/CHANGELOG.md

@@ -1,4 +1,40 @@
-## [Unreleased]
+## [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
+- Remove stale `.gem` build artifact from repository
+
+## [0.1.3] - 2026-05-05
+
+- Add `JobTick::WheneverSetup.install!(self)` — one-line setup that overrides Whenever's built-in `runner`, `rake`, and `command` job types to send heartbeat pings automatically, with no per-job changes required
+- Extract shared `Parsers.slugify` helper, remove redundant `.to_s` calls, unify guard style
+
+## [0.1.2] - 2026-04-30
+
+- Add automatic ping instrumentation for Solid Queue (via `ActiveJob::Base` `around_perform` hook) and Sidekiq (via server middleware)
+
+## [0.1.1] - 2026-04-28
+
+- Send `app_name` on monitor sync
 
 ## [0.1.0] - 2026-04-27
 

data/README.md

@@ -1,5 +1,6 @@
 # JobTick
 
+[![Gem Version](https://badge.fury.io/rb/jobtick.svg)](https://rubygems.org/gems/jobtick)
 [![Ruby](https://github.com/clearstack-labs/jobtick/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/clearstack-labs/jobtick/actions/workflows/main.yml)
 
 **Rails job monitoring for Whenever, Solid Queue, and Sidekiq.**
@@ -57,6 +58,51 @@ 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:
+
+```ruby
+JobTick.configure do |config|
+  config.api_key = ENV['JOBTICK_API_KEY']
+  config.prune   = true   # remove monitors absent from the latest sync
+end
+```
+
+With `prune` enabled, a deploy acts as the single source of truth: any monitor whose key is not present in the current payload is permanently deleted. You can also remove individual monitors manually from the JobTick dashboard at any time.
+
 ---
 
 ## What gets monitored
@@ -97,25 +143,34 @@ JobTick installs a server middleware that wraps every job execution. For native
 
 ### Whenever (`config/schedule.rb`)
 
-Whenever schedules jobs as cron shell commands, so there is no Ruby hook point to instrument automatically. One setup step is required: run the generator and update your `config/schedule.rb` to use the `jobtick_runner` and `jobtick_rake` job types instead of the built-in `runner` and `rake`:
+Whenever schedules jobs as cron shell commands, so there is no Ruby hook point to instrument automatically. Add one line to `config/schedule.rb`:
 
-```
-bundle exec rake jobtick:whenever:setup
+```ruby
+JobTick::WheneverSetup.install!(self)
 ```
 
-This prints the two `job_type` definitions to add to the top of your schedule file, then use them in place of the standard types:
+This overrides the built-in `runner`, `rake`, and `command` job types to wrap every execution with `curl` pings. Your existing schedule entries need no changes:
 
 ```ruby
+JobTick::WheneverSetup.install!(self)
+
 every 1.day, at: '2:00 am' do
-  jobtick_runner 'InvoiceJob.perform_later', monitor_key: 'whenever.invoice_job'
+  runner 'InvoiceJob.perform_later'
 end
 
 every :hour do
-  jobtick_rake 'reports:sync', monitor_key: 'whenever.reports_sync'
+  rake 'reports:sync'
 end
 ```
 
-The job types wrap execution with `curl` pings to the JobTick API, so no changes to individual job classes are needed.
+After adding the line, run `whenever --update-crontab` as normal and all jobs will start sending heartbeats.
+
+If jobtick is not already loaded via your Rails environment, require it first:
+
+```ruby
+require 'jobtick/whenever_setup'
+JobTick::WheneverSetup.install!(self)
+```
 
 ---
 
@@ -123,7 +178,7 @@ The job types wrap execution with `curl` pings to the JobTick API, so no changes
 
 **Silent failure detection** — alerts when a job stops running entirely, not just when it raises an exception. The failure mode your error monitor misses.
 
-**Auto-sync on deploy** — add a job to your schedule, it appears in your dashboard at next deploy. Remove a job, its monitor is automatically retired.
+**Auto-sync on deploy** — add a job to your schedule, it appears in your dashboard at next deploy. Enable `config.prune = true` to automatically retire monitors when jobs are removed from your schedule.
 
 **Run history** — see every execution: start time, duration, exit status. Spot when a job starts getting slower before it becomes a problem.
 
@@ -137,17 +192,16 @@ The job types wrap execution with `curl` pings to the JobTick API, so no changes
 
 - Ruby >= 3.3
 - Rails >= 7.0
-- One or more of: Whenever, Solid Queue, Sidekiq
-
----
+- One or more of:
 
-## Status
+| Adapter | Supported versions |
+|---|---|
+| Solid Queue | >= 0.1 |
+| Sidekiq | >= 6 |
+| sidekiq-cron | >= 1.0 |
+| Whenever | >= 0.10 |
 
-> **JobTick is currently in development.**
-> Sign up for early access at [jobtick.app](https://jobtick.app).
-> Launching June 2026.
-
-If you want to follow along or give early feedback, open an issue or watch the repo.
+---
 
 ---
 

data/lib/jobtick/client.rb

@@ -1,52 +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)
-      return unless JobTick.config.enabled
-      return if JobTick.config.api_key.nil?
+    def register(monitors, app_name: nil, prune: false)
+      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?
-      post("/monitors/sync", payload)
-    end
+      payload[:prune]    = true if prune
 
-    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,12 +2,20 @@
 
 module JobTick
   class Configuration
-    attr_accessor :api_key, :endpoint, :environment, :enabled
+    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,14 +9,16 @@ 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?
 
       app_name = Rails.application.class.module_parent_name if defined?(Rails)
-      JobTick.client.register(monitors, app_name: app_name)
+      options  = { app_name: app_name }
+      options[:prune] = true if JobTick.config.prune
+      JobTick.client.register(monitors, **options)
       monitors
     end
   end

data/lib/jobtick/version.rb

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

data/lib/jobtick/whenever_setup.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "jobtick"
+
+module JobTick
+  # Overrides Whenever's built-in job types to wrap execution with jobtick pings.
+  #
+  # Usage — add one line to config/schedule.rb:
+  #
+  #   JobTick::WheneverSetup.install!(self)
+  #
+  # This replaces the :runner, :rake, and :command job types so that every
+  # scheduled job automatically sends started/completed/failed heartbeats without
+  # any per-job configuration.
+  module WheneverSetup
+    def self.install!(schedule)
+      endpoint = JobTick.config.endpoint
+
+      schedule.job_type :runner,  wrap(endpoint, "cd :path && bundle exec rails runner ':task' :output")
+      schedule.job_type :rake,    wrap(endpoint, "cd :path && bundle exec rake :task :output")
+      schedule.job_type :command, wrap(endpoint, "cd :path && :task :output")
+    end
+
+    def self.wrap(endpoint, inner_cmd)
+      # Shell equivalent of Parsers.slugify: downcase, collapse non-alnum runs to _, strip leading/trailing _.
+      sed = "sed 's/[^a-z0-9][^a-z0-9]*/_/g' | sed 's/^_*//;s/_*$//'"
+      slug = "$(printf '%s' ':task' | tr '[:upper:]' '[:lower:]' | #{sed})"
+      key_assign = %(JOBTICK_KEY="whenever.#{slug}")
+
+      "#{key_assign} ; " \
+        "curl -sf \"#{endpoint}/ping/$JOBTICK_KEY/started\" ; " \
+        "#{inner_cmd} && " \
+        "curl -sf \"#{endpoint}/ping/$JOBTICK_KEY/completed\" || " \
+        "curl -sf \"#{endpoint}/ping/$JOBTICK_KEY/failed\""
+    end
+    private_class_method :wrap
+  end
+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,32 +3,31 @@
 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)"
   end
 
   namespace :whenever do
-    desc "Print Whenever job_type wrappers to add to config/schedule.rb for heartbeat injection"
+    desc "Print the line to add to config/schedule.rb to enable JobTick heartbeat injection"
     task :setup do
-      endpoint = JobTick.config.endpoint
       puts <<~RUBY
-        # Add to config/schedule.rb to enable JobTick heartbeat injection for Whenever jobs:
-
-        job_type :jobtick_runner, %(curl -sf "#{endpoint}/ping/:monitor_key/started" ; ) \\
-                                  %(bundle exec rails runner ':task' :output && ) \\
-                                  %(curl -sf "#{endpoint}/ping/:monitor_key/completed" || ) \\
-                                  %(curl -sf "#{endpoint}/ping/:monitor_key/failed")
+        # Add to config/schedule.rb to enable JobTick heartbeat injection for all Whenever jobs:
 
-        job_type :jobtick_rake,   %(curl -sf "#{endpoint}/ping/:monitor_key/started" ; ) \\
-                                  %(bundle exec rake :task :output && ) \\
-                                  %(curl -sf "#{endpoint}/ping/:monitor_key/completed" || ) \\
-                                  %(curl -sf "#{endpoint}/ping/:monitor_key/failed")
+        JobTick::WheneverSetup.install!(self)
 
-        # Then use jobtick_runner / jobtick_rake instead of runner / rake, e.g.:
-        # every 1.hour do
-        #   jobtick_runner "InvoiceJob.perform_later", monitor_key: "invoice_job"
-        # end
+        # This overrides the built-in runner, rake, and command job types so that
+        # every scheduled job automatically sends started/completed/failed heartbeats.
+        # No per-job changes are required.
+        #
+        # If jobtick is not already loaded via your Rails environment, add:
+        #   require "jobtick/whenever_setup"
+        # before the install! call.
       RUBY
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jobtick
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Clearstack Labs
@@ -35,10 +35,10 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- jobtick-0.0.1.gem
 - 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
@@ -48,6 +48,7 @@ files:
 - lib/jobtick/railtie.rb
 - lib/jobtick/registry.rb
 - lib/jobtick/version.rb
+- lib/jobtick/whenever_setup.rb
 - lib/tasks/jobtick.rake
 - sig/jobtick.rbs
 homepage: https://jobtick.app