Laravel Queue RabbitMQ

https://github.com/websolutionfalcon/laravel-queue-rabbitmq
Admin
A RabbitMQ queue driver for Laravel that provides robust message queuing, including support for...
Tokens:12,327
Snippets:92
Trust Score:3.7
License:MIT
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install Delayed Message Exchange Plugin for RabbitMQ

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

These bash commands demonstrate how to install and enable the `rabbitmq_delayed_message_exchange` plugin on RabbitMQ servers. It includes steps for different RabbitMQ versions and verification.

```bash
# For RabbitMQ 3.x
rabbitmq-plugins enable rabbitmq_delayed_message_exchange

# For RabbitMQ 4.x, you may need to download it first:
cd /opt/rabbitmq/plugins
wget https://github.com/rabbitmq/rabbitmq-delayed-message-exchange/releases/download/v4.1.0/rabbitmq_delayed_message_exchange-4.1.0.ez
rabbitmq-plugins enable rabbitmq_delayed_message_exchange

# Verify the plugin is enabled
rabbitmq-plugins list | grep delayed
```

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

### Install RabbitMQ Queue Driver for Laravel

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

Installs the RabbitMQ queue driver package for Laravel using Composer. This command adds the necessary dependencies to your project.

```bash
composer require websolutionfalcon/laravel-queue-rabbitmq
```

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

### Run RabbitMQ Docker Compose in Bash

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

This bash command starts the RabbitMQ service using Docker Compose. It assumes a `docker-compose.yml` file is present in the current directory. This is typically used for setting up a testing environment.

```bash
docker compose up -d
```

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

### Set RabbitMQ Delayed Message Environment Variables

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

This example demonstrates how to configure RabbitMQ delayed message strategies using environment variables in a .env file. It allows for easy switching between strategies and defining exchange parameters.

```bash
# .env
RABBITMQ_DELAY_STRATEGY=plugin
RABBITMQ_DELAYED_EXCHANGE=delayed
RABBITMQ_DELAYED_EXCHANGE_TYPE=direct
```

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

### Install Delayed Message Exchange Plugin via Dockerfile

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

This Dockerfile snippet shows how to install the `rabbitmq_delayed_message_exchange` plugin within a RabbitMQ Docker image. It downloads the plugin, enables it offline, and cleans up.

```dockerfile
FROM rabbitmq:4.1-management-alpine

# Download and install the plugin
RUN apk add --no-cache wget && \
    cd /opt/rabbitmq/plugins && \
    wget https://github.com/rabbitmq/rabbitmq-delayed-message-exchange/releases/download/v4.1.0/rabbitmq_delayed_message_exchange-4.1.0.ez && \
    rabbitmq-plugins enable --offline rabbitmq_delayed_message_exchange && \
    apk del wget
```

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

### Dispatching Delayed Jobs in Laravel

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

These PHP examples illustrate how to dispatch jobs with delays using Laravel's Queue API. It shows delaying jobs by specific seconds, minutes, or using `laterOn` and `later` methods.

```php
use App\Jobs\ProcessPodcast;

// Delay a job by 60 seconds
ProcessPodcast::dispatch($podcast)->delay(now()->addSeconds(60));

// Delay a job by 5 minutes
ProcessPodcast::dispatch($podcast)->delay(now()->addMinutes(5));

// Using laterOn with queue name
Queue::laterOn('rabbitmq', now()->addMinutes(10), new ProcessPodcast($podcast));

// Using later with default queue
Queue::later(now()->addHour(), new ProcessPodcast($podcast));
```

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

### Custom RabbitMQJob for Arbitrary Class Execution

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

An example of a custom RabbitMQJob class that allows for executing an arbitrary class and method with a custom payload structure. This provides flexibility when the incoming message format doesn't directly map to Laravel jobs.

```php
<?php

namespace App\Queue\Jobs;

use VladimirYuldashev\LaravelQueueRabbitMQ\Queue\Jobs\RabbitMQJob as BaseJob;

class RabbitMQJob extends BaseJob
{

    /**
     * Fire the job.
     *
     * @return void
     */
    public function fire()
    {
        $payload = $this->payload();

        $class = WhatheverClassNameToExecute::class;
        $method = 'handle';

        ($this->instance = $this->resolve($class))->{$method}($this, $payload);

        $this->delete();
    }
}
```

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

### Implement Reconnect Logic for RabbitMQ Queue

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

An example of how to override publish and createChannel methods in a custom RabbitMQQueue class to automatically reconnect if the connection is lost. This provides resilience against temporary network issues.

