sidekiq 6.5.9 → 7.0.0.beta1

Sign up to get free protection for your applications and to get access to all the features.

Potentially problematic release.


This version of sidekiq might be problematic. Click here for more details.

Files changed (92) hide show
  1. checksums.yaml +4 -4
  2. data/Changes.md +5 -13
  3. data/README.md +13 -12
  4. data/bin/sidekiq +3 -8
  5. data/bin/sidekiqload +14 -23
  6. data/lib/sidekiq/api.rb +51 -127
  7. data/lib/sidekiq/capsule.rb +110 -0
  8. data/lib/sidekiq/cli.rb +44 -59
  9. data/lib/sidekiq/client.rb +30 -17
  10. data/lib/sidekiq/component.rb +1 -0
  11. data/lib/sidekiq/config.rb +270 -0
  12. data/lib/sidekiq/deploy.rb +62 -0
  13. data/lib/sidekiq/embedded.rb +61 -0
  14. data/lib/sidekiq/fetch.rb +10 -11
  15. data/lib/sidekiq/job.rb +375 -10
  16. data/lib/sidekiq/job_logger.rb +1 -1
  17. data/lib/sidekiq/job_retry.rb +8 -8
  18. data/lib/sidekiq/job_util.rb +4 -4
  19. data/lib/sidekiq/launcher.rb +36 -46
  20. data/lib/sidekiq/logger.rb +1 -26
  21. data/lib/sidekiq/manager.rb +9 -11
  22. data/lib/sidekiq/metrics/query.rb +3 -3
  23. data/lib/sidekiq/metrics/shared.rb +4 -3
  24. data/lib/sidekiq/metrics/tracking.rb +18 -18
  25. data/lib/sidekiq/middleware/chain.rb +7 -9
  26. data/lib/sidekiq/middleware/current_attributes.rb +3 -8
  27. data/lib/sidekiq/monitor.rb +1 -1
  28. data/lib/sidekiq/paginator.rb +1 -9
  29. data/lib/sidekiq/pool.rb +7 -0
  30. data/lib/sidekiq/processor.rb +17 -26
  31. data/lib/sidekiq/redis_client_adapter.rb +9 -45
  32. data/lib/sidekiq/redis_connection.rb +11 -111
  33. data/lib/sidekiq/scheduled.rb +19 -20
  34. data/lib/sidekiq/testing.rb +4 -32
  35. data/lib/sidekiq/transaction_aware_client.rb +4 -5
  36. data/lib/sidekiq/version.rb +1 -1
  37. data/lib/sidekiq/web/application.rb +1 -4
  38. data/lib/sidekiq/web/csrf_protection.rb +1 -1
  39. data/lib/sidekiq/web/helpers.rb +21 -22
  40. data/lib/sidekiq/web.rb +2 -17
  41. data/lib/sidekiq/worker_compatibility_alias.rb +13 -0
  42. data/lib/sidekiq.rb +52 -274
  43. data/sidekiq.gemspec +29 -5
  44. data/web/assets/javascripts/base-charts.js +106 -0
  45. data/web/assets/javascripts/dashboard-charts.js +166 -0
  46. data/web/assets/javascripts/dashboard.js +3 -223
  47. data/web/assets/javascripts/metrics.js +90 -116
  48. data/web/assets/stylesheets/application-rtl.css +2 -91
  49. data/web/assets/stylesheets/application.css +21 -296
  50. data/web/locales/ar.yml +70 -70
  51. data/web/locales/cs.yml +62 -62
  52. data/web/locales/da.yml +52 -52
  53. data/web/locales/de.yml +65 -65
  54. data/web/locales/el.yml +2 -7
  55. data/web/locales/en.yml +76 -70
  56. data/web/locales/es.yml +68 -68
  57. data/web/locales/fa.yml +65 -65
  58. data/web/locales/fr.yml +67 -67
  59. data/web/locales/he.yml +65 -64
  60. data/web/locales/hi.yml +59 -59
  61. data/web/locales/it.yml +53 -53
  62. data/web/locales/ja.yml +64 -68
  63. data/web/locales/ko.yml +52 -52
  64. data/web/locales/lt.yml +66 -66
  65. data/web/locales/nb.yml +61 -61
  66. data/web/locales/nl.yml +52 -52
  67. data/web/locales/pl.yml +45 -45
  68. data/web/locales/pt-br.yml +59 -69
  69. data/web/locales/pt.yml +51 -51
  70. data/web/locales/ru.yml +67 -66
  71. data/web/locales/sv.yml +53 -53
  72. data/web/locales/ta.yml +60 -60
  73. data/web/locales/uk.yml +62 -61
  74. data/web/locales/ur.yml +64 -64
  75. data/web/locales/vi.yml +67 -67
  76. data/web/locales/zh-cn.yml +1 -0
  77. data/web/locales/zh-tw.yml +10 -1
  78. data/web/views/_footer.erb +5 -2
  79. data/web/views/busy.erb +1 -6
  80. data/web/views/dashboard.erb +36 -5
  81. data/web/views/metrics.erb +30 -19
  82. data/web/views/metrics_for_job.erb +16 -34
  83. metadata +60 -37
  84. data/lib/sidekiq/delay.rb +0 -43
  85. data/lib/sidekiq/extensions/action_mailer.rb +0 -48
  86. data/lib/sidekiq/extensions/active_record.rb +0 -43
  87. data/lib/sidekiq/extensions/class_methods.rb +0 -43
  88. data/lib/sidekiq/extensions/generic_proxy.rb +0 -33
  89. data/lib/sidekiq/metrics/deploy.rb +0 -47
  90. data/lib/sidekiq/worker.rb +0 -370
  91. data/web/assets/javascripts/graph.js +0 -16
  92. /data/{LICENSE → LICENSE.txt} +0 -0
