PHP port of resque (Workers and Queueing)

Overview

php-resque: PHP Resque Worker (and Enqueue) Build Status

Resque is a Redis-backed library for creating background jobs, placing those jobs on one or more queues, and processing them later.

Background

Resque was pioneered and is developed by the fine folks at GitHub (yes, I am a kiss-ass), and written in Ruby. What you're seeing here is an almost direct port of the Resque worker and enqueue system to PHP.

For more information on Resque, visit the official GitHub project: https://github.com/resque/resque

For further information, see the launch post on the GitHub blog: http://github.com/blog/542-introducing-resque

The PHP port does NOT include its own web interface for viewing queue stats, as the data is stored in the exact same expected format as the Ruby version of Resque.

The PHP port provides much the same features as the Ruby version:

  • Workers can be distributed between multiple machines
  • Includes support for priorities (queues)
  • Resilient to memory leaks (forking)
  • Expects failure

It also supports the following additional features:

  • Has the ability to track the status of jobs
  • Will mark a job as failed, if a forked child running a job does not exit with a status code as 0
  • Has built in support for setUp and tearDown methods, called pre and post jobs

Requirements

  • PHP 5.3+
  • Redis 2.2+
  • Optional but Recommended: Composer

Getting Started

The easiest way to work with php-resque is when it's installed as a Composer package inside your project. Composer isn't strictly required, but makes life a lot easier.

If you're not familiar with Composer, please see http://getcomposer.org/.

  1. Add php-resque to your application's composer.json.
{
    "require": {
        "chrisboulton/php-resque": "1.2.x"
    }
}
  1. Run composer install.

  2. If you haven't already, add the Composer autoload to your project's initialization file. (example)

require 'vendor/autoload.php';

Jobs

Queueing Jobs

Jobs are queued as follows:

// Required if redis is located elsewhere
Resque::setBackend('localhost:6379');

$args = array(
        'name' => 'Chris'
        );
Resque::enqueue('default', 'My_Job', $args);

Defining Jobs

Each job should be in its own class, and include a perform method.

class My_Job
{
    public function perform()
    {
        // Work work work
        echo $this->args['name'];
    }
}

When the job is run, the class will be instantiated and any arguments will be set as an array on the instantiated object, and are accessible via $this->args.

Any exception thrown by a job will result in the job failing - be careful here and make sure you handle the exceptions that shouldn't result in a job failing.

Jobs can also have setUp and tearDown methods. If a setUp method is defined, it will be called before the perform method is run. The tearDown method, if defined, will be called after the job finishes.

class My_Job
{
    public function setUp()
    {
        // ... Set up environment for this job
    }

    public function perform()
    {
        // .. Run job
    }

    public function tearDown()
    {
        // ... Remove environment for this job
    }
}

Dequeueing Jobs

This method can be used to conveniently remove a job from a queue.

// Removes job class 'My_Job' of queue 'default'
Resque::dequeue('default', ['My_Job']);

// Removes job class 'My_Job' with Job ID '087df5819a790ac666c9608e2234b21e' of queue 'default'
Resque::dequeue('default', ['My_Job' => '087df5819a790ac666c9608e2234b21e']);

// Removes job class 'My_Job' with arguments of queue 'default'
Resque::dequeue('default', ['My_Job' => array('foo' => 1, 'bar' => 2)]);

// Removes multiple jobs
Resque::dequeue('default', ['My_Job', 'My_Job2']);

If no jobs are given, this method will dequeue all jobs matching the provided queue.

// Removes all jobs of queue 'default'
Resque::dequeue('default');

Tracking Job Statuses

php-resque has the ability to perform basic status tracking of a queued job. The status information will allow you to check if a job is in the queue, is currently being run, has finished, or has failed.

To track the status of a job, pass true as the fourth argument to Resque::enqueue. A token used for tracking the job status will be returned:

$token = Resque::enqueue('default', 'My_Job', $args, true);
echo $token;

To fetch the status of a job:

$status = new Resque_Job_Status($token);
echo $status->get(); // Outputs the status

Job statuses are defined as constants in the Resque_Job_Status class. Valid statuses include:

  • Resque_Job_Status::STATUS_WAITING - Job is still queued
  • Resque_Job_Status::STATUS_RUNNING - Job is currently running
  • Resque_Job_Status::STATUS_FAILED - Job has failed
  • Resque_Job_Status::STATUS_COMPLETE - Job is complete
  • false - Failed to fetch the status - is the token valid?