```php
<?php

namespace App\Queue;

use PhpAmqpLib\Exception\AMQPChannelClosedException;
use PhpAmqpLib\Exception\AMQPConnectionClosedException;
use VladimirYuldashev\LaravelQueueRabbitMQ\Queue\RabbitMQQueue as BaseRabbitMQQueue;

class RabbitMQQueue extends BaseRabbitMQQueue
{

    protected function publishBasic($msg, $exchange = '', $destination = '', $mandatory = false, $immediate = false, $ticket = null): void
    {
        try {
            parent::publishBasic($msg, $exchange, $destination, $mandatory, $immediate, $ticket);
        } catch (AMQPConnectionClosedException|AMQPChannelClosedException) {
            $this->reconnect();
            parent::publishBasic($msg, $exchange, $destination, $mandatory, $immediate, $ticket);
        }
    }

    protected function publishBatch($jobs, $data = '', $queue = null): void
    {
        try {
            parent::publishBatch($jobs, $data, $queue);
        } catch (AMQPConnectionClosedException|AMQPChannelClosedException) {
            $this->reconnect();
            parent::publishBatch($jobs, $data, $queue);
        }
    }

    protected function createChannel(): AMQPChannel
    {
        try {
            return parent::createChannel();
        } catch (AMQPConnectionClosedException) {
            $this->reconnect();
            return parent::createChannel();
        }
    }
}
```

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

### Custom RabbitMQJob for Basic Payload Handling

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

An example of a custom RabbitMQJob class that overrides the 'payload' method to manually construct the job payload. This is useful when dealing with messages from external applications that might have a different structure.

```php
<?php

namespace App\Queue\Jobs;

use VladimirYuldashev\LaravelQueueRabbitMQ\Queue\Jobs\RabbitMQJob as BaseJob;

class RabbitMQJob extends BaseJob
{
   /**
     * Get the decoded body of the job.
     *
     * @return array
     */
    public function payload()
    {
        return [
            'job'  => 'WhatheverFullyQualifiedClassNameToExecute@handle',
            'data' => json_decode($this->getRawBody(), true)
        ];
    }
}
```

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

### Manage RabbitMQ Failed Job Rerouting (Bash)

Source: https://context7.com/websolutionfalcon/laravel-queue-rabbitmq/llms.txt

Use Artisan commands to declare the necessary RabbitMQ exchange and queue for failed jobs, bind them, and then configure the queue worker to consume from the failed jobs queue. This setup ensures failed jobs are isolated for later inspection.

```bash
# First, declare the failed jobs exchange and queue
php artisan rabbitmq:exchange-declare failed-jobs --type=topic --durable=1
php artisan rabbitmq:queue-declare failed-jobs-queue --durable=1
php artisan rabbitmq:queue-bind failed-jobs-queue failed-jobs --routing-key="app.*.failed"

# Failed jobs will now be routed to failed-jobs-queue
# You can consume and inspect them later
php artisan queue:work rabbitmq --queue=failed-jobs-queue

```

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

### Run Test Suite in Bash

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

These bash commands are used to execute the test suite for the laravel-queue-rabbitmq package. `composer test` runs all tests, while `composer test:style` and `composer test:unit` run specific test categories.

```bash
# To run both style and unit tests.
composer test

# To run only style tests.
composer test:style

# To run only unit tests.
composer test:unit
```

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

### Register Lumen Service Provider in PHP

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

This PHP code demonstrates how to manually register the service provider for the laravel-queue-rabbitmq package in a Lumen application. This is necessary for Lumen usage and should be added to the `bootstrap/app.php` file.

```php
$app->register(VladimirYuldashev\LaravelQueueRabbitMQ\LaravelQueueRabbitMQServiceProvider::class);
```

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

### Manage RabbitMQ Exchanges with Laravel Artisan

Source: https://context7.com/websolutionfalcon/laravel-queue-rabbitmq/llms.txt

Provides commands for declaring and deleting RabbitMQ exchanges. Supports specifying exchange types (direct, topic) and durability. These commands allow direct management of exchange configurations from the command line.

```bash
php artisan rabbitmq:exchange-declare my-exchange --type=direct --durable=1
```

```bash
php artisan rabbitmq:exchange-declare events --type=topic --durable=1 --auto-delete=0
```

```bash
php artisan rabbitmq:exchange-delete my-exchange
```

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

### Consume RabbitMQ Messages with Laravel Artisan

Source: https://context7.com/websolutionfalcon/laravel-queue-rabbitmq/llms.txt

Demonstrates various ways to consume messages from RabbitMQ queues using the `php artisan rabbitmq:consume` command. Options include specifying queue names, worker names, memory limits, retries, timeouts, and controlling consumption behavior like stopping when empty or processing a single job.

```bash
php artisan rabbitmq:consume rabbitmq --queue=default
```

```bash
php artisan rabbitmq:consume rabbitmq --name=worker1 --queue=podcasts --memory=256
```

