Minion::Job(3)

💖 Minion::Job — the whole vibe 💖

okay bestie, welcome to Minion::Job (that's the Minion::Job(3) page from the User Contributed Perl Documentation, if you're keeping receipts) — it's a container for Minion jobs and honestly it's giving main character energy for your whole task pipeline ✨

---

✨ NAME ✨

Minion::Job — a Minion job. that's it. that's the name. iconic 💅

---

🌸 SYNOPSIS 🌸

here's the whole setup, no cap:

package MyApp::Task::Foo;
use Mojo::Base 'Minion::Job', -signatures;

sub run ($self, @args) {

  # Magic here! :)
}

see that # Magic here! :)? that's you. that's your moment. go off 🧚

---

🦋 DESCRIPTION 🦋

Minion::Job is a container for Minion jobs. literally just a little box that holds one job and all its hopes and dreams 🫶

---

🌈 EVENTS 🌈

Minion::Job inherits all events from Mojo::EventEmitter and can emit the following new ones. these are your little notification pings, bestie 🔔

💜 cleanup

$job->on(cleanup => sub ($job) {
  ...
});

Emitted in the process performing this job right before the process will exit. like the last text before you go to sleep 🌙

$job->on(cleanup => sub ($job) {
  $job->app->log->debug("Process $$ is about to exit");
});

💜 failed

$job->on(failed => sub ($job, $err) {
  ...
});

Emitted in the worker process managing this job or the process performing it, after it has transitioned to the "failed" state. it's giving not-your-day 😭

$job->on(failed => sub ($job, $err) {
  say "Something went wrong: $err";
});

💜 finish

$job->on(finish => sub ($job) {
  ...
});

Emitted in the process performing this job if the task was successful. slay ✅

$job->on(finish => sub ($job) {
  my $id   = $job->id;
  my $task = $job->task;
  $job->app->log->debug(qq{Job "$id" was performed with task "$task"});
});

💜 finished

$job->on(finished => sub ($job, $result) {
  ...
});

Emitted in the worker process managing this job or the process performing it, after it has transitioned to the "finished" state. she's done, she's healed, periodt 💅

$job->on(finished => sub ($job, $result) {
  my $id = $job->id;
  say "Job $id is finished.";
});

💜 reap

$job->on(reap => sub ($job, $pid) {
  ...
});

Emitted in the worker process managing this job, after the process performing it has exited. rip bozo (affectionate) 🙈

$job->on(reap => sub ($job, $pid) {
  my $id = $job->id;
  say "Job $id ran in process $pid";
});

💜 spawn

$job->on(spawn => sub ($job, $pid) {
  ...
});

Emitted in the worker process managing this job, after a new process has been spawned for processing. baby process is born 🐣

$job->on(spawn => sub ($job, $pid) {
  my $id = $job->id;
  say "Job $id running in process $pid";
});

💜 start

$job->on(start => sub ($job) {
  ...
});

Emitted in the process performing this job, after it has been spawned. the way that this is literally the opening scene of the job's life 😭

$job->on(start => sub ($job) {
  $0 = $job->id;
});

---

🎀 ATTRIBUTES 🎀

Minion::Job implements the following attributes. these are the little properties she carries around in her bag 👜

🍓 args

my $args = $job->args;
$job     = $job->args([]);

Arguments passed to task. the receipts, the lore 🧾

🍓 id

my $id = $job->id;
$job   = $job->id($id);

Job id. her name tag 💖

🍓 minion

my $minion = $job->minion;
$job       = $job->minion(Minion->new);

Minion object this job belongs to. her home base 🏠

🍓 retries

my $retries = $job->retries;
$job        = $job->retries(5);

Number of times job has been retried. how many second chances she's gotten 🔁

🍓 task

my $task = $job->task;
$job     = $job->task('foo');

Task name. what she's actually here to do ✨

---

🔥 METHODS 🔥

Minion::Job inherits all methods from Mojo::EventEmitter and implements the following new ones. buckle up buttercup, this is the long section 😤

👑 app

my $app = $job->app;

Get application from "app" in Minion. also here's the long version, iykyk:

# Longer version
my $app = $job->minion->app;

👑 execute

my $err = $job->execute;

Perform job in this process and return "undef" if the task was successful or an exception otherwise. Note that this method should only be used to implement custom workers.

# Perform job in foreground
if (my $err = $job->execute) { $job->fail($err) }
else                         { $job->finish }

👑 fail

my $bool = $job->fail;
my $bool = $job->fail('Something went wrong!');
my $bool = $job->fail({whatever => 'Something went wrong!'});

Transition from "active" to "failed" state with or without a result, and if there are attempts remaining, transition back to "inactive" with a delay based on "backoff" in Minion. she's not down bad, she's just resting 💀

👑 finish

my $bool = $job->finish;
my $bool = $job->finish('All went well!');
my $bool = $job->finish({whatever => 'All went well!'});

Transition from "active" to "finished" state with or without a result. ate and left no crumbs 🌟

👑 info

my $info = $job->info;

