├── README.md
├── composer.json
├── resources
    └── views
    │   ├── date.blade.php
    │   ├── status-json.php
    │   ├── status-page.blade.php
    │   ├── status-panel.blade.php
    │   └── status.blade.php
└── src
    ├── Command
        └── QueueQueueCheckCommand.php
    ├── Job.php
    ├── QueueChecker.php
    ├── QueueMonitor.php
    ├── QueueStatus.php
    └── ServiceProvider.php


/README.md:
--------------------------------------------------------------------------------
 1 | Laravel queue monitor
 2 | =====================
 3 | 
 4 | This adds various tools to a project for monitoring its queue.
 5 | 
 6 | Laravel version
 7 | ---------------
 8 | 
 9 | This branch and the `2.*` line of tags are for Laravel 5. For the Laravel 4
10 | version [see the laravel4 branch][l4] and the `1.*` line of tags.
11 | 
12 | If you are using Laravel 5.5 or later, and are using PHP 7.1 or later,
13 | and your queue is backed by Redis,
14 | you may instead consider using [Laravel Horizon][horizon],
15 | which is an official tool and solves the same issue as this package.
16 | 
17 | [l4]: https://github.com/tremby/laravel-queue-monitor/tree/laravel4
18 | [horizon]: https://laravel.com/docs/5.5/horizon
19 | 
20 | Installation
21 | ------------
22 | 
23 | Require it in your Laravel project:
24 | 
25 |     composer require tremby/laravel-queue-monitor
26 | 
27 | If you're running Laravel 5.4 or below,
28 | you have to register the service provider manually
29 | in your `config/app.php` file:
30 | 
31 | ```php
32 | 'providers' => [
33 |     ...
34 |     Tremby\QueueMonitor\ServiceProvider::class,
35 | ],
36 | ```
37 | 
38 | Use
39 | ---
40 | 
41 | Add a cron job which runs the `queue:queuecheck` Artisan task for each queue you
42 | want to monitor. A queue name can be passed as an argument, or the default queue
43 | name is used if none is given. See `./artisan queue:queuecheck --help` for full
44 | details.
45 | 
46 | Example cron job to check the default queue every 15 minutes:
47 | 
48 |     */15 * * * * php /home/forge/example.com/artisan queue:queuecheck
49 | 
50 | This task records in the application cache (for one day) that a check for this
51 | queue is pending, then pushes a job to this queue. This job changes that cached
52 | status to "OK", so if the job doesn't run for whatever reason the status will be
53 | left at "pending".
54 | 
55 | The status of all queue monitors can be checked by rendering one of the provided
56 | status views. The markup of the provided views are [Twitter
57 | Bootstrap](http://getbootstrap.com/)-friendly and if the `status-page` view is
58 | used Bootstrap is loaded from a CDN.
59 | 
60 | ```php
61 | Route::get('queue-monitor', function () {
62 |     return Response::view('queue-monitor::status-page');
63 | });
64 | ```
65 | 
66 | Other views available are `queue-monitor::status-panel`, which is the `.panel`
67 | element and its contents; and `queue-monitor::status`, which is just the `table`
68 | element. Either of these could be used to plug this monitor into a larger
69 | monitoring panel. A `panel_class` option can be passed, which defaults to
70 | `panel-default`.
71 | 
72 | There's also `queue-monitor::status-json`, which renders JSON suitable for
73 | machine consumption. This allows rendering options to be passed to the
74 | underlying `json_encode` and can be used like this:
75 | 
76 | ```php
77 | Route::get('queue-monitor.json', function () {
78 |     $response = Response::view('queue-monitor::status-json', [
79 |         'options' => \JSON_PRETTY_PRINT,
80 |     ]);
81 |     $response->header('Content-Type', 'application/json');
82 |     return $response;
83 | });
84 | ```
85 | 
86 | In practice you might set the cron job to run every 15 minutes, and then
87 | automate another job (such as with a remote health checker) to run a few minutes
88 | later, consume the JSON, and ensure all queues have the `ok` status. If any
89 | don't, it could send an alert with a link to the HTML queue status view. It
90 | could also check that the date at which the last check was queued is reasonable,
91 | and so that the cron job has not stopped working.
92 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "tremby/laravel-queue-monitor",
 3 |     "description": "Laravel queue monitoring tools",
 4 |     "require": {
 5 |         "php": ">=5.6.4",
 6 |         "laravel/framework": "~5.1"
 7 |     },
 8 |     "license": "MIT",
 9 |     "authors": [
10 |         {
11 |             "name": "Bart Nagel",
12 |             "email": "bart@tremby.net"
13 |         }
14 |     ],
15 |     "autoload": {
16 |         "psr-4": {
17 |             "Tremby\\QueueMonitor\\": "src/"
18 |         }
19 |     },
20 |     "extra": {
21 |         "laravel": {
22 |             "providers": [
23 |                 "Tremby\\QueueMonitor\\ServiceProvider"
24 |             ]
25 |         }
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/resources/views/date.blade.php:
--------------------------------------------------------------------------------
 1 | @if ($date)
 2 |     <time datetime="{{ $date->toW3cString() }}" title="{{ $date->format('r') }}">
 3 |         {{ $date->diffForHumans() }}
 4 |     </time>
 5 | @else
 6 |     <span class="text-muted">
 7 |         null
 8 |     </span>
 9 | @endif
10 | 


--------------------------------------------------------------------------------
/resources/views/status-json.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | echo json_encode($queues, @$options);
4 | 


--------------------------------------------------------------------------------
/resources/views/status-page.blade.php:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE HTML>
 2 | <html lang="en">
 3 |     <head>
 4 |         <meta charset="utf-8">
 5 |         <meta name="viewport" content="width=device-width, initial-scale=1">
 6 |         <title>Queue monitor</title>
 7 |         <link href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.5/css/bootstrap.min.css" rel="stylesheet">
 8 |         <!-- <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.5/js/bootstrap.min.js"></script> -->
 9 |     </head>
10 |     <body>
11 |         <div class="container-fluid">
12 |             @include('queue-monitor::status-panel')
13 |         </div>
14 |     </body>
15 | </html>
16 | 


--------------------------------------------------------------------------------
/resources/views/status-panel.blade.php:
--------------------------------------------------------------------------------
1 | <div class="panel {{ @$panel_class ?: 'panel-default' }}">
2 |     <div class="panel-heading">
3 |         <h3 class="panel-title">
4 |             Queue monitor
5 |         </h3>
6 |     </div>
7 |     @include('queue-monitor::status')
8 | </div>
9 | 


--------------------------------------------------------------------------------
/resources/views/status.blade.php:
--------------------------------------------------------------------------------
 1 | <table class="table">
 2 |     <thead>
 3 |         <th>
 4 |             Queue name
 5 |         </th>
 6 |         <th>
 7 |             Status
 8 |         </th>
 9 |         <th>
10 |             Details
11 |         </th>
12 |         <th>
13 |             Check queued
14 |         </th>
15 |         <th>
16 |             Queue job completed
17 |         </th>
18 |     </thead>
19 |     <tbody>
20 |         @foreach ($queues as $queueStatus)
21 |             <tr class="
22 |                 @if ($queueStatus->isError())
23 |                     danger
24 |                 @elseif ($queueStatus->isOk())
25 |                     success
26 |                 @elseif ($queueStatus->isPending())
27 |                     warning
28 |                 @endif
29 |             ">
30 |                 <td>
31 |                     <code>
32 |                         {{ $queueStatus->getQueueName() }}
33 |                     </code>
34 |                 </td>
35 |                 <td>
36 |                     {{ $queueStatus->getStatus() }}
37 |                 </td>
38 |                 <td>
39 |                     {{ $queueStatus->getMessage() }}
40 |                 </td>
41 |                 <td>
42 |                     @include('queue-monitor::date', ['date' => $queueStatus->getStartTime()])
43 |                 </td>
44 |                 <td>
45 |                     @include('queue-monitor::date', ['date' => $queueStatus->getEndTime()])
46 |                     @if (($start = $queueStatus->getStartTime()) && ($end = $queueStatus->getEndTime()))
47 |                         <span class="text-muted">
48 |                             ({{ $end->diffForHumans($start) }})
49 |                         </span>
50 |                     @endif
51 |                 </td>
52 |             </tr>
53 |         @endforeach
54 |     </tbody>
55 | </table>
56 | 


--------------------------------------------------------------------------------
/src/Command/QueueQueueCheckCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Tremby\QueueMonitor\Command;
 3 | 
 4 | use Illuminate\Console\Command;
 5 | use Symfony\Component\Console\Input\InputArgument;
 6 | use Symfony\Component\Console\Input\InputOption;
 7 | use Tremby\QueueMonitor\QueueMonitor;
 8 | 
 9 | class QueueQueueCheckCommand extends Command
10 | {
11 |     /**
12 |      * The console command name.
13 |      *
14 |      * @var string
15 |      */
16 |     protected $name = 'queue:queuecheck';
17 | 
18 |     /**
19 |      * The console command description.
20 |      *
21 |      * @var string
22 |      */
23 |     protected $description = "Queue a check to make sure a queue is functioning properly";
24 | 
25 |     /**
26 |      * Create a new command instance.
27 |      *
28 |      * @return void
29 |      */
30 |     public function __construct()
31 |     {
32 |         parent::__construct();
33 |     }
34 | 
35 |     /**
36 |      * Execute the console command for Laravel 5.4 or older
37 |      *
38 |      * @return mixed
39 |      */
40 |     public function fire()
41 |     {
42 |         QueueMonitor::queueQueueCheck($this->argument('queue'));
43 |     }
44 | 
45 |     /**
46 |      * Execute the console command for Laravel 5.5+
47 |      *
48 |      * @return mixed
49 |      */
50 |     public function handle()
51 |     {
52 |         $this->fire();
53 |     }
54 | 
55 |     /**
56 |      * Get the console command arguments.
57 |      *
58 |      * @return array
59 |      */
60 |     protected function getArguments()
61 |     {
62 |         return [
63 |             [
64 |                 'queue',
65 |                 InputArgument::OPTIONAL,
66 |                 "Queue to queue a check for"
67 |                 . " (default is the application's default queue)",
68 |                 null,
69 |             ],
70 |         ];
71 |     }
72 | 
73 |     /**
74 |      * Get the console command options.
75 |      *
76 |      * @return array
77 |      */
78 |     protected function getOptions()
79 |     {
80 |         return [];
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/src/Job.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Tremby\QueueMonitor;
 3 | 
 4 | use Carbon\Carbon;
 5 | use Illuminate\Bus\Queueable;
 6 | use Illuminate\Contracts\Logging\Log;
 7 | use Illuminate\Contracts\Queue\ShouldQueue;
 8 | use Illuminate\Queue\InteractsWithQueue;
 9 | 
10 | class Job implements ShouldQueue
11 | {
12 |     use Queueable;
13 |     use InteractsWithQueue;
14 | 
15 |     /**
16 |      * @var string
17 |      */
18 |     protected $queueName;
19 | 
20 |     /**
21 |      * @var Carbon
22 |      */
23 |     protected $startTime;
24 | 
25 |     /**
26 |      * Make a new instance
27 |      *
28 |      * @param string $queueName Queue connection name
29 |      * @param Carbon $startTime Queue checker start time
30 |      * @return void
31 |      */
32 |     public function __construct($queueName, Carbon $startTime)
33 |     {
34 |         $this->queueName = $queueName;
35 |         $this->startTime = $startTime;
36 |     }
37 | 
38 |     /**
39 |      * Execute the job
40 |      *
41 |      * @param Log $log
42 |      * @return void
43 |      */
44 |     public function handle(Log $log)
45 |     {
46 |         $log->debug("Handling check job for queue '{$this->queueName}', queued at {$this->startTime}");
47 |         $status = QueueStatus::get($this->queueName);
48 |         if (!$status) {
49 |             $message = "Queue status was not found in cache, yet queued job ran; is the cache correctly configured?";
50 |             $log->error($message);
51 |             $status = new QueueStatus($this->queueName, QueueStatus::ERROR);
52 |             $status->setMessage($message);
53 |             $status->setEndTime();
54 |             $status->save();
55 |         } elseif (!$status->isPending()) {
56 |             $log->warning("Non-pending status for check for queue '{$this->queueName}' found in the cache; ignoring: " . $status);
57 |         } elseif (!$status->getStartTime() || $status->getStartTime()->ne($this->startTime)) {
58 |             $log->warning("Pending status for check for queue '{$this->queueName}' found in the cache with mismatching time (expected {$this->startTime}, found {$status->getStartTime()}); ignoring: " . $status);
59 |         } else {
60 |             $log->debug("Successful queue check for queue '{$this->queueName}'");
61 |             $status->setStatus(QueueStatus::OK);
62 |             $status->setEndTime();
63 |             $status->save();
64 |         }
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/QueueChecker.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Tremby\QueueMonitor;
 3 | 
 4 | use Carbon\Carbon;
 5 | use Queue;
 6 | 
 7 | class QueueChecker
 8 | {
 9 |     /**
10 |      * @var string
11 |      */
12 |     private $queueName;
13 | 
14 |     /**
15 |      * @var int
16 |      */
17 |     private $startTime;
18 | 
19 |     /**
20 |      * Make a new instance
21 |      *
22 |      * @param string $queueName Queue name
23 |      */
24 |     public function __construct($queueName)
25 |     {
26 |         $this->queueName = $queueName;
27 |         $this->startTime = Carbon::now();
28 |     }
29 | 
30 |     /**
31 |      * Cache the fact that a queue check has been queued, and queue the check
32 |      *
33 |      * @return void
34 |      */
35 |     public function queueCheck()
36 |     {
37 |         $status = new QueueStatus($this->queueName, QueueStatus::PENDING, $this->startTime);
38 |         $status->save();
39 | 
40 |         Queue::pushOn(
41 |             $this->queueName,
42 |             new Job($this->queueName, $this->startTime)
43 |         );
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/QueueMonitor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Tremby\QueueMonitor;
 3 | 
 4 | use Cache;
 5 | use Config;
 6 | 
 7 | class QueueMonitor
 8 | {
 9 |     const CACHE_KEY_PREFIX = 'queue-monitor:';
10 |     const QUEUES_CACHE_KEY = self::CACHE_KEY_PREFIX . 'queues';
11 | 
12 |     /**
13 |      * Get a cache key for the check status of a queue by name
14 |      *
15 |      * @param string $queueName
16 |      * @return string
17 |      */
18 |     public static function getCheckCacheKey($queueName)
19 |     {
20 | 
21 |         return self::CACHE_KEY_PREFIX . 'status:' . $queueName;
22 |     }
23 | 
24 |     /**
25 |      * Queue a queue check
26 |      *
27 |      * @param string $queueName Queue to queue a check for, or null for the
28 |      * application's default queue
29 |      * @return void
30 |      */
31 |     public static function queueQueueCheck($queueName = null)
32 |     {
33 |         // Get the default queue name if none was given
34 |         if (is_null($queueName)) {
35 |             $queueName = Config::get('queue.connections.' . Config::get('queue.default') . '.queue');
36 |         }
37 | 
38 |         // Store this queue name in the monitored queues list
39 |         $queues = Cache::get(self::QUEUES_CACHE_KEY, []);
40 |         if (!in_array($queueName, $queues)) {
41 |             $queues[] = $queueName;
42 |             Cache::forever(self::QUEUES_CACHE_KEY, $queues);
43 |         }
44 | 
45 |         // Add a queue job for this queue
46 |         $checker = new QueueChecker($queueName);
47 |         $checker->queueCheck();
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/QueueStatus.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Tremby\QueueMonitor;
  3 | 
  4 | use Cache;
  5 | use Carbon\Carbon;
  6 | use Illuminate\Contracts\Support\Arrayable;
  7 | use Illuminate\Contracts\Support\Jsonable;
  8 | use JsonSerializable;
  9 | 
 10 | class QueueStatus implements
 11 |     Arrayable,
 12 |     JsonSerializable,
 13 |     Jsonable
 14 | {
 15 |     const ERROR = 'error';
 16 |     const PENDING = 'pending';
 17 |     const OK = 'ok';
 18 | 
 19 |     /**
 20 |      * @var string
 21 |      */
 22 |     protected $queueName;
 23 | 
 24 |     /**
 25 |      * @var string
 26 |      */
 27 |     protected $status;
 28 | 
 29 |     /**
 30 |      * @var string
 31 |      */
 32 |     protected $message;
 33 | 
 34 |     /**
 35 |      * @var Carbon
 36 |      */
 37 |     protected $startTime = null;
 38 | 
 39 |     /**
 40 |      * @var Carbon
 41 |      */
 42 |     protected $endTime = null;
 43 | 
 44 |     /**
 45 |      * Make a new instance
 46 |      *
 47 |      * @param string $queueName Queue name
 48 |      * @param string $status Status constant
 49 |      * @param Carbon|null $startTime Start time to set if appropriate, such as
 50 |      * when the job was queued
 51 |      */
 52 |     public function __construct($queueName, $status, $startTime = null)
 53 |     {
 54 |         $this->queueName = $queueName;
 55 |         $this->status = $status;
 56 |         if ($startTime) {
 57 |             $this->startTime = $startTime;
 58 |         }
 59 |     }
 60 | 
 61 |     /**
 62 |      * Get the queue name
 63 |      *
 64 |      * @return string
 65 |      */
 66 |     public function getQueueName()
 67 |     {
 68 |         return $this->queueName;
 69 |     }
 70 | 
 71 |     /**
 72 |      * Get the status
 73 |      *
 74 |      * @return string
 75 |      */
 76 |     public function getStatus()
 77 |     {
 78 |         return $this->status;
 79 |     }
 80 | 
 81 |     /**
 82 |      * Is this queue pending its queued job?
 83 |      *
 84 |      * @return bool
 85 |      */
 86 |     public function isPending()
 87 |     {
 88 |         return $this->getStatus() === self::PENDING;
 89 |     }
 90 | 
 91 |     /**
 92 |      * Is this queue OK?
 93 |      *
 94 |      * @return bool
 95 |      */
 96 |     public function isOk()
 97 |     {
 98 |         return $this->getStatus() === self::OK;
 99 |     }
100 | 
101 |     /**
102 |      * Does this queue have an error status?
103 |      *
104 |      * @return bool
105 |      */
106 |     public function isError()
107 |     {
108 |         return $this->getStatus() === self::ERROR;
109 |     }
110 | 
111 |     /**
112 |      * Set the status
113 |      *
114 |      * @param string $status Status constant
115 |      * @return void
116 |      */
117 |     public function setStatus($status)
118 |     {
119 |         $this->status = $status;
120 |     }
121 | 
122 |     /**
123 |      * Get the start time
124 |      *
125 |      * @return Carbon
126 |      */
127 |     public function getStartTime()
128 |     {
129 |         return $this->startTime;
130 |     }
131 | 
132 |     /**
133 |      * Get the end time
134 |      *
135 |      * @return Carbon
136 |      */
137 |     public function getEndTime()
138 |     {
139 |         return $this->endTime;
140 |     }
141 | 
142 |     /**
143 |      * Set the end time
144 |      *
145 |      * @param Carbon $endTime End time, or null for the current time
146 |      * @return void
147 |      */
148 |     public function setEndTime(Carbon $endTime = null)
149 |     {
150 |         if ($endTime) {
151 |             $this->endTime = $endTime;
152 |         } else {
153 |             $this->endTime = Carbon::now();
154 |         }
155 |     }
156 | 
157 |     /**
158 |      * Get the message
159 |      *
160 |      * @return string
161 |      */
162 |     public function getMessage()
163 |     {
164 |         return $this->message;
165 |     }
166 | 
167 |     /**
168 |      * Set the message
169 |      *
170 |      * @param string $message
171 |      * @return void
172 |      */
173 |     public function setMessage($message)
174 |     {
175 |         $this->message = $message;
176 |     }
177 | 
178 |     /**
179 |      * Save in cache
180 |      *
181 |      * @return void
182 |      */
183 |     public function save()
184 |     {
185 |         Cache::forever(QueueMonitor::getCheckCacheKey($this->getQueueName()), $this);
186 |     }
187 | 
188 |     /**
189 |      * {@inheritDoc}
190 |      */
191 |     public function toJson($options = 0)
192 |     {
193 |         return json_encode($this->toArray(), $options);
194 |     }
195 | 
196 |     /**
197 |      * {@inheritDoc}
198 |      */
199 |     public function jsonSerialize()
200 |     {
201 |         return $this->toArray();
202 |     }
203 | 
204 |     /**
205 |      * {@inheritDoc}
206 |      */
207 |     public function toArray()
208 |     {
209 |         return [
210 |             'queueName' => $this->getQueueName(),
211 |             'status' => $this->getStatus(),
212 |             'message' => $this->getMessage(),
213 |             'startTime' => $this->getStartTime(),
214 |             'startTimeDiff' => $this->getStartTime() ? $this->getStartTime()->diffInSeconds(null, false) : null,
215 |             'endTime' => $this->getEndTime(),
216 |             'endTimeDiff' => $this->getEndTime() ? $this->getEndTime()->diffInSeconds(null, false) : null,
217 |         ];
218 |     }
219 | 
220 |     /**
221 |      * {@inheritDoc}
222 |      */
223 |     public function __toString()
224 |     {
225 |         return $this->toJson();
226 |     }
227 | 
228 |     /**
229 |      * Get an instance from cache by queue name
230 |      *
231 |      * @param string $queueName
232 |      * @return QueueStatus
233 |      */
234 |     public static function get($queueName)
235 |     {
236 |         return Cache::get(QueueMonitor::getCheckCacheKey($queueName));
237 |     }
238 | }
239 | 


--------------------------------------------------------------------------------
/src/ServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Tremby\QueueMonitor;
 3 | 
 4 | use Illuminate\Contracts\Cache\Repository as CacheRepository;
 5 | use Illuminate\Contracts\View\Factory as ViewFactory;
 6 | use Illuminate\Support\ServiceProvider as BaseServiceProvider;
 7 | 
 8 | class ServiceProvider extends BaseServiceProvider
 9 | {
10 |     /**
11 |      * {@inheritDoc}
12 |      */
13 |     public function register()
14 |     {
15 |         $this->commands([
16 |             Command\QueueQueueCheckCommand::class,
17 |         ]);
18 |     }
19 | 
20 |     /**
21 |      * {@inheritDoc}
22 |      */
23 |     public function boot(ViewFactory $viewFactory, CacheRepository $cache)
24 |     {
25 |         // Define views path
26 |         $this->loadViewsFrom(__DIR__ . '/../resources/views', 'queue-monitor');
27 | 
28 |         // Composer for the status views
29 |         $composer = function ($view) use ($cache) {
30 |             $queues = [];
31 |             foreach ($cache->get(QueueMonitor::QUEUES_CACHE_KEY, []) as $queueName) {
32 |                 $status = QueueStatus::get($queueName);
33 |                 if (!$status) {
34 |                     $status = new QueueStatus($queueName, QueueStatus::ERROR);
35 |                     $status->setMessage("Status not found in cache; is a cron job set up and running?");
36 |                 }
37 |                 $queues[$queueName] = $status;
38 |             }
39 |             $view->withQueues($queues);
40 |         };
41 |         $viewFactory->composer('queue-monitor::status', $composer);
42 |         $viewFactory->composer('queue-monitor::status-json', $composer);
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------