```bash
php artisan rabbitmq:consume rabbitmq \
    --queue=default \
    --name=production-worker \
    --tries=3 \
    --timeout=60 \
    --memory=512 \
    --sleep=3 \
    --rest=1 \
    --max-jobs=1000 \
    --max-time=3600 \
    --prefetch-count=100 \
    --prefetch-size=0
```

```bash
php artisan rabbitmq:consume rabbitmq --queue=batch-jobs --stop-when-empty
```

```bash
php artisan rabbitmq:consume rabbitmq --queue=default --once
```

```bash
php artisan rabbitmq:consume rabbitmq --queue=priority-queue --max-priority=10
```

```bash
php artisan rabbitmq:consume rabbitmq --queue=critical --force
```

```bash
php artisan queue:work rabbitmq --queue=high,default,low
```

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

### Manage RabbitMQ Queues with Laravel Artisan

Source: https://context7.com/websolutionfalcon/laravel-queue-rabbitmq/llms.txt

Offers commands for declaring, deleting, binding, and purging RabbitMQ queues. Supports durable and priority queues, as well as quorum queues for high availability. Binding commands allow associating queues with exchanges using routing keys.

```bash
php artisan rabbitmq:queue-declare my-queue --durable=1
```

```bash
php artisan rabbitmq:queue-declare priority-queue --durable=1 --max-priority=10
```

```bash
php artisan rabbitmq:queue-declare ha-queue --durable=1 --quorum=1
```

```bash
php artisan rabbitmq:queue-delete my-queue
```

```bash
php artisan rabbitmq:queue-bind my-queue my-exchange --routing-key=my.routing.key
```

```bash
php artisan rabbitmq:queue-bind events-queue events --routing-key="user.*"
```

```bash
php artisan rabbitmq:queue-purge my-queue
```

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

### Configure DLX Delay Strategy in Laravel

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

This PHP configuration snippet shows how to set the 'dlx' delay strategy for RabbitMQ in Laravel. This is the default strategy and requires no additional plugins.

```php
'connections' => [
    'rabbitmq' => [
        // ...

        'options' => [
            'queue' => [
                'delay_strategy' => 'dlx', // This is the default, can be omitted
            ],
        ],
    ],
],
```

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

### Configure RabbitMQ Connection in Laravel

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

Sets up a new 'rabbitmq' connection in Laravel's queue configuration file (config/queue.php). This minimal configuration enables the RabbitMQ driver and specifies connection details like host, port, user, password, and virtual host.

```php
'connections' => [
    // ...

    'rabbitmq' => [
    
       'driver' => 'rabbitmq',
       'hosts' => [
           [
               'host' => env('RABBITMQ_HOST', '127.0.0.1'),
               'port' => env('RABBITMQ_PORT', 5672),
               'user' => env('RABBITMQ_USER', 'guest'),
               'password' => env('RABBITMQ_PASSWORD', 'guest'),
               'vhost' => env('RABBITMQ_VHOST', '/'),
           ],
           // ...
       ],

       // ...
    ],

    // ...    
]
```

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

### Configure SSL/TLS Secure Connection for RabbitMQ (PHP & .env)

Source: https://context7.com/websolutionfalcon/laravel-queue-rabbitmq/llms.txt

Sets up secure, encrypted communication with RabbitMQ using SSL/TLS. This involves configuring the queue connection in `config/queue.php` and defining necessary environment variables in `.env` for host, port, credentials, and SSL options.

```php
<?php
// config/queue.php
'connections' => [
    'rabbitmq' => [
        'driver' => 'rabbitmq',
        'secure' => true,
        'network_protocol' => 'ssl',  // or 'tls'
        'hosts' => [
            [
                'host' => env('RABBITMQ_HOST', 'rabbitmq.example.com'),
                'port' => env('RABBITMQ_PORT', 5671),  // SSL port
                'user' => env('RABBITMQ_USER', 'guest'),
                'password' => env('RABBITMQ_PASSWORD', 'guest'),
                'vhost' => env('RABBITMQ_VHOST', '/'),
            ],
        ],
        'options' => [
            'ssl_options' => [
                'cafile' => env('RABBITMQ_SSL_CAFILE', '/path/to/ca.pem'),
                'local_cert' => env('RABBITMQ_SSL_LOCALCERT', '/path/to/client.crt'),
                'local_key' => env('RABBITMQ_SSL_LOCALKEY', '/path/to/client.key'),
                'verify_peer' => env('RABBITMQ_SSL_VERIFY_PEER', true),
                'passphrase' => env('RABBITMQ_SSL_PASSPHRASE', null),
            ],
        ],
    ],
],

```