@@ -0,0 +1,61 @@
1
+ require "sidekiq/component"
2
+ require "sidekiq/launcher"
3
+ require "sidekiq/metrics/tracking"
4
+
5
+ module Sidekiq
6
+ class Embedded
7
+ include Sidekiq::Component
8
+
9
+ def initialize(config)
10
+ @config = config
11
+ end
12
+
13
+ def run
14
+ housekeeping
15
+ fire_event(:startup, reverse: false, reraise: true)
16
+ @launcher = Sidekiq::Launcher.new(@config, embedded: true)
17
+ @launcher.run
18
+ sleep 0.1 # pause to give threads time to spin up
19
+
20
+ logger.info "Embedded mode running with #{Thread.list.size} threads"
21
+ logger.debug { Thread.list.map(&:name) }
22
+ end
23
+
24
+ def quiet
25
+ @launcher&.quiet
26
+ end
27
+
28
+ def stop
29
+ @launcher&.stop
30
+ end
31
+
32
+ private
33
+
34
+ def housekeeping
35
+ logger.info "Running in #{RUBY_DESCRIPTION}"
36
+ logger.info Sidekiq::LICENSE
37
+ logger.info "Upgrade to Sidekiq Pro for more features and support: https://sidekiq.org" unless defined?(::Sidekiq::Pro)
38
+
39
+ # touch the connection pool so it is created before we
40
+ # fire startup and start multithreading.
41
+ info = config.redis_info
42
+ ver = Gem::Version.new(info["redis_version"])
43
+ raise "You are connecting to Redis #{ver}, Sidekiq requires Redis 6.2.0 or greater" if ver < Gem::Version.new("6.2.0")
44
+
45
+ maxmemory_policy = info["maxmemory_policy"]
46
+ if maxmemory_policy != "noeviction"
47
+ logger.warn <<~EOM
48
+
49
+
50
+ WARNING: Your Redis instance will evict Sidekiq data under heavy load.
51
+ The 'noeviction' maxmemory policy is recommended (current policy: '#{maxmemory_policy}').
52
+ See: https://github.com/mperham/sidekiq/wiki/Using-Redis#memory
53
+
54
+ EOM
55
+ end
56
+
57
+ logger.debug { "Client Middleware: #{@config.default_capsule.client_middleware.map(&:klass).join(", ")}" }
58
+ logger.debug { "Server Middleware: #{@config.default_capsule.server_middleware.map(&:klass).join(", ")}" }
59
+ end
60
+ end
61
+ end
data/lib/sidekiq/fetch.rb CHANGED
@@ -2,6 +2,7 @@
2
2
 
