Class: Wurk::JobRetry

Inherits:
Object
  • Object
show all
Includes:
Component
Defined in:
lib/wurk/job_retry.rb

Overview

Owns the retry pipeline. When perform raises, JobRetry decides whether to reschedule (retry ZSET, exponential backoff + jitter), drop, kill, or send to the morgue. Wire-compat sacred: error_message / error_class / retry_count / failed_at / retried_at / error_backtrace field names and encodings (base64 of zlib of JSON for the backtrace) match Sidekiq byte for byte — third-party gems and the dashboard read them directly.

Two entry points wrap the dispatch onion in Processor#dispatch:

* `global(jobstr, queue)` — outermost, no job instance required.
Rescues `Exception` so pre-instantiation failures (const_get, reloader)
still get a retry recorded. Re-raises `Handled` so the processor
skips ACK logging.
* `local(jobinst, jobstr, queue)` — inner, runs after the worker is
instantiated. Honors per-class `sidekiq_retry_in_block` /
`sidekiq_retries_exhausted_block` (and the wrapped-class variants).
Raises `Handled` after booking the retry so `global` does not double-
process the failure.

Spec: docs/target/sidekiq-free.md §17.

Defined Under Namespace

Classes: Handled, Skip

Constant Summary collapse

DEFAULT_MAX_RETRY_ATTEMPTS = 
25

Constants included from Component

Component::DEFAULT_THREAD_PRIORITY, Component::PROCESS_NONCE

Instance Attribute Summary

Attributes included from Component

#config

Instance Method Summary collapse

Methods included from Component

#default_tag, #fire_event, #hostname, #identity, #leader?, #logger, #mono_ms, #process_nonce, #real_ms, #redis, #safe_thread, #tid, #watchdog

Constructor Details

#initialize(capsule) ⇒ JobRetry

Returns a new instance of JobRetry.



40
41
42
43
44
45
 
# File 'lib/wurk/job_retry.rb', line 40

def initialize(capsule)
  @capsule = capsule
  @config = capsule
  @max_retries = inner_config_get(:max_retries) || DEFAULT_MAX_RETRY_ATTEMPTS
  @backtrace_cleaner = inner_config_get(:backtrace_cleaner)
end

Instance Method Details

#global(jobstr, queue) ⇒ Object

Outermost retry guard. Rescues Exception so const_get / reloader failures still get a retry. Handled is re-raised intact; Shutdown bubbles up so the swarm can drain.



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/wurk/job_retry.rb', line 50

def global(jobstr, queue)
  yield
rescue Handled, Wurk::Shutdown
  raise
rescue Exception => e # rubocop:disable Lint/RescueException
  raise Wurk::Shutdown if exception_caused_by_shutdown?(e)

  msg = Wurk.load_json(jobstr)
  if msg['retry']
    process_retry(nil, msg, queue, e)
  else
    run_death_handlers(msg, e)
  end

  raise Handled
end

#handle_exception(ex, ctx = {}) ⇒ Object

Component's handle_exception delegates to config.handle_exception. When initialized with a Capsule, that's not defined directly; route through the underlying Configuration.



90
91
92
 
# File 'lib/wurk/job_retry.rb', line 90

def handle_exception(ex, ctx = {})
  inner_config.handle_exception(ex, ctx)
end

#local(jobinst, jobstr, queue) ⇒ Object

Per-job retry guard. Same rescue semantics as global but the worker instance is in hand, so per-class sidekiq_retry_in_block and sidekiq_retries_exhausted_block can run. Raises Handled to short- circuit global's rescue.



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/wurk/job_retry.rb', line 71

def local(jobinst, jobstr, queue)
  yield
rescue Handled, Wurk::Shutdown
  raise
rescue Exception => e # rubocop:disable Lint/RescueException
  raise Wurk::Shutdown if exception_caused_by_shutdown?(e)

  msg = Wurk.load_json(jobstr)
  msg['retry'] = jobinst.class.get_sidekiq_options['retry'] if msg['retry'].nil?

  raise e unless msg['retry']

  process_retry(jobinst, msg, queue, e)
  raise Handled
end