```env
# .env for SSL connection
RABBITMQ_HOST=rabbitmq.example.com
RABBITMQ_PORT=5671
RABBITMQ_USER=secure_user
RABBITMQ_PASSWORD=secure_password
RABBITMQ_SSL_CAFILE=/etc/ssl/certs/ca.pem
RABBITMQ_SSL_LOCALCERT=/etc/ssl/certs/client.crt
RABBITMQ_SSL_LOCALKEY=/etc/ssl/private/client.key
RABBITMQ_SSL_VERIFY_PEER=true

```

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

### Fix Code Style Issues in Bash

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

This bash command automatically fixes most style-related issues in the codebase. It's a convenient way to maintain code consistency before committing changes or running tests.

```bash
composer fix:style
```

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

### Dispatch Jobs to RabbitMQ Queues

Source: https://context7.com/websolutionfalcon/laravel-queue-rabbitmq/llms.txt

Dispatch jobs to RabbitMQ queues using Laravel's standard Queue API. This includes dispatching to the default queue, a specific queue, or explicitly on the 'rabbitmq' connection. The Queue facade can also be used for pushing single or bulk jobs.

```php
<?php

namespace App\Jobs;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;

class ProcessPodcast implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public function __construct(
        public int $podcastId,
        public int $priority = 0
    ) {}

    public function handle(): void
    {
        // Process the podcast...
        logger()->info("Processing podcast: {$this->podcastId}");
    }
}

// Dispatch a job to the default queue
ProcessPodcast::dispatch($podcastId);

// Dispatch to a specific queue
ProcessPodcast::dispatch($podcastId)->onQueue('podcasts');

// Dispatch on the rabbitmq connection explicitly
ProcessPodcast::dispatch($podcastId)->onConnection('rabbitmq');

// Using the Queue facade
use Illuminate\Support\Facades\Queue;

Queue::push(new ProcessPodcast($podcastId));
Queue::pushOn('podcasts', new ProcessPodcast($podcastId));

// Bulk push multiple jobs
Queue::bulk([
    new ProcessPodcast(1),
    new ProcessPodcast(2),
    new ProcessPodcast(3),
], '', 'podcasts');

```

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

### Configure Plugin Delay Strategy in Laravel

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

This PHP configuration shows how to set the 'plugin' delay strategy for RabbitMQ in Laravel, along with options for the delayed exchange name and type. It utilizes environment variables for flexibility.

```php
'connections' => [
    'rabbitmq' => [
        // ...

        'options' => [
            'queue' => [
                'delay_strategy' => 'plugin',
                'delayed_exchange' => env('RABBITMQ_DELAYED_EXCHANGE', 'delayed'),
                'delayed_exchange_type' => env('RABBITMQ_DELAYED_EXCHANGE_TYPE', 'direct'),
            ],
        ],
    ],
],
```

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

### Configure RabbitMQ Connection in Laravel

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

Defines the configuration for a RabbitMQ queue connection within Laravel's queue.php file. This includes setting the driver, host, port, and other connection-specific parameters.

```php
'connections' => [
    // ...

    'rabbitmq' => [
        'driver' => 'rabbitmq',
        'host' => env('RABBITMQ_HOST'),
        'port' => env('RABBITMQ_PORT'),
        'user' => env('RABBITMQ_USER'),
        'password' => env('RABBITMQ_PASSWORD'),
        'vhost' => env('RABBITMQ_VHOST'),
        'options' => [
            'ssl_connection' => env('RABBITMQ_SSL_CONNECTION', false),
        ],
        'worker' => env('RABBITMQ_WORKER'),
        'queue' => env('RABBITMQ_QUEUE', 'default'),
        'after_commit' => env('RABBITMQ_AFTER_COMMIT', false),
        'lazy' => env('RABBITMQ_LAZY', true),
        'network_protocol' => env('RABBITMQ_NETWORK_PROTOCOL', 'tcp'),
    ],

    // ...
]
```

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

### Consume Messages with rabbitmq:consume Command

Source: https://context7.com/websolutionfalcon/laravel-queue-rabbitmq/llms.txt

Utilize the high-performance `rabbitmq:consume` Artisan command for consuming messages. This command uses `basic_consume` for improved performance compared to `basic_get`.

```bash
# Example usage of the consume command (actual command not provided in text)
# php artisan rabbitmq:consume

```

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

### Configure RabbitMQ Connection in Laravel

Source: https://context7.com/websolutionfalcon/laravel-queue-rabbitmq/llms.txt

Configure the RabbitMQ connection details within your Laravel application's queue configuration file (`config/queue.php`). This includes host, port, credentials, and queue options. The `.env` file should also be updated with the corresponding RabbitMQ credentials.