3
3
  require "sidekiq"
4
4
  require "sidekiq/component"
5
+ require "sidekiq/capsule"
5
6
 
6
7
  module Sidekiq # :nodoc:
7
8
  class BasicFetch
@@ -26,31 +27,30 @@ module Sidekiq # :nodoc:
26
27
  end
27
28
  }
28
29
 
29
- def initialize(config)
30
- raise ArgumentError, "missing queue list" unless config[:queues]
31
- @config = config
32
- @strictly_ordered_queues = !!@config[:strict]
33
- @queues = @config[:queues].map { |q| "queue:#{q}" }
30
+ def initialize(cap)
31
+ raise ArgumentError, "missing queue list" unless cap.queues
32
+ @config = cap
33
+ @strictly_ordered_queues = (config.queues.size == config.queues.uniq.size)
34
+ @queues = config.queues.map { |q| "queue:#{q}" }
34
35
  if @strictly_ordered_queues
35
36
  @queues.uniq!
36
- @queues << {timeout: TIMEOUT}
37
37
  end
38
38
  end
39
39
 
40
40
  def retrieve_work
41
41
  qs = queues_cmd
42
42
  # 4825 Sidekiq Pro with all queues paused will return an
43
- # empty set of queues with a trailing TIMEOUT value.
44
- if qs.size <= 1
43
+ # empty set of queues
44
+ if qs.size <= 0
45
45
  sleep(TIMEOUT)
46
46
  return nil
47
47
  end
48
48
 
49
- queue, job = redis { |conn| conn.brpop(*qs) }
49
+ queue, job = redis { |conn| conn.blocking_call(false, "brpop", *qs, TIMEOUT) }
50
50
  UnitOfWork.new(queue, job, config) if queue
51
51
  end
52
52
 
53
- def bulk_requeue(inprogress, options)
53
+ def bulk_requeue(inprogress, _)
54
54
  return if inprogress.empty?
55
55
 
56
56
  logger.debug { "Re-queueing terminated jobs" }
@@ -83,7 +83,6 @@ module Sidekiq # :nodoc:
83
83
  else
84
84
  permute = @queues.shuffle
85
85
  permute.uniq!
86
- permute << {timeout: TIMEOUT}
87
86
  permute
88
87
  end
89
88
  end
data/lib/sidekiq/job.rb CHANGED
@@ -1,13 +1,378 @@
1
- require "sidekiq/worker"
1
+ # frozen_string_literal: true
2
+
3
+ require "sidekiq/client"
2
4
 
3
5
  module Sidekiq