Statuses are available for up to 24 hours after a job has completed or failed, and are then automatically expired. A status can also forcefully be expired by calling the stop() method on a status class.

Workers

Workers work in the exact same way as the Ruby workers. For complete documentation on workers, see the original documentation.

A basic "up-and-running" bin/resque file is included that sets up a running worker environment. (vendor/bin/resque when installed via Composer)

The exception to the similarities with the Ruby version of resque is how a worker is initially setup. To work under all environments, not having a single environment such as with Ruby, the PHP port makes no assumptions about your setup.

To start a worker, it's very similar to the Ruby version:

$ QUEUE=file_serve php bin/resque

It's your responsibility to tell the worker which file to include to get your application underway. You do so by setting the APP_INCLUDE environment variable:

$ QUEUE=file_serve APP_INCLUDE=../application/init.php php bin/resque

Pro tip: Using Composer? More than likely, you don't need to worry about APP_INCLUDE, because hopefully Composer is responsible for autoloading your application too!

Getting your application underway also includes telling the worker your job classes, by means of either an autoloader or including them.

Alternately, you can always include('bin/resque') from your application and skip setting APP_INCLUDE altogether. Just be sure the various environment variables are set (setenv) before you do.

Logging

The port supports the same environment variables for logging to STDOUT. Setting VERBOSE will print basic debugging information and VVERBOSE will print detailed information.

$ VERBOSE=1 QUEUE=file_serve bin/resque
$ VVERBOSE=1 QUEUE=file_serve bin/resque

Priorities and Queue Lists

Similarly, priority and queue list functionality works exactly the same as the Ruby workers. Multiple queues should be separated with a comma, and the order that they're supplied in is the order that they're checked in.

As per the original example:

$ QUEUE=file_serve,warm_cache bin/resque

The file_serve queue will always be checked for new jobs on each iteration before the warm_cache queue is checked.

Running All Queues

All queues are supported in the same manner and processed in alphabetical order:

$ QUEUE='*' bin/resque

Running Multiple Workers

Multiple workers can be launched simultaneously by supplying the COUNT environment variable:

$ COUNT=5 bin/resque

Be aware, however, that each worker is its own fork, and the original process will shut down as soon as it has spawned COUNT forks. If you need to keep track of your workers using an external application such as monit, you'll need to work around this limitation.

Custom prefix

When you have multiple apps using the same Redis database it is better to use a custom prefix to separate the Resque data:

$ PREFIX=my-app-name bin/resque

Forking

Similarly to the Ruby versions, supported platforms will immediately fork after picking up a job. The forked child will exit as soon as the job finishes.

The difference with php-resque is that if a forked child does not exit nicely (PHP error or such), php-resque will automatically fail the job.

Signals

Signals also work on supported platforms exactly as in the Ruby version of Resque:

  • QUIT - Wait for job to finish processing then exit
  • TERM / INT - Immediately kill job then exit
  • USR1 - Immediately kill job but don't exit
  • USR2 - Pause worker, no new jobs will be processed
  • CONT - Resume worker.

Process Titles/Statuses

The Ruby version of Resque has a nifty feature whereby the process title of the worker is updated to indicate what the worker is doing, and any forked children also set their process title with the job being run. This helps identify running processes on the server and their resque status.

PHP does not have this functionality by default until 5.5.