```php
// config/queue.php
'connections' => [
    'rabbitmq' => [
        'driver' => 'rabbitmq',
        'queue' => env('RABBITMQ_QUEUE', 'default'),
        'hosts' => [
            [
                'host' => env('RABBITMQ_HOST', '127.0.0.1'),
                'port' => env('RABBITMQ_PORT', 5672),
                'user' => env('RABBITMQ_USER', 'guest'),
                'password' => env('RABBITMQ_PASSWORD', 'guest'),
                'vhost' => env('RABBITMQ_VHOST', '/'),
            ],
        ],
        'options' => [
            'queue' => [
                'exchange' => 'application-x',
                'exchange_type' => 'topic',
                'exchange_routing_key' => '',
                'prioritize_delayed' => false,
                'queue_max_priority' => 10,
            ],
            'heartbeat' => 10,
            'connection_timeout' => 3.0,
            'read_timeout' => 3.0,
            'write_timeout' => 3.0,
        ],
        'worker' => env('RABBITMQ_WORKER', 'default'),
        'after_commit' => true,
    ],
],

```

```env
# .env
RABBITMQ_HOST=127.0.0.1
RABBITMQ_PORT=5672
RABBITMQ_USER=guest
RABBITMQ_PASSWORD=guest
RABBITMQ_VHOST=/
RABBITMQ_QUEUE=default

```

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

### Schedule Delayed Jobs with RabbitMQ

Source: https://context7.com/websolutionfalcon/laravel-queue-rabbitmq/llms.txt

Schedule jobs to be executed after a specified delay using either the DLX (Dead Letter Exchange) or Plugin strategy. This can be done using the `delay` method on the job or the `later` method on the Queue facade. Configuration for the delay strategy is available in `config/queue.php`.

```php
<?php

use App\Jobs\ProcessPodcast;
use Illuminate\Support\Facades\Queue;

// Delay a job by 60 seconds
ProcessPodcast::dispatch($podcastId)->delay(now()->addSeconds(60));

// Delay by 5 minutes
ProcessPodcast::dispatch($podcastId)->delay(now()->addMinutes(5));

// Delay by 1 hour
ProcessPodcast::dispatch($podcastId)->delay(now()->addHour());

// Using Carbon directly
ProcessPodcast::dispatch($podcastId)->delay(\Carbon\Carbon::now()->addMinutes(30));

// Using the Queue facade with later()
Queue::later(now()->addMinutes(10), new ProcessPodcast($podcastId));

// Later on a specific queue
Queue::laterOn('podcasts', now()->addMinutes(10), new ProcessPodcast($podcastId));

// Configuration for Plugin strategy (more efficient, requires plugin)
// config/queue.php
'options' => [
    'queue' => [
        'delay_strategy' => 'plugin',  // or 'dlx' (default)
        'delayed_exchange' => env('RABBITMQ_DELAYED_EXCHANGE', 'delayed'),
        'delayed_exchange_type' => env('RABBITMQ_DELAYED_EXCHANGE_TYPE', 'direct'),
    ],
],

```

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

### Configure Network Protocol for RabbitMQ Connection

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

Specifies the network protocol used for connecting to RabbitMQ. Available options include 'tcp', 'ssl', and 'tls'. This is configured using the 'network_protocol' parameter.

```php
'connections' => [
    // ...

    'rabbitmq' => [
        // ...

        'network_protocol' => 'tcp',
    ],

    // ...    
]
```

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

### Enable Events After Database Commits for RabbitMQ

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

Instructs Laravel workers to dispatch events only after all database commits are successfully completed. This ensures that events are fired in a consistent state with the database. Set the 'after_commit' option to true.

```php
'connections' => [
    // ...

    'rabbitmq' => [
        // ...

        'after_commit' => true,
    ],

    // ...    
]
```

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

### Programmatic RabbitMQ Queue and Exchange Operations (PHP)

Source: https://context7.com/websolutionfalcon/laravel-queue-rabbitmq/llms.txt

Interact directly with RabbitMQ exchanges and queues using the RabbitMQQueue API. This allows for dynamic management of queue size checks, existence checks, declarations, bindings, purging, and deletions.

```php
<?php

use Illuminate\Support\Facades\Queue;
use VladimirYuldashev\LaravelQueueRabbitMQ\Queue\RabbitMQQueue;

// Get the RabbitMQ connection
/** @var RabbitMQQueue $rabbitmq */
$rabbitmq = Queue::connection('rabbitmq');

// Check queue size
$size = $rabbitmq->size('default');
echo "Queue size: {$size}\n";

// Check if queue exists
if ($rabbitmq->isQueueExists('my-queue')) {
    echo "Queue exists\n";
}

// Check if exchange exists
if ($rabbitmq->isExchangeExists('my-exchange')) {
    echo "Exchange exists\n";
}

// Declare a queue programmatically
$rabbitmq->declareQueue(
    name: 'new-queue',
    durable: true,
    autoDelete: false,
    arguments: ['x-max-priority' => 10]
);

// Declare an exchange programmatically
use PhpAmqpLib\Exchange\AMQPExchangeType;

$rabbitmq->declareExchange(
    name: 'new-exchange',
    type: AMQPExchangeType::TOPIC,
    durable: true,
    autoDelete: false
);

// Bind queue to exchange
$rabbitmq->bindQueue(
    queue: 'new-queue',
    exchange: 'new-exchange',
    routingKey: 'events.*'
);

// Purge messages from a queue
$rabbitmq->purge('old-queue');

// Delete queue
$rabbitmq->deleteQueue('temp-queue');

// Delete exchange
$rabbitmq->deleteExchange('temp-exchange');

// Close connection when done
$rabbitmq->close();

```

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