4
- # Sidekiq::Job is a new alias for Sidekiq::Worker as of Sidekiq 6.3.0.
5
- # Use `include Sidekiq::Job` rather than `include Sidekiq::Worker`.
6
- #
7
- # The term "worker" is too generic and overly confusing, used in several
8
- # different contexts meaning different things. Many people call a Sidekiq
9
- # process a "worker". Some people call the thread that executes jobs a
10
- # "worker". This change brings Sidekiq closer to ActiveJob where your job
11
- # classes extend ApplicationJob.
12
- Job = Worker
6
+ ##
7
+ # Include this module in your job class and you can easily create
8
+ # asynchronous jobs:
9
+ #
10
+ # class HardJob
11
+ # include Sidekiq::Job
12
+ # sidekiq_options queue: 'critical', retry: 5
13
+ #
14
+ # def perform(*args)
15
+ # # do some work
16
+ # end
17
+ # end
18
+ #
19
+ # Then in your Rails app, you can do this:
20
+ #
21
+ # HardJob.perform_async(1, 2, 3)
22
+ #
23
+ # Note that perform_async is a class method, perform is an instance method.
24
+ #
25
+ # Sidekiq::Job also includes several APIs to provide compatibility with
26
+ # ActiveJob.
27
+ #
28
+ # class SomeJob
29
+ # include Sidekiq::Job
30
+ # queue_as :critical
31
+ #
32
+ # def perform(...)
33
+ # end
34
+ # end
35
+ #
36
+ # SomeJob.set(wait_until: 1.hour).perform_async(123)
37
+ #
38
+ # Note that arguments passed to the job must still obey Sidekiq's
39
+ # best practice for simple, JSON-native data types. Sidekiq will not
40
+ # implement ActiveJob's more complex argument serialization. For
41
+ # this reason, we don't implement `perform_later` as our call semantics
42
+ # are very different.
43
+ #
44
+ module Job
45
+ ##
46
+ # The Options module is extracted so we can include it in ActiveJob::Base
47
+ # and allow native AJs to configure Sidekiq features/internals.
48
+ module Options
49
+ def self.included(base)
50
+ base.extend(ClassMethods)
51
+ base.sidekiq_class_attribute :sidekiq_options_hash
52
+ base.sidekiq_class_attribute :sidekiq_retry_in_block
53
+ base.sidekiq_class_attribute :sidekiq_retries_exhausted_block
54
+ end
55
+
56
+ module ClassMethods
57
+ ACCESSOR_MUTEX = Mutex.new
58
+
59
+ ##
60
+ # Allows customization for this type of Job.
61
+ # Legal options:
62
+ #
63
+ # queue - name of queue to use for this job type, default *default*
64
+ # retry - enable retries for this Job in case of error during execution,
65
+ # *true* to use the default or *Integer* count
66
+ # backtrace - whether to save any error backtrace in the retry payload to display in web UI,
67
+ # can be true, false or an integer number of lines to save, default *false*
68
+ #
69
+ # In practice, any option is allowed. This is the main mechanism to configure the
70
+ # options for a specific job.
71
+ def sidekiq_options(opts = {})
72
+ opts = opts.transform_keys(&:to_s) # stringify
73
+ self.sidekiq_options_hash = get_sidekiq_options.merge(opts)
74
+ end
75
+
76
+ def sidekiq_retry_in(&block)
77
+ self.sidekiq_retry_in_block = block
78
+ end
79
+
80
+ def sidekiq_retries_exhausted(&block)
81
+ self.sidekiq_retries_exhausted_block = block
82
+ end
83
+
84
+ def get_sidekiq_options # :nodoc:
85
+ self.sidekiq_options_hash ||= Sidekiq.default_job_options
86
+ end
87
+
88
+ def sidekiq_class_attribute(*attrs)
89
+ instance_reader = true
90
+ instance_writer = true
91
+
92
+ attrs.each do |name|
93
+ synchronized_getter = "__synchronized_#{name}"
94
+
95
+ singleton_class.instance_eval do
96
+ undef_method(name) if method_defined?(name) || private_method_defined?(name)
97
+ end
98
+
99
+ define_singleton_method(synchronized_getter) { nil }
100
+ singleton_class.class_eval do
101
+ private(synchronized_getter)
102
+ end
103
+
104
+ define_singleton_method(name) { ACCESSOR_MUTEX.synchronize { send synchronized_getter } }
105
+
106
+ ivar = "@#{name}"
107
+
108
+ singleton_class.instance_eval do
109
+ m = "#{name}="
110
+ undef_method(m) if method_defined?(m) || private_method_defined?(m)
111
+ end
112
+ define_singleton_method("#{name}=") do |val|
113
+ singleton_class.class_eval do
114
+ ACCESSOR_MUTEX.synchronize do
115
+ undef_method(synchronized_getter) if method_defined?(synchronized_getter) || private_method_defined?(synchronized_getter)
116
+ define_method(synchronized_getter) { val }
117
+ end
118
+ end
119
+
120
+ if singleton_class?
121
+ class_eval do
122
+ undef_method(name) if method_defined?(name) || private_method_defined?(name)
123
+ define_method(name) do
124
+ if instance_variable_defined? ivar
125
+ instance_variable_get ivar
126
+ else
127
+ singleton_class.send name
128
+ end
129
+ end
130
+ end
131
+ end
132
+ val
133
+ end
134
+
135
+ if instance_reader
136
+ undef_method(name) if method_defined?(name) || private_method_defined?(name)
137
+ define_method(name) do
138
+ if instance_variable_defined?(ivar)
139
+ instance_variable_get ivar
140
+ else
141
+ self.class.public_send name
142
+ end
143
+ end
144
+ end
145
+
146
+ if instance_writer
147
+ m = "#{name}="
148
+ undef_method(m) if method_defined?(m) || private_method_defined?(m)
149
+ attr_writer name
150
+ end
151
+ end
152
+ end
153
+ end
154
+ end
155
+
156
+ attr_accessor :jid
157
+
158
+ def self.included(base)
159
+ raise ArgumentError, "Sidekiq::Job cannot be included in an ActiveJob: #{base.name}" if base.ancestors.any? { |c| c.name == "ActiveJob::Base" }
160
+
161
+ base.include(Options)
162
+ base.extend(ClassMethods)
163
+ end
164
+
165
+ def logger
166
+ Sidekiq.logger
167
+ end
168
+
169
+ # This helper class encapsulates the set options for `set`, e.g.
170
+ #
171
+ # SomeJob.set(queue: 'foo').perform_async(....)
172
+ #
173
+ class Setter
174
+ include Sidekiq::JobUtil
175
+
176
+ def initialize(klass, opts)
177
+ @klass = klass
178
+ # NB: the internal hash always has stringified keys
179
+ @opts = opts.transform_keys(&:to_s)
180
+
181
+ # ActiveJob compatibility
182
+ interval = @opts.delete("wait_until") || @opts.delete("wait")
183
+ at(interval) if interval
184
+ end
185
+
186
+ def set(options)
187
+ hash = options.transform_keys(&:to_s)
188
+ interval = hash.delete("wait_until") || @opts.delete("wait")
189
+ @opts.merge!(hash)
190
+ at(interval) if interval
191
+ self
192
+ end
193
+
194
+ def perform_async(*args)
195
+ if @opts["sync"] == true
196
+ perform_inline(*args)
197
+ else
198
+ @klass.client_push(@opts.merge("args" => args, "class" => @klass))
199
+ end
200
+ end
201
+
202
+ # Explicit inline execution of a job. Returns nil if the job did not
203
+ # execute, true otherwise.
204
+ def perform_inline(*args)
205
+ raw = @opts.merge("args" => args, "class" => @klass)
206
+
207
+ # validate and normalize payload
208
+ item = normalize_item(raw)
209
+ queue = item["queue"]
210
+
211
+ # run client-side middleware
212
+ cfg = Sidekiq.default_configuration
213
+ result = cfg.client_middleware.invoke(item["class"], item, queue, cfg.redis_pool) do
214
+ item
215
+ end
216
+ return nil unless result
217
+
218
+ # round-trip the payload via JSON
219
+ msg = Sidekiq.load_json(Sidekiq.dump_json(item))
220
+
221
+ # prepare the job instance
222
+ klass = Object.const_get(msg["class"])
223
+ job = klass.new
224
+ job.jid = msg["jid"]
225
+ job.bid = msg["bid"] if job.respond_to?(:bid)
226
+
227
+ # run the job through server-side middleware
228
+ result = cfg.server_middleware.invoke(job, msg, msg["queue"]) do
229
+ # perform it
230
+ job.perform(*msg["args"])
231
+ true
232
+ end
233
+ return nil unless result
234
+ # jobs do not return a result. they should store any
235
+ # modified state.
236
+ true
237
+ end
238
+ alias_method :perform_sync, :perform_inline
239
+
240
+ def perform_bulk(args, batch_size: 1_000)
241
+ client = @klass.build_client
242
+ result = args.each_slice(batch_size).flat_map do |slice|
243
+ client.push_bulk(@opts.merge("class" => @klass, "args" => slice))
244
+ end
245
+
246
+ result.is_a?(Enumerator::Lazy) ? result.force : result
247
+ end
248
+
249
+ # +interval+ must be a timestamp, numeric or something that acts
250
+ # numeric (like an activesupport time interval).
251
+ def perform_in(interval, *args)
252
+ at(interval).perform_async(*args)
253
+ end
254
+ alias_method :perform_at, :perform_in
255
+
256
+ private
257
+
258
+ def at(interval)
259
+ int = interval.to_f
260
+ now = Time.now.to_f
261
+ ts = (int < 1_000_000_000 ? now + int : int)
262
+ # Optimization to enqueue something now that is scheduled to go out now or in the past
263
+ @opts["at"] = ts if ts > now
264
+ self
265
+ end
266
+ end
267
+
268
+ module ClassMethods
269
+ def delay(*args)
270
+ raise ArgumentError, "Do not call .delay on a Sidekiq::Job class, call .perform_async"
271
+ end
272
+
273
+ def delay_for(*args)
274
+ raise ArgumentError, "Do not call .delay_for on a Sidekiq::Job class, call .perform_in"
275
+ end
276
+
277
+ def delay_until(*args)
278
+ raise ArgumentError, "Do not call .delay_until on a Sidekiq::Job class, call .perform_at"
279
+ end
280
+
281
+ def queue_as(q)
282
+ sidekiq_options("queue" => q.to_s)
283
+ end
284
+
285
+ def set(options)
286
+ Setter.new(self, options)
287
+ end
288
+
289
+ def perform_async(*args)
290
+ Setter.new(self, {}).perform_async(*args)
291
+ end
292
+
293
+ # Inline execution of job's perform method after passing through Sidekiq.client_middleware and Sidekiq.server_middleware
294
+ def perform_inline(*args)
295
+ Setter.new(self, {}).perform_inline(*args)
296
+ end
297
+ alias_method :perform_sync, :perform_inline
298
+
299
+ ##
300
+ # Push a large number of jobs to Redis, while limiting the batch of
301
+ # each job payload to 1,000. This method helps cut down on the number
302
+ # of round trips to Redis, which can increase the performance of enqueueing
303
+ # large numbers of jobs.
304
+ #
305
+ # +items+ must be an Array of Arrays.
306
+ #
307
+ # For finer-grained control, use `Sidekiq::Client.push_bulk` directly.
308
+ #
309
+ # Example (3 Redis round trips):
310
+ #
311
+ # SomeJob.perform_async(1)
312
+ # SomeJob.perform_async(2)
313
+ # SomeJob.perform_async(3)
314
+ #
315
+ # Would instead become (1 Redis round trip):
316
+ #
317
+ # SomeJob.perform_bulk([[1], [2], [3]])
318
+ #
319
+ def perform_bulk(*args, **kwargs)
320
+ Setter.new(self, {}).perform_bulk(*args, **kwargs)
321
+ end
322
+
323
+ # +interval+ must be a timestamp, numeric or something that acts
324
+ # numeric (like an activesupport time interval).
325
+ def perform_in(interval, *args)
326
+ int = interval.to_f
327
+ now = Time.now.to_f
328
+ ts = (int < 1_000_000_000 ? now + int : int)
329
+
330
+ item = {"class" => self, "args" => args}
331
+
332
+ # Optimization to enqueue something now that is scheduled to go out now or in the past
333
+ item["at"] = ts if ts > now
334
+
335
+ client_push(item)
336
+ end
337
+ alias_method :perform_at, :perform_in
338
+
339
+ ##
340
+ # Allows customization for this type of Job.
341
+ # Legal options:
342
+ #
343
+ # queue - use a named queue for this Job, default 'default'
344
+ # retry - enable the RetryJobs middleware for this Job, *true* to use the default
345
+ # or *Integer* count
346
+ # backtrace - whether to save any error backtrace in the retry payload to display in web UI,
347
+ # can be true, false or an integer number of lines to save, default *false*
348
+ # pool - use the given Redis connection pool to push this type of job to a given shard.
349
+ #
350
+ # In practice, any option is allowed. This is the main mechanism to configure the
351
+ # options for a specific job.
352
+ def sidekiq_options(opts = {})
353
+ super
354
+ end
355
+
356
+ def client_push(item) # :nodoc:
357
+ raise ArgumentError, "Job payloads should contain no Symbols: #{item}" if item.any? { |k, v| k.is_a?(::Symbol) }
358
+
359
+ # allow the user to dynamically re-target jobs to another shard using the "pool" attribute
360
+ # FooJob.set(pool: SOME_POOL).perform_async
361
+ old = Thread.current[:sidekiq_redis_pool]
362
+ pool = item.delete("pool")
363
+ Thread.current[:sidekiq_redis_pool] = pool if pool
364
+ begin
365
+ build_client.push(item)
366
+ ensure
367
+ Thread.current[:sidekiq_redis_pool] = old
368
+ end
369
+ end
370
+
371
+ def build_client # :nodoc:
372
+ pool = Thread.current[:sidekiq_redis_pool] || get_sidekiq_options["pool"] || Sidekiq.default_configuration.redis_pool
373
+ client_class = get_sidekiq_options["client_class"] || Sidekiq::Client
374
+ client_class.new(pool: pool)
375
+ end
376
+ end
377
+ end
13
378
  end
