Getting Started

Minimal Steps

Installation Add the package via Composer:

composer require djereg/symfony-rabbitmq

Ensure php-amqplib is installed:

composer require php-amqplib/php-amqplib

Basic Configuration Publish the default config:

php artisan vendor:publish --provider="Djereg\RabbitMQBundle\RabbitMQBundle" --tag="config"

Update .env with RabbitMQ connection details:

RABBITMQ_HOST=localhost
RABBITMQ_PORT=5672
RABBITMQ_USER=guest
RABBITMQ_PASSWORD=guest

First Use Case: Publishing a Message Dispatch an event (Symfony Messenger integration):

use Djereg\RabbitMQBundle\Messenger\Transport\RabbitMQTransport;
use Symfony\Component\Messenger\MessageBus;

$bus = new MessageBus([
    new RabbitMQTransport('amqp://guest:guest@localhost:5672/%2f', 'my_queue')
]);
$bus->dispatch(new MyMessage());

Implementation Patterns

Workflows

Event-Driven Architecture

Dispatching Events: Use Symfony Messenger to publish messages to RabbitMQ queues.
```
$bus->dispatch(new UserRegisteredEvent($userId));
```

Listening to Events: Create a consumer class and register it as a Symfony Messenger handler.

use Djereg\RabbitMQBundle\Messenger\Transport\RabbitMQTransport;

class UserRegisteredHandler
{
    public function __invoke(UserRegisteredEvent $event)
    {
        // Process event (e.g., send welcome email)
    }
}

Remote Procedure Calls (RPC)

Register a Client:

$rpcClient = $container->get('djereg_rabbitmq.rpc.client');
$rpcClient->call('remote_procedure_name', [$arg1, $arg2]);

Register a Remote Procedure:

$rpcServer = $container->get('djereg_rabbitmq.rpc.server');
$rpcServer->register('remote_procedure_name', function ($args) {
    return $this->processArgs($args);
});

Lifecycle Events

Subscribe to RabbitMQ lifecycle events (e.g., message publishing/received):

$dispatcher->addListener(MessagePublishingEvent::class, function (MessagePublishingEvent $event) {
    logger()->info('Message published:', ['message' => $event->getMessage()]);
});

Integration Tips

Laravel-Specific Setup: Use Laravel's service provider to bind the RabbitMQ client:

// config/rabbitmq.php
'connections' => [
    'default' => [
        'host' => env('RABBITMQ_HOST'),
        'port' => env('RABBITMQ_PORT'),
        'user' => env('RABBITMQ_USER'),
        'password' => env('RABBITMQ_PASSWORD'),
    ],
],

'providers' => [
    Djereg\RabbitMQBundle\RabbitMQBundle::class,
],

Queue Consumption: Start the consumer via Artisan:

php artisan rabbitmq:consume --queue=my_queue --worker=default

For Laravel, create a custom Artisan command to integrate with Laravel's queue worker:

use Djereg\RabbitMQBundle\Command\ConsumeCommand;

class RabbitMQWorkerCommand extends ConsumeCommand
{
    protected function getDefaultQueue()
    {
        return config('queue.default');
    }
}

Gotchas and Tips

Pitfalls

Connection Management:
- RabbitMQ connections are not automatically reconnected on failure. Implement a retry mechanism or use a connection pool.
- Example retry logic:
```
try {
    $connection = new AmqpConnection($config);
    $connection->connect();
} catch (Exception $e) {
    sleep(5); // Wait before retry
    retry();
}
```
Message Serialization:
- The package defaults to Symfony's Serializer. Ensure your message classes are serializable or configure a custom serializer:
```
# config/packages/djereg_rabbitmq.yaml
djereg_rabbitmq:
    serializer: 'App\CustomSerializer'
```
Consumer Lifecycle:
- Consumers are not managed by Laravel's queue system by default. Use rabbitmq:consume Artisan command or integrate with Laravel's queue worker manually.
Thread Safety:
- RabbitMQ clients are not thread-safe. Avoid sharing a single connection across multiple threads/processes.

Debugging

Enable Debugging: Configure RabbitMQ to log messages:
```
djereg_rabbitmq:
    debug: true
```
Check logs for connection issues or message routing problems.
Common Errors:
- ConnectionRefusedError: Verify RabbitMQ server is running and credentials are correct.
- SerializationException: Ensure message classes implement Serializable or use a custom serializer.
- QueueNotFoundException: Declare queues explicitly in configuration or ensure they exist before publishing.

Extension Points

Custom Transports: Extend RabbitMQTransport to add custom logic (e.g., message transformation):

class CustomRabbitMQTransport extends RabbitMQTransport
{
    public function send(Envelope $envelope): void
    {
        $message = $this->transformMessage($envelope->getMessage());
        parent::send($envelope->with($message));
    }

    protected function transformMessage($message): mixed
    {
        // Custom logic
    }
}

Event Subscribers: Create custom subscribers for lifecycle events:

use Djereg\RabbitMQBundle\Event\MessageReceivedEvent;

class CustomSubscriber implements EventSubscriberInterface
{
    public static function getSubscribedEvents(): array
    {
        return [
            MessageReceivedEvent::class => 'onMessageReceived',
        ];
    }

    public function onMessageReceived(MessageReceivedEvent $event)
    {
        // Custom logic
    }
}

RPC Extensions: Add middleware to RPC calls for logging or validation:

$rpcClient->addMiddleware(function (callable $next, $request) {
    logger()->info('RPC call started', ['request' => $request]);
    $response = $next($request);
    logger()->info('RPC call completed', ['response' => $response]);
    return $response;
});

Configuration Quirks

Queue Declarations: Ensure queues are declared in the configuration or via code:

djereg_rabbitmq:
    queues:
        my_queue:
            durable: true
            exclusive: false
            auto_delete: false

Exchange Bindings: Bind queues to exchanges explicitly if using direct/topic exchanges:

djereg_rabbitmq:
    exchanges:
        my_exchange:
            type: direct
            durable: true
    bindings:
        my_queue:
            exchange: my_exchange
            routing_key: my.routing.key

Symfony Rabbitmq Laravel Package