Get job information. the whole gossip file 📋

# Check job state
my $state = $job->info->{state};

# Get job metadata
my $progress = $job->info->{notes}{progress};

# Get job result
my $result = $job->info->{result};

These fields are currently available:

• args — args => ['foo', 'bar'] — Job arguments.
• attempts — attempts => 25 — Number of times performing this job will be attempted.
• children — children => ['10026', '10027', '10028'] — Jobs depending on this job.
• created — created => 784111777 — Epoch time job was created.
• delayed — delayed => 784111777 — Epoch time job was delayed to.
• expires — expires => 784111777 — Epoch time job is valid until before it expires.
• finished — finished => 784111777 — Epoch time job was finished.
• lax — lax => 0 — Existing jobs this job depends on may also have failed to allow for it to be processed.
• notes — notes => {foo => 'bar', baz => [1, 2, 3]} — Hash reference with arbitrary metadata for this job.
• parents — parents => ['10023', '10024', '10025'] — Jobs this job depends on.
• priority — priority => 3 — Job priority.
• queue — queue => 'important' — Queue name.
• result — result => 'All went well!' — Job result.
• retried — retried => 784111777 — Epoch time job has been retried.
• retries — retries => 3 — Number of times job has been retried.
• started — started => 784111777 — Epoch time job was started.
• state — state => 'inactive' — Current job state, usually "active", "failed", "finished" or "inactive".
• task — task => 'foo' — Task name.
• time — time => 784111777 — Server time.
• worker — worker => '154' — Id of worker that is processing the job.

👑 is_finished

my $bool = $job->is_finished;

Check if job performed with "start" is finished. Note that this method should only be used to implement custom workers.

👑 kill

$job->kill('INT');

Send a signal to job performed with "start". Note that this method should only be used to implement custom workers. it's giving "we need to talk" 😬

👑 note

my $bool = $job->note(mojo => 'rocks', minion => 'too');

Change one or more metadata fields for this job. Setting a value to "undef" will remove the field. The new values will get serialized by "backend" in Minion (often with Mojo::JSON), so you shouldn't send objects and be careful with binary data, nested data structures with hash and array references are fine though.

fr fr on the binary data thing, bestie — don't do it, it's not worth the drama 😭

# Share progress information
$job->note(progress => 95);

# Share stats
$job->note(stats => {utime => '0.012628', stime => '0.002429'});

👑 parents

my $parents = $job->parents;

Return a Mojo::Collection object containing all jobs this job depends on as Minion::Job objects. her ancestors, her lineage 👑

# Check parent state
for my $parent ($job->parents->each) {
  my $info = $parent->info;
  say "$info->{id}: $info->{state}";
}

👑 perform

$job->perform;

Perform job in new process and wait for it to finish. Note that this method should only be used to implement custom workers.

👑 pid

my $pid = $job->pid;

Process id of the process spawned by "start" if available. Note that this method should only be used to implement custom workers.

👑 remove

my $bool = $job->remove;

Remove "failed", "finished" or "inactive" job from queue. she's out, she's gone, blocked 🚫

👑 retry

my $bool = $job->retry;
my $bool = $job->retry({delay => 10});

Transition job back to "inactive" state, already "inactive" jobs may also be retried to change options. second chance era 🫶

These options are currently available:

• attempts — attempts => 25 — Number of times performing this job will be attempted.
• delay — delay => 10 — Delay job for this many seconds (from now), defaults to 0.
• expire — expire => 300 — Job is valid for this many seconds (from now) before it expires.
• lax — lax => 1 — Existing jobs this job depends on may also have transitioned to the "failed" state to allow for it to be processed, defaults to "false".
• parents — parents => [$id1, $id2, $id3] — Jobs this job depends on.
• priority — priority => 5 — Job priority.
• queue — queue => 'important' — Queue to put job in.

👑 run

$job->run(@args);

Task to perform by this job. Meant to be overloaded in a subclass to create a custom task class.

⚠️ Note that this method is EXPERIMENTAL and might change without warning! ⚠️

like she said what she said but she might change her mind, no cap 💅

👑 start

$job = $job->start;

Perform job in new process, but do not wait for it to finish. Note that this method should only be used to implement custom workers.

# Perform two jobs concurrently
$job1->start;
$job2->start;
my ($first, $second);
sleep 1
  until $first ||= $job1->is_finished and $second ||= $job2->is_finished;

multitasking queen behavior 👸

👑 stop

$job->stop;

Stop job performed with "start" immediately. Note that this method should only be used to implement custom workers. abrupt but necessary, we've all been there 😭

---

🌟 SEE ALSO 🌟

go read these too, bestie, they're the extended universe:

• Minion
• Minion::Guide
• <https://minion.pm>
• Mojolicious::Guides
• <https://mojolicious.org>

---

and that's the whole page!! 💖✨🎀🦋🌸💅🫶 this beauty ships as perl v5.42.0, dated 2026-01-17, and it's the Minion::Job(3) manpage — so go forth and run your tasks, you absolute icon 👑💜