@@ -2,7 +2,7 @@
2
2
 
3
3
  module Sidekiq
4
4
  class JobLogger
5
- def initialize(logger = Sidekiq.logger)
5
+ def initialize(logger)
6
6
  @logger = logger
7
7
  end
8
8
 
@@ -68,9 +68,9 @@ module Sidekiq
68
68
 
69
69
  DEFAULT_MAX_RETRY_ATTEMPTS = 25
70
70
 
71
- def initialize(options)
72
- @config = options
73
- @max_retries = @config[:max_retries] || DEFAULT_MAX_RETRY_ATTEMPTS
71
+ def initialize(capsule)
72
+ @config = @capsule = capsule
73
+ @max_retries = Sidekiq.default_configuration[:max_retries] || DEFAULT_MAX_RETRY_ATTEMPTS
74
74
  end
75
75
 
76
76
  # The global retry handler requires only the barest of data.
@@ -91,7 +91,7 @@ module Sidekiq
91
91
  if msg["retry"]
92
92
  process_retry(nil, msg, queue, e)
93
93
  else
94
- Sidekiq.death_handlers.each do |handler|
94
+ @capsule.config.death_handlers.each do |handler|
95
95
  handler.call(msg, e)
96
96
  rescue => handler_ex
97
97
  handle_exception(handler_ex, {context: "Error calling death handler", job: msg})
