Class: Zizq::EnqueueRequest

Inherits:
Object
  • Object
show all
Defined in:
lib/zizq/enqueue_request.rb

Overview

Represents a job enqueue request.

Contains all the information needed to enqueue a job. Built by ‘Job::ClassMethods#zizq_enqueue_options` or directly for raw enqueues. Mutable — callers can override values via the block form of `Zizq.enqueue`.

Zizq.enqueue(MyJob, 42) { |req| req.priority = 0 }

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(type:, queue:, payload:, priority: nil, delay: nil, ready_at: nil, retry_limit: nil, backoff: nil, retention: nil, unique_key: nil, unique_while: nil) ⇒ EnqueueRequest

Returns a new instance of EnqueueRequest.



63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/zizq/enqueue_request.rb', line 63

def initialize(type:,
               queue:,
               payload:,
               priority: nil,
               delay: nil,
               ready_at: nil,
               retry_limit: nil,
               backoff: nil,
               retention: nil,
               unique_key: nil,
               unique_while: nil)
  update(
    type:,
    queue:,
    payload:,
    priority:,
    delay:,
    ready_at:,
    retry_limit:,
    backoff:,
    retention:,
    unique_key:,
    unique_while:,
  )
end

Instance Attribute Details

#backoff ⇒ Object

Backoff configuration (in seconds).



40
41
42
 
# File 'lib/zizq/enqueue_request.rb', line 40

def backoff
  @backoff
end

#delay ⇒ Object

Delay before the job becomes ready (seconds).



31
32
33
 
# File 'lib/zizq/enqueue_request.rb', line 31

def delay
  @delay
end

#payload ⇒ Object

Job payload (serialized arguments).



25
26
27
 
# File 'lib/zizq/enqueue_request.rb', line 25

def payload
  @payload
end

#priority ⇒ Object

Job priority (lower = higher priority).



28
29
30
 
# File 'lib/zizq/enqueue_request.rb', line 28

def priority
  @priority
end

#queue ⇒ Object

Target queue name.



22
23
24
 
# File 'lib/zizq/enqueue_request.rb', line 22

def queue
  @queue
end

#ready_at ⇒ Object

Absolute time when the job becomes ready (fractional seconds since epoch).



34
35
36
 
# File 'lib/zizq/enqueue_request.rb', line 34

def ready_at
  @ready_at
end

#retention ⇒ Object

Retention configuration (in seconds).



43
44
45
 
# File 'lib/zizq/enqueue_request.rb', line 43

def retention
  @retention
end

#retry_limit ⇒ Object

Maximum number of retries before the job is killed.



37
38
39
 
# File 'lib/zizq/enqueue_request.rb', line 37

def retry_limit
  @retry_limit
end

#type ⇒ Object

Job type string (e.g. class name).



19
20
21
 
# File 'lib/zizq/enqueue_request.rb', line 19

def type
  @type
end

#unique_key ⇒ Object

Unique key for deduplication.



46
47
48
 
# File 'lib/zizq/enqueue_request.rb', line 46

def unique_key
  @unique_key
end

#unique_while ⇒ Object

Uniqueness scope.



49
50
51
 
# File 'lib/zizq/enqueue_request.rb', line 49

def unique_while
  @unique_while
end

Instance Method Details

#to_enqueue_params ⇒ Object

Convert to the params expected by ‘Client#enqueue`.

Handles seconds -> milliseconds conversion for time-based fields, delay -> ready_at resolution, and nil omission.



144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
 
# File 'lib/zizq/enqueue_request.rb', line 144

def to_enqueue_params #: () -> Hash[Symbol, untyped]
  params = { queue:, type:, payload: } #: Hash[Symbol, untyped]
  params[:priority] = priority if priority

  effective_ready_at = if delay
    Time.now.to_f + delay.to_f
  else
    ready_at
  end
  params[:ready_at] = effective_ready_at if effective_ready_at

  params[:retry_limit] = retry_limit if retry_limit

  if backoff
    params[:backoff] = {
      exponent: backoff[:exponent].to_f,
      base_ms: (backoff[:base].to_f * 1000).to_f,
      jitter_ms: (backoff[:jitter].to_f * 1000).to_f
    }
  end

  if retention
    ret = {} #: Hash[Symbol, Integer]
    ret[:completed_ms] = (retention[:completed].to_f * 1000).to_i if retention[:completed]
    ret[:dead_ms] = (retention[:dead].to_f * 1000).to_i if retention[:dead]
    params[:retention] = ret
  end

  params[:unique_key] = unique_key if unique_key
  params[:unique_while] = unique_while.to_s if unique_while

  params
end

#update(type: @type, queue: @queue, payload: @payload, priority: @priority, delay: @delay, ready_at: @ready_at, retry_limit: @retry_limit, backoff: @backoff, retention: @retention, unique_key: @unique_key, unique_while: @unique_while) ⇒ Object

Update one or more fields in place.

Each keyword argument defaults to the current field value, so callers only need to name the fields they want to change. Returns ‘self` for chaining. Unknown keys raise `ArgumentError` — this is the signal that prevents typos like `:retries` from silently doing nothing.

req.update(priority: 0, ready_at: Time.now + 60)

Used by ‘Zizq::EnqueueWith` to apply scoped overrides, and can be called directly from enqueue blocks as an alternative to assigning individual attributes.



115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/zizq/enqueue_request.rb', line 115

def update(type: @type,
           queue: @queue,
           payload: @payload,
           priority: @priority,
           delay: @delay,
           ready_at: @ready_at,
           retry_limit: @retry_limit,
           backoff: @backoff,
           retention: @retention,
           unique_key: @unique_key,
           unique_while: @unique_while)
  @type         = type
  @queue        = queue
  @payload      = payload
  @priority     = priority
  @delay        = delay
  @ready_at     = ready_at
  @retry_limit  = retry_limit
  @backoff      = backoff
  @retention    = retention
  @unique_key   = unique_key
  @unique_while = unique_while
  self
end