Introduction

Building APIs means dealing with complex layers of cache, middleware, and performance optimizations. While these layers help in production, they can also obscure the actual flow of data. How do you know whether a cache has been hit or missed in a particular request? One simple way is to add custom headers to the response, giving you valuable insights.

In this article, I’ll show you how Symfony’s HeaderBag, when registered as a service, can be a powerful tool for debugging APIs in production. By attaching custom headers that indicate cache hits and misses, you can instantly understand what’s happening in your API without adding unnecessary logging or breaking the flow of execution.

Why HeaderBag?

Symfony’s HeaderBag is part of the HttpFoundation component and is used internally by Symfony’s request and response objects. It provides a structured way to interact with HTTP headers, allowing you to add, modify, and retrieve headers in a clean, object-oriented manner. This makes it the perfect fit for managing custom headers during API execution, especially in debugging scenarios.

But there’s more: you can register HeaderBag as a service and use it across your application, keeping your code clean and your debugging consistent.

Step 1: Registering HeaderBag as a Service

You can easily register HeaderBag as a service in one of two ways.

Option 1: Extend HeaderBag in a Custom Service

You can create a custom service that extends HeaderBag and then use it in your application:

<?php
declare(strict_types=1);

namespace App\Service;

use Symfony\Component\HttpFoundation\HeaderBag;

class ResponseHeaderService extends HeaderBag
{
}

Option 2: Define it in services.yaml

Alternatively, you can directly register HeaderBag as a service in services.yaml:

my.awesome.headerbag:
    class: 'Symfony\Component\HttpFoundation\HeaderBag'

Both methods achieve the same goal: Allowing HeaderBag to be available as a service throughout your app.

Step 2: Adding Custom Headers via an Event Subscriber

Once you’ve registered HeaderBag as a service, the next step is to make it interact with Symfony’s response object. This is where event subscribers come into play. By subscribing to the KernelEvents::RESPONSE event, you can inject custom headers into the response before it’s sent back to the client.

Here’s an example of how to create an event subscriber that adds headers stored in HeaderBag:

<?php
declare(strict_types=1);

namespace App\EventSubscriber;

use App\Service\ResponseHeaderService;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpKernel\Event\ResponseEvent;
use Symfony\Component\HttpKernel\KernelEvents;

readonly class ResponseHeadersEventSubscriber implements EventSubscriberInterface
{
    public function __construct(
        private ResponseHeaderService $responseHeaderService
    )
    {}

    public static function getSubscribedEvents(): array
    {
        return [
            KernelEvents::RESPONSE => 'onKernelResponse'
        ];
    }

    public function onKernelResponse(ResponseEvent $event): void
    {
        $response = $event->getResponse();

        $response->headers->add($this->responseHeaderService->all());
    }
}

If you preferred to register your HeaderBag as a service in services.yaml, you’ll need to use the Autowire attribute:

<?php
declare(strict_types=1);

namespace App\EventSubscriber;

use Symfony\Component\DependencyInjection\Attribute\Autowire;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpFoundation\HeaderBag;
use Symfony\Component\HttpKernel\Event\ResponseEvent;
use Symfony\Component\HttpKernel\KernelEvents;

readonly class ResponseHeadersEventSubscriber implements EventSubscriberInterface
{
    public function __construct(
        #[Autowire(service: 'my.awesome.headerbag')]
        private HeaderBag $headerBag
    )
    {}

    // ...

Step 3: Implementing Cache Diagnostics

Now comes the fun part: using this service to track cache hits and misses. Here’s an example of a service that computes some result, checks for cache hits, and adds a custom header to the response indicating whether the cache was hit or missed:

<?php
declare(strict_types=1);

namespace App\Service;

use Psr\Cache\CacheItemPoolInterface;
use Symfony\Component\DependencyInjection\Attribute\Autowire;
use Symfony\Component\HttpFoundation\HeaderBag;

readonly class UniverseService
{
    public function __construct(
        #[Autowire(service: 'my.awesome.headerbag')]
        private HeaderBag $headerBag,
        private CacheItemPoolInterface $cacheItemPool
    )
    {}

    public function calculateUniverseWeight(): float
    {
        $cacheItem = $this->cacheItemPool->getItem('some_cached_data');

        // Check for a cache hit
        if ($cacheItem->isHit() && $cacheItem->get()) {
            // Set the HIT header
            $this->headerBag->set('X-Universe-Cache', 'HIT');

            return $cacheItem->get();
        }

        // Set the MISS header
        $this->headerBag->set('X-Universe-Cache', 'MISS');

        // Perform your heavy lifting...

        return INF;
    }
}

In this example, every time the UniverseService interacts with the cache, it sets an X-Universe-Cache header, indicating whether the cache was hit or missed. This header is then automatically added to the response by the event subscriber. The result? Every API response will contain a simple, informative header that gives you immediate insight into whether the cache was used.

Your Response could look something like this:

HTTP/1.1 200 OK

Date: Mon, 08 Oct 2024 14:23:45 GMT

Server: Apache/2.4.41 (Ubuntu)

Content-Type: application/json

Connection: keep-alive

Content-Length: ∞

X-Universe-Cache: HIT 

{

    "status": "success",

    "message": "The universe's weight has been calculated.",

    "data": {

        "universe_weight": ∞

    }

}

Conclusion

Using Symfony’s HeaderBag as a service is a powerful tool in API development, especially when you’re running in production environments with complex caching layers. By adding custom headers to your API responses, you can quickly determine cache statuses, improving your debugging and optimization processes.

Next time you find yourself wondering whether a particular request was cached, take a look at the headers you’ve added — you’ll have your answer right there!