@@ -223,7 +223,7 @@ module Sidekiq
223
223
 
224
224
  send_to_morgue(msg) unless msg["dead"] == false
225
225
 
226
- config.death_handlers.each do |handler|
226
+ @capsule.config.death_handlers.each do |handler|
227
227
  handler.call(msg, exception)
228
228
  rescue => e
229
229
  handle_exception(e, {context: "Error calling death handler", job: msg})
@@ -235,11 +235,11 @@ module Sidekiq
235
235
  payload = Sidekiq.dump_json(msg)
236
236
  now = Time.now.to_f
237
237
 
238
- config.redis do |conn|
238
+ redis do |conn|
239
239
  conn.multi do |xa|
240
240
  xa.zadd("dead", now.to_s, payload)
241
- xa.zremrangebyscore("dead", "-inf", now - config[:dead_timeout_in_seconds])
242
- xa.zremrangebyrank("dead", 0, - config[:dead_max_jobs])
241
+ xa.zremrangebyscore("dead", "-inf", now - @capsule.config[:dead_timeout_in_seconds])
242
+ xa.zremrangebyrank("dead", 0, - @capsule.config[:dead_max_jobs])
243
243
  end
244
244
  end
245
245
  end
@@ -17,14 +17,14 @@ module Sidekiq
17
17
 
