1# Queue System
2 
3## Job Patterns
4 
5```php
6namespace App\Jobs;
7 
8use App\Models\Post;
9use App\Models\User;
10use Illuminate\Bus\Queueable;
11use Illuminate\Contracts\Queue\ShouldQueue;
12use Illuminate\Foundation\Bus\Dispatchable;
13use Illuminate\Queue\InteractsWithQueue;
14use Illuminate\Queue\SerializesModels;
15 
16class ProcessPost implements ShouldQueue
17{
18    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
19 
20    public $tries = 3;
21    public $timeout = 120;
22    public $maxExceptions = 3;
23    public $backoff = [60, 120, 300]; // Exponential backoff
24 
25    public function __construct(
26        public Post $post,
27        public ?User $user = null,
28    ) {}
29 
30    public function handle(): void
31    {
32        // Process the post
33        $this->post->update(['processed' => true]);
34 
35        // Can access injected dependencies
36        $analytics = app(AnalyticsService::class);
37        $analytics->trackPostProcessed($this->post);
38    }
39 
40    public function failed(\Throwable $exception): void
41    {
42        // Handle job failure
43        \Log::error('Post processing failed', [
44            'post_id' => $this->post->id,
45            'error' => $exception->getMessage(),
46        ]);
47    }
48}
49```
50 
51## Dispatching Jobs
52 
53```php
54use App\Jobs\ProcessPost;
55 
56// Dispatch immediately
57ProcessPost::dispatch($post);
58 
59// Dispatch to specific queue
60ProcessPost::dispatch($post)->onQueue('processing');
61 
62// Delayed dispatch
63ProcessPost::dispatch($post)->delay(now()->addMinutes(10));
64 
65// Dispatch after database commit
66ProcessPost::dispatch($post)->afterCommit();
67 
68// Dispatch conditionally
69ProcessPost::dispatchIf($condition, $post);
70ProcessPost::dispatchUnless($condition, $post);
71 
72// Synchronous dispatch (no queue)
73ProcessPost::dispatchSync($post);
74 
75// Dispatch after response
76ProcessPost::dispatchAfterResponse($post);
77```
78 
79## Job Chaining
80 
81```php
82use App\Jobs\{OptimizeImage, GenerateThumbnail, PublishPost};
83 
84// Chain jobs
85OptimizeImage::withChain([
86    new GenerateThumbnail($post),
87    new PublishPost($post),
88])->dispatch($post);
89 
90// Catch failures in chain
91Bus::chain([
92    new ProcessPost($post),
93    new NotifyUser($user),
94])->catch(function (\Throwable $e) {
95    // Handle failure
96})->dispatch();
97```
98 
99## Job Batching
100 
101```php
102use Illuminate\Bus\Batch;
103use Illuminate\Support\Facades\Bus;
104 
105$batch = Bus::batch([
106    new ProcessPost($post1),
107    new ProcessPost($post2),
108    new ProcessPost($post3),
109])->then(function (Batch $batch) {
110    // All jobs completed successfully
111})->catch(function (Batch $batch, \Throwable $e) {
112    // First batch job failure detected
113})->finally(function (Batch $batch) {
114    // The batch has finished executing
115})->name('Process Posts')
116->allowFailures()
117->dispatch();
118 
119// Check batch status
120$batch = Bus::findBatch($batchId);
121if ($batch->finished()) {
122    // Batch is complete
123}
124if ($batch->cancelled()) {
125    // Batch was cancelled
126}
127 
128// Add jobs to existing batch
129$batch->add([
130    new ProcessPost($post4),
131]);
132```
133 
134## Rate Limiting
135 
136```php
137use Illuminate\Support\Facades\Redis;
138 
139class ProcessPost implements ShouldQueue
140{
141    public function handle(): void
142    {
143        Redis::throttle('process-posts')
144            ->block(0)
145            ->allow(10)
146            ->every(60)
147            ->then(function () {
148                // Lock acquired, process job
149            }, function () {
150                // Could not acquire lock, release job back
151                $this->release(10);
152            });
153    }
154}
155 
156// Or using middleware
157use Illuminate\Queue\Middleware\RateLimited;
158 
159public function middleware(): array
160{
161    return [new RateLimited('process-posts')];
162}
163```
164 
165## Job Middleware
166 
167```php
168namespace App\Jobs\Middleware;
169 
170class RateLimitedByUser
171{
172    public function handle($job, $next): void
173    {
174        Redis::throttle("user:{$job->user->id}")
175            ->allow(10)
176            ->every(60)
177            ->then(function () use ($job, $next) {
178                $next($job);
179            }, function () use ($job) {
180                $job->release(10);
181            });
182    }
183}
184 
185// Use in job
186use App\Jobs\Middleware\RateLimitedByUser;
187 
188public function middleware(): array
189{
190    return [new RateLimitedByUser];
191}
192 
193// Skip middleware
194use Illuminate\Queue\Middleware\WithoutOverlapping;
195 
196public function middleware(): array
197{
198    return [
199        (new WithoutOverlapping($this->user->id))->expireAfter(180),
200    ];
201}
202```
203 
204## Unique Jobs
205 
206```php
207use Illuminate\Contracts\Queue\ShouldBeUnique;
208 
209class ProcessPost implements ShouldQueue, ShouldBeUnique
210{
211    public int $uniqueFor = 3600;
212 
213    public function __construct(
214        public Post $post,
215    ) {}
216 
217    public function uniqueId(): string
218    {
219        return $this->post->id;
220    }
221}
222 
223// Or use unique until processing
224use Illuminate\Contracts\Queue\ShouldBeUniqueUntilProcessing;
225 
226class ProcessPost implements ShouldQueue, ShouldBeUniqueUntilProcessing
227{
228    // ...
229}
230```
231 
232## Failed Jobs
233 
234```php
235// Retry failed job
236php artisan queue:retry <job-id>
237 
238// Retry all failed jobs
239php artisan queue:retry all
240 
241// Flush failed jobs
242php artisan queue:flush
243 
244// Prune failed jobs
245php artisan queue:prune-failed --hours=48
246 
247// Handle in code
248use Illuminate\Support\Facades\Queue;
249 
250Queue::failing(function (JobFailed $event) {
251    \Log::error('Job failed', [
252        'connection' => $event->connectionName,
253        'queue' => $event->job->getQueue(),
254        'exception' => $event->exception->getMessage(),
255    ]);
256});
257```
258 
259## Queue Workers
260 
261```bash
262# Start worker
263php artisan queue:work
264 
265# Process specific queue
266php artisan queue:work --queue=high,default
267 
268# Process one job
269php artisan queue:work --once
270 
271# Stop worker gracefully
272php artisan queue:restart
273 
274# Timeout settings
275php artisan queue:work --timeout=60
276 
277# Memory limit
278php artisan queue:work --memory=512
279 
280# Max jobs before restart
281php artisan queue:work --max-jobs=1000
282 
283# Max time before restart
284php artisan queue:work --max-time=3600
285```
286 
287## Horizon Setup
288 
289```php
290// config/horizon.php
291return [
292    'environments' => [
293        'production' => [
294            'supervisor-1' => [
295                'connection' => 'redis',
296                'queue' => ['default'],
297                'balance' => 'auto',
298                'maxProcesses' => 10,
299                'maxTime' => 0,
300                'maxJobs' => 0,
301                'memory' => 512,
302                'tries' => 3,
303                'timeout' => 60,
304                'nice' => 0,
305            ],
306            'supervisor-2' => [
307                'connection' => 'redis',
308                'queue' => ['high', 'default'],
309                'balance' => 'auto',
310                'maxProcesses' => 5,
311                'tries' => 3,
312            ],
313        ],
314    ],
315];
316 
317// Start Horizon
318php artisan horizon
319 
320// Terminate Horizon
321php artisan horizon:terminate
322 
323// Pause workers
324php artisan horizon:pause
325 
326// Continue workers
327php artisan horizon:continue
328 
329// Check status
330php artisan horizon:status
331```
332 
333## Monitoring
334 
335```php
336use Illuminate\Queue\Events\JobProcessed;
337use Illuminate\Queue\Events\JobFailed;
338use Illuminate\Support\Facades\Queue;
339 
340// In AppServiceProvider
341public function boot(): void
342{
343    Queue::before(function (JobProcessing $event) {
344        // Called before job is processed
345    });
346 
347    Queue::after(function (JobProcessed $event) {
348        // Called after job is processed
349        \Log::info('Job processed', [
350            'job' => $event->job->resolveName(),
351            'time' => $event->job->processingTime(),
352        ]);
353    });
354 
355    Queue::failing(function (JobFailed $event) {
356        // Called when job fails
357        \Log::error('Job failed', [
358            'job' => $event->job->resolveName(),
359            'exception' => $event->exception,
360        ]);
361    });
362}
363```
364 
365## Queue Configuration
366 
367```php
368// config/queue.php
369return [
370    'default' => env('QUEUE_CONNECTION', 'sync'),
371 
372    'connections' => [
373        'sync' => [
374            'driver' => 'sync',
375        ],
376 
377        'database' => [
378            'driver' => 'database',
379            'table' => 'jobs',
380            'queue' => 'default',
381            'retry_after' => 90,
382            'after_commit' => false,
383        ],
384 
385        'redis' => [
386            'driver' => 'redis',
387            'connection' => 'default',
388            'queue' => env('REDIS_QUEUE', 'default'),
389            'retry_after' => 90,
390            'block_for' => null,
391            'after_commit' => false,
392        ],
393 
394        'sqs' => [
395            'driver' => 'sqs',
396            'key' => env('AWS_ACCESS_KEY_ID'),
397            'secret' => env('AWS_SECRET_ACCESS_KEY'),
398            'prefix' => env('SQS_PREFIX'),
399            'queue' => env('SQS_QUEUE'),
400            'region' => env('AWS_DEFAULT_REGION'),
401        ],
402    ],
403 
404    'failed' => [
405        'driver' => env('QUEUE_FAILED_DRIVER', 'database-uuids'),
406        'database' => env('DB_CONNECTION', 'mysql'),
407        'table' => 'failed_jobs',
408    ],
409];
410```
411 
412## Best Practices
413 
4141. **Keep jobs small and focused** - Single responsibility
4152. **Make jobs idempotent** - Safe to run multiple times
4163. **Use type hints** - Better error detection
4174. **Set reasonable timeouts** - Prevent hanging jobs
4185. **Monitor failed jobs** - Set up alerts
4196. **Use batching for bulk operations** - Better performance
4207. **Implement proper error handling** - Use failed() method
4218. **Use unique jobs** - Prevent duplicate processing
4229. **Queue long-running tasks** - Don't block requests
42310. **Use Horizon for Redis queues** - Better monitoring
424