### Laravel Horizon Integration with RabbitMQ (PHP & .env & Bash)

Source: https://context7.com/websolutionfalcon/laravel-queue-rabbitmq/llms.txt

Enables Laravel Horizon for monitoring and managing RabbitMQ queues. This involves setting the `RABBITMQ_WORKER` environment variable to 'horizon' and configuring Horizon's supervisor settings in `config/horizon.php`.

```php
<?php
// config/queue.php
'connections' => [
    'rabbitmq' => [
        'driver' => 'rabbitmq',
        'hosts' => [/* ... */],
        'worker' => env('RABBITMQ_WORKER', 'horizon'),  // Set to 'horizon'
    ],
],

```

```php
<?php
// config/horizon.php
'environments' => [
    'production' => [
        'supervisor-1' => [
            'connection' => 'rabbitmq',
            'queue' => ['default', 'notifications'],
            'balance' => 'auto',
            'maxProcesses' => 10,
            'minProcesses' => 1,
            'memory' => 128,
            'tries' => 3,
            'timeout' => 60,
        ],
    ],
    'local' => [
        'supervisor-1' => [
            'connection' => 'rabbitmq',
            'queue' => ['default'],
            'balance' => 'simple',
            'processes' => 3,
            'tries' => 3,
        ],
    ],
],

```

```env
# .env
RABBITMQ_WORKER=horizon

```

```bash
# Start Horizon
php artisan horizon

# Monitor Horizon
php artisan horizon:status

```

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

### Configure RabbitMQ Exchange and Routing Keys

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

Configures optional queue settings for the RabbitMQ connection in Laravel to publish messages to a specific exchange with routing keys. This allows for more advanced message routing based on exchange type and routing key patterns.

```php
'connections' => [
    // ...

    'rabbitmq' => [
        // ...

        'options' => [
            'queue' => [
                // ...

                'exchange' => 'application-x',
                'exchange_type' => 'topic',
                'exchange_routing_key' => '',
            ],
        ],
    ],

    // ...    
]
```

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

### Configure RabbitMQ Queue Prioritization

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

Configures optional queue settings for the RabbitMQ connection in Laravel, specifically enabling message prioritization. When 'prioritize_delayed' is set to true and 'queue_max_priority' is defined, delayed messages can be processed with higher priority.

```php
'connections' => [
    // ...

    'rabbitmq' => [
        // ...

        'options' => [
            'queue' => [
                // ...

                'prioritize_delayed' =>  false,
                'queue_max_priority' => 10,
            ],
        ],
    ],

    // ...    
]
```

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

### Configure SSL/TLS Secure Connection for RabbitMQ

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

Enables and configures SSL/TLS for a secure connection to the RabbitMQ server. This involves setting 'secure' to true and providing paths to SSL certificates and keys within the 'ssl_options' array.

```php
'connections' => [
    // ...

    'rabbitmq' => [
        // ...

        'secure' => true,
        'options' => [
            // ...

            'ssl_options' => [
                'cafile' => env('RABBITMQ_SSL_CAFILE', null),
                'local_cert' => env('RABBITMQ_SSL_LOCALCERT', null),
                'local_key' => env('RABBITMQ_SSL_LOCALKEY', null),
                'verify_peer' => env('RABBITMQ_SSL_VERIFY_PEER', true),
                'passphrase' => env('RABBITMQ_SSL_PASSPHRASE', null),
            ],
        ],
    ],

    // ...    
]
```

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

### Configure Custom RabbitMQ Connection Class

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

This configuration snippet shows how to specify a custom RabbitMQ connection class in your Laravel queue configuration. This allows you to extend or replace the default AMQP stream or SSL connections with your own implementations.

```php
'connections' => [
    // ...

    'rabbitmq' => [
        // ...

        'connection' = > \App\Queue\Connection\MyRabbitMQConnection::class,
    ],

    // ...    
]
```

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

### Configure Custom RabbitMQJob Class in Laravel

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

This configuration demonstrates how to specify a custom RabbitMQJob class within the queue connection settings. This allows for custom handling of messages that may not adhere to Laravel's standard job payload schema.