18
18
  def verify_json(item)
19
19
  job_class = item["wrapped"] || item["class"]
20
- if Sidekiq[:on_complex_arguments] == :raise
20
+ if Sidekiq::Config::DEFAULTS[:on_complex_arguments] == :raise
21
21
  msg = <<~EOM
22
22
  Job arguments to #{job_class} must be native JSON types, see https://github.com/mperham/sidekiq/wiki/Best-Practices.
23
- To disable this error, remove `Sidekiq.strict_args!` from your initializer.
23
+ To disable this error, add `Sidekiq.strict_args!(false)` to your initializer.
24
24
  EOM
25
25
  raise(ArgumentError, msg) unless json_safe?(item)
26
- elsif Sidekiq[:on_complex_arguments] == :warn
27
- Sidekiq.logger.warn <<~EOM unless json_safe?(item)
26
+ elsif Sidekiq::Config::DEFAULTS[:on_complex_arguments] == :warn
27
+ warn <<~EOM unless json_safe?(item)
28
28
  Job arguments to #{job_class} do not serialize to JSON safely. This will raise an error in
29
29
  Sidekiq 7.0. See https://github.com/mperham/sidekiq/wiki/Best-Practices or raise an error today
30
30
  by calling `Sidekiq.strict_args!` during Sidekiq initialization.