Unleash the Power of Symfony Messenger

SymfonyD
a
y Chic
a
go 2025
Kris W
a
llsmith
UnleashthePowerof
SymfonyMessenger

AboutMe
• Former Symfony Core Team
• Live in Portland, Oregon
• VP of Engineering at Vacatia
• CTO at Pickathon Music Festival
• Likes long walks on the beach

Owners & Contracts
Reservations
TECH STACK

Billing
Reservations
Owners & Contracts
TECH STACK

Billing
Reservations
Owners & Contracts
Integration Layer
TECH STACK

Wikipedi
a
: Bus (computing)
“A bus … is a communication system that
transfers data between components”

$envelope = $bus->dispatch($envelope);

class Envelope
{
function getMessage(): object;
function with(StampInterface ...$stamps): static;
function last(string $stampClass): ?StampInterface;
/** @return StampInterface[]|StampInterface[][] */
function all(?string $stampClass = null): array;
// ...
}

/** Stamps must be serializable value objects for transport. */
interface StampInterface {}

CoreConcepts
Symfony Messenger
• Message Bus
• Envelopes
• Messages
• Stamps
• …

Component A Component B
Middleware

interface MiddlewareInterface
{
function handle(
Envelope $envelope,
StackInterface $stack,
): Envelope;
}

interface StackInterface
{
function next(): MiddlewareInterface;
}

class MyMiddleware implements MiddlewareInterface
{
public function handle(
Envelope $envelope,
): Envelope {
return $envelope;
}
}

class MyMiddleware implements MiddlewareInterface
{
Envelope $envelope,
): Envelope {
return $stack->next()->handle(
$envelope,
$stack,
);
}
}

public function handle(Envelope $envelope, StackInterface $stack): Envelope
{
// before
try {
$envelope = $stack->next()->handle($envelope, $stack);
} catch (Throwable $e) {
// on error
throw $e;
} finally {
// always
}
// on success
return $envelope;
}

CoreMiddleware
Symfony Messenger
• SendMessageMiddleware
• HandleMessageMiddleware

CoreConcepts
Symfony Messenger
• Message Bus
• Envelopes
• Messages
• Stamps
• Middleware
• Transports (send & receive)
• Workers
• Handlers

Billing
Reservations
Owners & Contracts
TECH STACK
“Porter”

readonly class IdStamp implements StampInterface
{
public function __construct(
public Ulid $id = new Ulid(),
) {}
}

class IdMiddleware implements MiddlewareInterface
{
Envelope $envelope,
): Envelope {
$envelope = $envelope->with(new IdStamp());
return $stack->next()->handle($envelope, $stack);
}
}

Transport
Worker
Send
Receive
Envelopes can pass through
middleware multiple times

{
Envelope $envelope,
): Envelope {
if (!$envelope->last(IdStamp::class)) {
$envelope = $envelope->with(new IdStamp());
}
}
}

{
private IdContext $context,
) {}
{
if (!$stamp = $envelope->last(IdStamp::class)) {
$envelope = $envelope->with($stamp = new IdStamp());
}
$this->context->push($stamp->id);
try {
} finally {
$this->context->pop();
}
}
}

class IdProcessor implements ProcessorInterface
{
private IdContext $context,
) {}
public function __invoke(LogRecord $record): LogRecord
{
if ($id = $this->context->head()) {
$record['extra']['message_id'] = "$id";
}
return $record;
}
}

{
if (!$stamp = $envelope->last(IdStamp::class)) {
$envelope = $envelope->with($stamp = new IdStamp());
$this->logDispatched($envelope);
}
$this->context->push($stamp->id);
try {
$envelope->last(HandledStamp::class) && $this->logHandled($envelope);
return $envelope;
} catch (Throwable $e) {
$this->logFailed($envelope, $e);
throw $e;
} finally {
$this->context->pop();
}
}

Billing
Reservations
Owners & Contracts
“Porter”
TECH STACK

class Envelope
{
function with(StampInterface ...$stamps): static;
function last(string $stampClass): ?StampInterface;
/** @return StampInterface[]|StampInterface[][] */
function all(?string $stampClass = null): array;
// ...
}

{
if (!$envelope->last(IdStamp::class)) {
$envelope = $envelope->with(...array_map(
idToStamp(...),
$this->context->all(),
))->with(new IdStamp());
$this->logDispatched($envelope);
}
$this->context->push(array_map(
stampToId(...),
$envelope->all(IdStamp::class),
));
//...
}

CREATE TABLE messenger_log (
id CHAR(26) NOT NULL,
path JSON NOT NULL,
headers JSON,
body TEXT,
dispatched_at DATETIME NOT NULL,
handled_at DATETIME,
failed_at DATETIME,
error TEXT,
PRIMARY KEY (id)
)

Create Reservation
Update Reservation
Update Guest
TECH STACK

class ChainStamp implements StampInterface
{
public Envelope $envelope,
) {}
}

class ChainMiddleware implements MiddlewareInterface
{
{
if (!$envelope->last(HandledStamp::class)) {
return $envelope;
}
foreach ($envelope->all(ChainStamp::class) as $chainStamp) {
$this->bus->dispatch($chainStamp->envelope);
}
return $envelope->withoutAll(ChainStamp::class);
}
}

$bus->dispatch($createReservation, [
new ChainStamp($sendConfirmation),
]);

interface ChainInterface
{
function next(
object $handledMessage,
mixed $handledResult,
): ?object;
}

class UpdateReservation implements ChainInterface
{
public string $reservationId;
public array $updates,
) {}
public function next(object $handledMessage, mixed $handledResult): ?object
{
$this->reservationId = $handledResult['id'];
return $this;
}
}

$bus->dispatch($createReservation, [
new ChainStamp($updateReservation),
]);

Envelope $envelope,
): Envelope {
// ...
foreach ($this->nextEnvelopes(
$envelope,
$handledStamp,
) as $nextEnvelope) {
$this->bus->dispatch($nextEnvelope);
}
// ...
}

private function nextEnvelopes(
Envelope $envelope,
HandledStamp $handledStamp,
): iterable {
foreach ($envelope->all(ChainStamp::class) as $chainStamp) {
$nextMessage = $chainStamp->envelope->getMessage();
if (!$nextMessage instanceof ChainInterface) {
yield $chainStamp->envelope;
} elseif ($nextMessage = $nextMessage->chain(
$envelope->getMessage(),
$handledStamp->getResult(),
)) {
yield Envelope::wrap($nextMessage);
}
}
}

UnleashthePowerofSymfonyMessenger
• Message Bus
• Envelopes
• Messages
• Stamps
• Middleware
• Transports (send & receive)
• Workers
• Handlers
• Message IDs
• Message Log
• Nested Messages
• Message Sequencing
• Message Dependencies
SymfonyD
a
y Chic
a
go 2025

Unleash the Power of Symfony Messenger

More Related Content

Similar to Unleash the Power of Symfony Messenger (20)

More from Kris Wallsmith (16)

Recently uploaded (20)

Unleash the Power of Symfony Messenger