```php
'connections' => [
    // ...

    'rabbitmq' => [
        // ...

        'options' => [
            'queue' => [
                // ...

                'job' => \App\Queue\Jobs\RabbitMQJob::class,
            ],
        ],
    ],

    // ...    
]
```

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

### Implement Custom RabbitMQ Job for External Messages

Source: https://context7.com/websolutionfalcon/laravel-queue-rabbitmq/llms.txt

A PHP class extending `RabbitMQJob` to process raw messages from external sources. It decodes the message, logs it, resolves an appropriate handler based on message type, and then deletes the message. It also overrides the `payload` and `getName` methods for custom handling.

```php
<?php

namespace App\Queue\Jobs;

use Illuminate\Support\Facades\Log;
use VladimirYuldashev\LaravelQueueRabbitMQ\Queue\Jobs\RabbitMQJob as BaseJob;

class ExternalRabbitMQJob extends BaseJob
{
    /**
     * Process the external message
     */
    public function fire(): void
    {
        $rawBody = $this->getRawBody();
        $data = json_decode($rawBody, true);

        Log::info('Processing external message', [
            'queue' => $this->queue,
            'data' => $data,
        ]);

        // Route to appropriate handler based on message type
        $handler = $this->resolveHandler($data['type'] ?? 'default');
        $handler->process($data);

        $this->delete();
    }

    /**
     * Override payload for non-Laravel messages
     */
    public function payload(): array
    {
        return [
            'job' => \App\Handlers\ExternalMessageHandler::class . '@handle',
            'data' => json_decode($this->getRawBody(), true),
        ];
    }

    /**
     * Return empty name for raw messages without 'job' key
     */
    public function getName(): string
    {
        return '';
    }

    protected function resolveHandler(string $type): object
    {
        $handlers = [
            'order' => \App\Handlers\OrderHandler::class,
            'notification' => \App\Handlers\NotificationHandler::class,
            'default' => \App\Handlers\DefaultHandler::class,
        ];

        $handlerClass = $handlers[$type] ?? $handlers['default'];

        return $this->resolve($handlerClass);
    }
}
```

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

### Configure RabbitMQ Connection Timeouts in PHP

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

This PHP configuration snippet shows how to set network timeouts for the RabbitMQ queue connection. It includes default values for connection, read, write, and channel RPC timeouts, all specified in seconds. A zero value indicates an infinite timeout.

```php
'connections' => [
    // ...

    'rabbitmq' => [
        // ...

        'options' => [
            // ...

            'connection_timeout' => 3.0,
            'read_timeout' => 3.0,
            'write_timeout' => 3.0,
            'channel_rpc_timeout' => 0.0,
        ],
    ],

    // ...
]
```

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

### Configure Laravel Horizon Integration for RabbitMQ

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

This configuration snippet shows how to enable Laravel Horizon support for the RabbitMQ queue connection by setting the 'worker' option. Horizon relies on events dispatched by the worker to track job progress.

```php
'connections' => [
    // ...

    'rabbitmq' => [
        // ...

        /* Set to "horizon" if you wish to use Laravel Horizon. */
       'worker' => env('RABBITMQ_WORKER', 'default'),
    ],

    // ...    
]
```

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

### Custom RabbitMQJob for Raw Message Handling

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

This custom RabbitMQJob class is designed to handle raw messages directly from the broker, bypassing Laravel's standard JSON payload processing. It logs the raw message and overrides 'getName' to return an empty string, indicating no specific job name.

```php
<?php

namespace App\Queue\Jobs;

use Illuminate\Support\Facades\Log;
use VladimirYuldashev\LaravelQueueRabbitMQ\Queue\Jobs\RabbitMQJob as BaseJob;

class RabbitMQJob extends BaseJob
{
    public function fire()
    {
        $anyMessage = $this->getRawBody();
        Log::info($anyMessage);

        $this->delete();
    }

    public function getName()
    {
        return '';
    }
}
```

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

### Configure Default Queue Name for RabbitMQ

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

Specifies the default queue name to be used by the RabbitMQ connection when Laravel does not explicitly provide one. This is set via the 'queue' parameter in the connection configuration.

```php
'connections' => [
    // ...

    'rabbitmq' => [
        // ...
            
        'queue' => env('RABBITMQ_QUEUE', 'default'),
    ],

    // ...    
]
```

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

### Custom RabbitMQ Queue Class with Reconnection (PHP)

Source: https://context7.com/websolutionfalcon/laravel-queue-rabbitmq/llms.txt

Extends the base RabbitMQQueue class to automatically reconnect upon connection or channel closure during publish or channel creation operations. This ensures message delivery even with transient network issues.

```php
<?php
// config/queue.php
'worker' => \App\Queue\RabbitMQQueue::class;
```