A PECL module (http://pecl.php.net/package/proctitle) exists that adds this functionality to PHP before 5.5, so if you'd like process titles updated, install the PECL module as well. php-resque will automatically detect and use it.

Event/Hook System

php-resque has a basic event system that can be used by your application to customize how some of the php-resque internals behave.

You listen in on events (as listed below) by registering with Resque_Event and supplying a callback that you would like triggered when the event is raised:

Resque_Event::listen('eventName', [callback]);

[callback] may be anything in PHP that is callable by call_user_func_array:

  • A string with the name of a function
  • An array containing an object and method to call
  • An array containing an object and a static method to call
  • A closure (PHP 5.3+)

Events may pass arguments (documented below), so your callback should accept these arguments.

You can stop listening to an event by calling Resque_Event::stopListening with the same arguments supplied to Resque_Event::listen.

It is up to your application to register event listeners. When enqueuing events in your application, it should be as easy as making sure php-resque is loaded and calling Resque_Event::listen.

When running workers, if you run workers via the default bin/resque script, your APP_INCLUDE script should initialize and register any listeners required for operation. If you have rolled your own worker manager, then it is again your responsibility to register listeners.

A sample plugin is included in the extras directory.

Events

beforeFirstFork

Called once, as a worker initializes. Argument passed is the instance of Resque_Worker that was just initialized.

beforeFork

Called before php-resque forks to run a job. Argument passed contains the instance of Resque_Job for the job about to be run.

beforeFork is triggered in the parent process. Any changes made will be permanent for as long as the worker lives.

afterFork

Called after php-resque forks to run a job (but before the job is run). Argument passed contains the instance of Resque_Job for the job about to be run.

afterFork is triggered in the child process after forking out to complete a job. Any changes made will only live as long as the job is being processed.

beforePerform

Called before the setUp and perform methods on a job are run. Argument passed contains the instance of Resque_Job for the job about to be run.

You can prevent execution of the job by throwing an exception of Resque_Job_DontPerform. Any other exceptions thrown will be treated as if they were thrown in a job, causing the job to fail.

afterPerform

Called after the perform and tearDown methods on a job are run. Argument passed contains the instance of Resque_Job that was just run.

Any exceptions thrown will be treated as if they were thrown in a job, causing the job to be marked as having failed.

onFailure

Called whenever a job fails. Arguments passed (in this order) include:

  • Exception - The exception that was thrown when the job failed
  • Resque_Job - The job that failed

beforeEnqueue

Called immediately before a job is enqueued using the Resque::enqueue method. Arguments passed (in this order) include:

  • Class - string containing the name of the job to be enqueued
  • Arguments - array of arguments for the job
  • Queue - string containing the name of the queue the job is to be enqueued in
  • ID - string containing the token of the job to be enqueued

You can prevent enqueing of the job by throwing an exception of Resque_Job_DontCreate.

afterEnqueue

Called after a job has been queued using the Resque::enqueue method. Arguments passed (in this order) include:

  • Class - string containing the name of scheduled job
  • Arguments - array of arguments supplied to the job
  • Queue - string containing the name of the queue the job was added to
  • ID - string containing the new token of the enqueued job

Step-By-Step

For a more in-depth look at what php-resque does under the hood (without needing to directly examine the code), have a look at HOWITWORKS.md.

Contributors

Project Lead

  • @chrisboulton

Others

  • @acinader
  • @ajbonner
  • @andrewjshults
  • @atorres757
  • @benjisg
  • @cballou
  • @chaitanyakuber
  • @charly22
  • @CyrilMazur
  • @d11wtq
  • @danhunsaker
  • @dceballos
  • @ebernhardson
  • @hlegius
  • @hobodave
  • @humancopy
  • @iskandar
  • @JesseObrien
  • @jjfrey
  • @jmathai
  • @joshhawthorne
  • @KevBurnsJr
  • @lboynton
  • @maetl
  • @matteosister
  • @MattHeath
  • @mickhrmweb
  • @Olden
  • @patrickbajao
  • @pedroarnal
  • @ptrofimov
  • @rajibahmed
  • @richardkmiller
  • @Rockstar04
  • @ruudk
  • @salimane
  • @scragg0x
  • @scraton
  • @thedotedge
  • @tonypiper
  • @trimbletodd
  • @warezthebeef
Comments
  • Multiple Workers = Lost jobs?

    Multiple Workers = Lost jobs?

    As per a comment on issue #30, I'm opening this issue in order to help gather more info and find a fix for the bug.

    I observed that when deploying multiple workers, some jobs dont get processed...

    Basically the test I did was:

    watch output and number of jobs, launch 5 workers. Enqueue 10 jobs. number of jobs in redis gets augmented to 10 (so 10 jobs queued), but only a few get really processed. Nonetheless, they all get pulled out of the queue...

    So basically it is "loosing" jobs.

    I will try and test more tomorrow, time permitting, and post back.

    Chris said he had already noticed this, so if anyone else has noticed and/or fixed this, please let us know.

    Imo this is crucial for any production environment, no? Is anyone using phpresque in a production environment? Are you loosing jobs? Maybe you havent noticed? Can you please check and revert?

    thanks!

    opened by roynasser 42
  • Possible issue Resque/Redis interaction, jobs not beeing queued/executed

    Possible issue Resque/Redis interaction, jobs not beeing queued/executed

    We have an issue where:

    • We have a record of a job's status: "resque:job:0303372f365b078473192b4b607c3f65:status"
    • Status of job above is Resque_Job_Status::STATUS_WAITING
    • The job has never been executed (We log all job-executions to fix this issue)
    • The queues are empty, queues that exist are "default" and "stage"
    • We suppose that the job WAS pushed as we got a response from PhpResque when the job was added

    Supposed problems:

    • Job failed somehow while popping, never reaching the next staus
    • Job was not added to a queue properly

    Any ideas?

    Currently we have 4000+ jobs that most probably was not executed, but all of them have status WAITING - and there are no way of actually finding out what they where supposed to do and "re-execute them"...(?) :)

    opened by hussfelt 24
  • Basic support for blocking list pop

    Basic support for blocking list pop

    This PR has basic support for BLPOP. Since PR #58 has a lot more changes in it than what's needed I decided to recreate it.

    The tests still use LPOP because that's faster to test. BLPOP differs in a small way (that it returns an array) which is not tested but I don't see any problem in that.

    opened by ruudk 23
  • Job status incorrect

    Job status incorrect

    It seems that tracking the status of jobs doesn't seem to be working for me. I've written the following to check the status every second: Resque::enqueue('processqueue', 'ProcessMessage', $args); $parsehost_token = Resque::enqueue('hostqueue', 'parseHost', $args, true);

    while(!$done){ $status = new Resque_Job_Status($parsehost_token); var_dump($status); switch($status->get()){ case Resque_Job_Status::STATUS_WAITING: echo "WAITING\n"; break; case Resque_Job_Status::STATUS_RUNNING: echo "RUNNING\n"; break; case Resque_Job_Status::STATUS_FAILED: $done = true; break; case Resque_Job_Status::STATUS_COMPLETE: $done = true; break; } sleep(1); }

    It keeps "RUNNING" forever, even when the script in the job exits with exit(0).

    var_dump gives me the following: object(Resque_Job_Status)#18 (2) { ["id":"Resque_Job_Status":private]=> string(32) "a6289a79d5059f7e53f5a6a7e3a895d1" ["isTracking":"Resque_Job_Status":private]=> NULL }

    So 'isTracking' is set to "false", even if i have enqueued the job with the 4th parameter set to "true"?

    What am I not seeing here?

    opened by driesken 20
  • Improved Worker Reliability

    Improved Worker Reliability

    Specifically, this improves the multi-worker forking process by having the parent process stick around and monitor the children. If a child process dies, and the supervisor has not been instructed to shut them all down, it will spawn a new child to replace it. It will pass signals down to all children. Currently, it only passes the signals explicitly watched by the Worker class. Children will be told that they have a parent process, and check periodically whether the supervisor is still running. This check is performed at the beginning of reserve() to ensure orphaned workers handle their condition properly. That is, if the supervisor is gone, the child will exit. This is intended to allow users to kill the supervisor and realistically expect that no new jobs will be processed until a new supervisor (or single-worker instance) is started.

    The other change, not related to worker-supervisor relationships, nevertheless still involves forking. Specifically, when a job process exits, the exit code is already being handled if it is greater than zero. However, if it is zero, the code prior to this commit assumed the exit was performed by PHP Resque itself. Usually, this is correct. The trouble comes when jobs exit without specifying an exit status - PHP defaults these to 0, for whatever reason. In these cases, the job status is not properly updated. Generally speaking, if you're writing jobs yourself - in their entirety - they will responsibly not use exit() at any point. But if your jobs use a framework, the chances of an unexpected exit() causing issues go up immensely. So, if the exit code is zero, and the job status hasn't been updated from queued or running, this commit's code causes the status to be updated to completed. This assumes that such jobs are properly written to only use exit status 0 for success, so some users might wish to change it to failed, but that's not best practice in the slightest, so I wouldn't encourage that.

    Signed-off-by: Daniel Hunsaker [email protected]

    opened by danhunsaker 19
  • Fix lost jobs in multiple workers with count > 1 (issue #32)

    Fix lost jobs in multiple workers with count > 1 (issue #32)

    Hi, I tracked down the issue #32. Seems it's caused by not letting the main parent process continue to live and wait for all its children to exit before exiting itself. I've also registered a shutdown function to kill the child process when exiting. Thanks

    opened by salimane 18
  • New Relic transaction naming support for Jobs?

    New Relic transaction naming support for Jobs?

    I was looking for pointers / support on how can each Job be reported as a separate New Relic transaction.

    Right now in my New Relic, I see the bin/resque as one thick transaction with no further clarity on which job is taking how long..

    Would like your thoughts on better integration with New Relic?

    opened by epicwhale 17
  • Use BLPOP by default?

    Use BLPOP by default?

    PR #63 added support for BLPOP with the BLOCKING environment variable. I've been running this for a couple of months now and it works great.

    Shouldn't we make this a default behavior? It's so much faster than the 5 second polling interval?

    opened by ruudk 17
  • Allowing to use a factory instead of manually instantiate the Jobs

    Allowing to use a factory instead of manually instantiate the Jobs

    In order to make the Jobs injectable, I want to allow to delegate the responsibility of create new jobs to an independent factory. In that way, if I want to use Pimple, I can do so using a factory that will encapsulate access to Pimple to retrieve instances of Resque_JobInterface

    I kept it as PSR-0 and I have added a couple of tests

    opened by serroba 16
  • performance issues (pcntl_fork overhead?)

    performance issues (pcntl_fork overhead?)

    So I've started playing with a deployment of this in production and seem to be having performance issues with pcntl_fork. Processing an empty job (that just contain an error_log statement) takes over 50ms, and our queue needs to be able to process more than 1000 items per second.

    I'm thinking I might have to fork the project and change the behavior so that instead of forking on every job, to fork on every X jobs (where X > 100). My concern is that I haven't figured out a way to communicate between processes in PHP that would let me pass back the job object about to be processed from the child to the parent. Ideas?

    opened by kballenegger 16
  • Implementing salimanes fork patch

    Implementing salimanes fork patch

    This is an up-to-date patch, based on Salimane's work: https://github.com/salimane/php-resque-jobs-per-fork

    This PR introduces an environment variable JOBS_PER_FORK, that will define the amount of jobs being processed per fork. A larger value introduces a slightly more risk (in case of errors or unexpected dependencies), but also reduces overhead quite a bit. I'm not sure yet what the optimum value is, but that will different for each job.

    Tests show up to 10x faster jobs and fewer resources needed.

    opened by Dynom 15
  • PHP Deprecated: implode(): Passing glue string after array is deprecated.

    PHP Deprecated: implode(): Passing glue string after array is deprecated.

    Hi,

    Who can help me make these code working whitout warnings? It is a file from Redis PHP Rescue

    PHP Deprecated: implode(): Passing glue string after array is deprecated. Swap the parameters in /public_html/vendor/chrisboulton/php-resque/lib/Redisent/Redisent.php on line 73

    Here is the code

    /* Build the Redis unified protocol command / array_unshift($args, strtoupper($name)); $command = sprintf('%d%s%s%s', count($args), CRLF, implode(array_map(array($this, 'formatArgument'), $args), CRLF), CRLF);

    opened by sjopz 0
  • Stat namespace growing

    Stat namespace growing

    The stat namespace in our Redis DB is approaching 2 million keys. What is the best way to clean up this namespace? Is it safe to delete the entire namespace?

    opened by jchoi926 0
  • Why not

    Why not "break"?

    https://github.com/chrisboulton/php-resque/blob/968b7e6a307a2079051dfc571d2fc2be0546209f/lib/Resque.php#L307 https://github.com/chrisboulton/php-resque/blob/968b7e6a307a2079051dfc571d2fc2be0546209f/lib/Resque.php#L298

    Isn't "break" more appropriate than "$finished" variable?

    opened by d-a-gerashenko 1
  • should check pcntl_wifexited first before pcntl_wexitstatus

    should check pcntl_wifexited first before pcntl_wexitstatus

    In lib/Worker.php line:215 in Function work(): I think it should check pcntl_wifexited first before pcntl_wexitstatus. Because pcntl_wexitstatus is meaningless if pcntl_wifexited return false. For example, kill the child process would result in this case.

    opened by Jinglever 0
  •  QUEUE=message php   vendor/bin/resque

    QUEUE=message php vendor/bin/resque

    Hi,all in command line ,I run QUEUE=message php vendor/bin/resque;then I push many task into queue .but only one queue was execute.others also in queue.not execute. anyone can help me ?

    opened by gangming 4
Owner
Chris Boulton
Chris Boulton
xcron - the souped up, modernized cron/Task Scheduler for Windows, Mac OSX, Linux, and FreeBSD server and desktop operating systems.

xcron is the souped up, modernized cron/Task Scheduler for Windows, Mac OSX, Linux, and FreeBSD server and desktop operating systems. MIT or LGPL.

CubicleSoft 5 Apr 7, 2022
A versatile and lightweight PHP task runner, designed with simplicity in mind.

Blend A versatile and lightweight PHP task runner, designed with simplicity in mind. Table of Contents About Blend Installation Config Examples API Ch

Marwan Al-Soltany 42 Sep 20, 2022
Manage all your cron jobs without modifying crontab. Handles locking, logging, error emails, and more.

Jobby, a PHP cron job manager Install the master jobby cron job, and it will manage all your offline tasks. Add jobs without modifying crontab. Jobby

null 1k Sep 23, 2022
A unified front-end for different queuing backends. Includes a REST server, CLI interface and daemon runners.

PHP-Queue A unified front-end for different queuing backends. Includes a REST server, CLI interface and daemon runners. Why PHP-Queue? Implementing a

CoderKungfu 646 Sep 23, 2022
Manage your Laravel Task Scheduling in a friendly interface and save schedules to the database.

Documentation This librarian creates a route(default: /schedule) in your application where it is possible to manage which schedules will be executed a

Roberson Faria 246 Sep 26, 2022
Schedule and unschedule eloquent models elegantly without cron jobs

Laravel Schedulable Schedule and Unschedule any eloquent model elegantly without cron job. Salient Features: Turn any Eloquent Model into a schedulabl

Neelkanth Kaushik 104 Sep 17, 2022
A course database lookup tool and schedule building web application for use at Rochester Institute of Technology.

CSH ScheduleMaker A course database lookup tool and schedule building web application for use at Rochester Institute of Technology. Built, maintained

Computer Science House 52 Oct 16, 2021
Modern task runner for PHP

RoboTask Modern and simple PHP task runner inspired by Gulp and Rake aimed to automate common tasks: writing cross-platform scripts processing assets

Consolidation 2.5k Sep 20, 2022
PHP cron job scheduler

PHP Cron Scheduler This is a framework agnostic cron jobs scheduler that can be easily integrated with your project or run as a standalone command sch

Giuseppe Occhipinti 673 Sep 26, 2022
Pure PHP task runner

task/task Got a PHP project? Heard of Grunt and Gulp but don't use NodeJS? Task is a pure PHP task runner. Leverage PHP as a scripting language, and a

null 183 Jul 31, 2022
Modern task runner for PHP

RoboTask Modern and simple PHP task runner inspired by Gulp and Rake aimed to automate common tasks: writing cross-platform scripts processing assets

Consolidation 2.5k Sep 20, 2022
Elegant SSH tasks for PHP.

Laravel Envoy Introduction Laravel Envoy provides a clean, minimal syntax for defining common tasks you run on your remote servers. Using Blade style

The Laravel Framework 1.5k Sep 22, 2022
🐺 Asynchronous Task Queue Based on Distributed Message Passing for PHP.

?? Asynchronous Task Queue Based on Distributed Message Passing for PHP.

Ahmed 36 Aug 11, 2022
A PHP implementation of a bare task loop.

TaskLoop A PHP implementation of a bare task loop. Installation. $ composer require thenlabs/task-loop 1.0.x-dev Usage. The file example.php contains

ThenLabs 2 Mar 23, 2022
Crunz is a framework-agnostic package to schedule periodic tasks (cron jobs) in PHP using a fluent API.

Crunz Install a cron job once and for all, manage the rest from the code. Crunz is a framework-agnostic package to schedule periodic tasks (cron jobs)

Reza Lavarian 1.4k Sep 26, 2022
A PHP-based job scheduler

Crunz Install a cron job once and for all, manage the rest from the code. Crunz is a framework-agnostic package to schedule periodic tasks (cron jobs)

null 27 Sep 24, 2022
Track the memory usage of your workers and display them in Filament.

Filament Memory Tracker Track the memory usage of your workers and display them in Filament. Installation Install the package via composer: composer r

Theraloss 21 Sep 5, 2022
PHP daemon for managing gearman workers

Running Gearman workers can be a tedious task. Many many files with the same lines of code over and over for creating a worker, connecting to a server, adding functions to the worker, etc. etc. The aim of GearmanManager is to make running workers more of an operational task and less of a development task.

Brian Moon 682 Sep 4, 2022
Instrument commands/workers/custom code with datadog, newrelic, tideways, symfony, spx.

sourceability/instrumentation This library provides a simple interface to start and stop instrumenting code with APMs. Symfony commands and messenger

null 15 Jun 6, 2022
A redacted PHP port of Underscore.js with additional functions and goodies – Available for Composer and Laravel

Underscore.php The PHP manipulation toolbelt First off : Underscore.php is not a PHP port of Underscore.js (well ok I mean it was at first). It's does

Emma Fabre 1.1k Sep 22, 2022