Class: Zizq::EnqueueRequest

Inherits:
Object
  • Object
show all
Defined in:
lib/zizq/enqueue_request.rb,
sig/generated/zizq/enqueue_request.rbs

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.

Parameters:

  • type: (String)
  • queue: (String)
  • payload: (Object)
  • priority: (Integer, nil) (defaults to: nil)
  • delay: (Zizq::to_f, nil) (defaults to: nil)
  • ready_at: (Zizq::to_f, nil) (defaults to: nil)
  • retry_limit: (Integer, nil) (defaults to: nil)
  • backoff: (Zizq::backoff, nil) (defaults to: nil)
  • retention: (Zizq::retention, nil) (defaults to: nil)
  • unique_key: (String, nil) (defaults to: nil)
  • unique_while: (Zizq::unique_scope, nil) (defaults to: nil) 


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 ⇒ Zizq::backoff?

Backoff configuration (in seconds).

Returns:

  • (Zizq::backoff, nil) 


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

def backoff
  @backoff
end

#delay ⇒ Zizq::to_f?

Delay before the job becomes ready (seconds).

Returns:

  • (Zizq::to_f, nil) 


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

def delay
  @delay
end

#payload ⇒ Object

Job payload (serialized arguments).

Returns:

  • (Object) 


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

def payload
  @payload
end

#priority ⇒ Integer?

Job priority (lower = higher priority).

Returns:

  • (Integer, nil) 


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

def priority
  @priority
end

#queue ⇒ String

Target queue name.

Returns:

  • (String) 


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

def queue
  @queue
end

#ready_at ⇒ Zizq::to_f?

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

Returns:

  • (Zizq::to_f, nil) 


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

def ready_at
  @ready_at
end

#retention ⇒ Zizq::retention?

Retention configuration (in seconds).

Returns:

  • (Zizq::retention, nil) 


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

def retention
  @retention
end

#retry_limit ⇒ Integer?

Maximum number of retries before the job is killed.

Returns:

  • (Integer, nil) 


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

def retry_limit
  @retry_limit
end

#type ⇒ String

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

Returns:

  • (String) 


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

def type
  @type
end

#unique_key ⇒ String?

Unique key for deduplication.

Returns:

  • (String, nil) 


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

def unique_key
  @unique_key
end

#unique_while ⇒ Zizq::unique_scope?

Uniqueness scope.

Returns:

  • (Zizq::unique_scope, nil) 


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.

Returns:

  • (Object) 


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_i,
      jitter_ms: (backoff[:jitter].to_f * 1000).to_i
    }
  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) ⇒ self

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.

Parameters:

  • type: (String) (defaults to: @type)
  • queue: (String) (defaults to: @queue)
  • payload: (Object) (defaults to: @payload)
  • priority: (Integer, nil) (defaults to: @priority)
  • delay: (Zizq::to_f, nil) (defaults to: @delay)
  • ready_at: (Zizq::to_f, nil) (defaults to: @ready_at)
  • retry_limit: (Integer, nil) (defaults to: @retry_limit)
  • backoff: (Zizq::backoff, nil) (defaults to: @backoff)
  • retention: (Zizq::retention, nil) (defaults to: @retention)
  • unique_key: (String, nil) (defaults to: @unique_key)
  • unique_while: (Zizq::unique_scope, nil) (defaults to: @unique_while)

Returns:

  • (self) 


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