```php
<?php

namespace App\Queue;

use PhpAmqpLib\Channel\AMQPChannel;
use PhpAmqpLib\Exception\AMQPChannelClosedException;
use PhpAmqpLib\Exception\AMQPConnectionClosedException;
use VladimirYuldashev\LaravelQueueRabbitMQ\Queue\RabbitMQQueue as BaseRabbitMQQueue;

class RabbitMQQueue extends BaseRabbitMQQueue
{
    /**
     * Publish with automatic reconnection
     */
    protected function publishBasic(
        $msg,
        $exchange = '',
        $destination = '',
        $mandatory = false,
        $immediate = false,
        $ticket = null
    ): void {
        try {
            parent::publishBasic($msg, $exchange, $destination, $mandatory, $immediate, $ticket);
        } catch (AMQPConnectionClosedException|AMQPChannelClosedException $e) {
            logger()->warning('RabbitMQ connection lost, reconnecting...', [
                'error' => $e->getMessage(),
            ]);

            $this->reconnect();
            parent::publishBasic($msg, $exchange, $destination, $mandatory, $immediate, $ticket);
        }
    }

    /**
     * Batch publish with automatic reconnection
     */
    protected function publishBatch($jobs, $data = '', $queue = null): void
    {
        try {
            parent::publishBatch($jobs, $data, $queue);
        } catch (AMQPConnectionClosedException|AMQPChannelClosedException $e) {
            logger()->warning('RabbitMQ connection lost during batch, reconnecting...');

            $this->reconnect();
            parent::publishBatch($jobs, $data, $queue);
        }
    }

    /**
     * Create channel with automatic reconnection
     */
    protected function createChannel(): AMQPChannel
    {
        try {
            return parent::createChannel();
        } catch (AMQPConnectionClosedException $e) {
            logger()->warning('RabbitMQ connection lost during channel creation, reconnecting...');

            $this->reconnect();
            return parent::createChannel();
        }
    }
}

```

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

### Use Custom Worker Class for RabbitMQ Queue

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

Allows extending the base RabbitMQQueue class to implement custom logic. Set the RABBITMQ_WORKER environment variable or the 'worker' config option to your custom class path. Ensure your custom class extends VladimirYuldashev\LaravelQueueRabbitMQ\Queue\RabbitMQQueue.

```php
<?php

namespace App\Queue;

use VladimirYuldashev\LaravelQueueRabbitMQ\Queue\RabbitMQQueue as BaseRabbitMQQueue;

class RabbitMQQueue extends BaseRabbitMQQueue
{
    // ...
}
```

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

### Configure RabbitMQ Failed Job Rerouting

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

Configures optional queue settings for the RabbitMQ connection in Laravel to reroute failed messages to a specified exchange or queue. This is useful for implementing custom failure handling mechanisms beyond Laravel's default database storage.

```php
'connections' => [
    // ...

    'rabbitmq' => [
        // ...

        'options' => [
            'queue' => [
                // ...

                'reroute_failed' => true,
                'failed_exchange' => 'failed-exchange',
                'failed_routing_key' => 'application-x.%s',
            ],
        ],
    ],

    // ...    
]
```

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

### Configure RabbitMQ Failed Job Rerouting (PHP)

Source: https://context7.com/websolutionfalcon/laravel-queue-rabbitmq/llms.txt

Configure the Laravel queue connection to automatically reroute failed jobs to a specified exchange and routing key. This requires setting 'reroute_failed' to true and defining 'failed_exchange' and 'failed_routing_key' in the queue configuration.

```php
<?php
// config/queue.php
'connections' => [
    'rabbitmq' => [
        'driver' => 'rabbitmq',
        'hosts' => [/* ... */],
        'options' => [
            'queue' => [
                'reroute_failed' => true,
                'failed_exchange' => 'failed-jobs',
                'failed_routing_key' => 'app.%s.failed',  // %s is replaced with queue name
            ],
        ],
    ],
],

```

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

### Disable Lazy Connection for RabbitMQ

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

Turns off the lazy connection feature for RabbitMQ, meaning the connection will be established immediately when the queue is first used, rather than on demand. Set the 'lazy' option to false.

```php
'connections' => [
    // ...

    'rabbitmq' => [
        // ...

        'lazy' => false,
    ],

    // ...    
]
```

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

### Set Heartbeat Interval for RabbitMQ Connection

Source: https://github.com/websolutionfalcon/laravel-queue-rabbitmq/blob/master/README.md

Configures the heartbeat interval for the RabbitMQ connection, which helps maintain an active connection by sending periodic signals. A value of 0 disables heartbeats. This is set within the 'options' array of the connection configuration.

```php
'connections' => [
    // ...

    'rabbitmq' => [
        // ...

        'options' => [
            // ...

            'heartbeat' => 10,
        ],
    ],

    // ...    
]
```
Tokens:
Raw