[loevgaard]

Closes #8.

New clients (requests without the setono_client_id cookie) no longer get their metadata persisted on their first request. It is kept in a signed cookie, setono_client_id_pending_metadata, and persisted on the client's next request, once the client has shown that it keeps its cookies. Crawlers, link checkers, preview fetchers and cookie-blocking browsers never come back with the cookie, so they never produce a row.

Choosing the approach

I compared the current behaviour, a session, the proposal in #8, and a variant of it:

	Persist right away (today)	Session	Pending metadata inside the id cookie (#8)	Separate signed cookie (this PR)
Server writes per bot hit	1 DB row, kept forever	1 session record (removed by GC) + a PHPSESSID cookie	none	none
Visitor bounces and returns days later	kept	lost once the session expires	kept	kept
Visitor can forge metadata	no	no	yes, unless signed	no (HMAC)
Breaks existing parsers of the id cookie	no	no	yes	no
Readable by JavaScript	–	no	yes	no (HttpOnly)
Size limit	none	none	~4 KB, shared with the id	2 KB, then falls back to persisting right away
Works on stateless routes, keeps responses cacheable	yes	no	yes	yes

Why not the session

• It moves the orphans instead of removing them. Every bot hit still writes a session record (file, Redis or DB) and gets a session cookie. Garbage collection only cleans up afterwards.
• It loses data for real visitors. A session usually ends with the browser session or after gc_maxlifetime (24 min by default). A visitor who lands from an ad, views one page and comes back next week to buy has lost the gclid. Today it's kept, and with a cookie that lives as long as the id cookie (365 days) it's still kept. This is the main use case of SyliusGoogleAdsPlugin, which stores its tracking information with a 90-day TTL.
• It costs the app something. Starting a session makes Symfony's AbstractSessionListener mark the response private, so landing pages can't be cached by shared caches. On routes declared stateless it throws UnexpectedSessionUsageException in debug mode. The bundle doesn't need sessions today, and API-only apps may not have them.

What changed compared to the proposal in #8

Sending the pending metadata to the browser is the right idea. This PR changes where it goes and how it's protected:

• Its own cookie, not a new segment in the id cookie. Cookie::fromString() splits with explode('.', $cookie, 4), so an older setono/client, or JavaScript that reads the id (the README encourages this), would read <uuid>.<payload> as the client id during the pending hop. A separate cookie leaves the id cookie format and setono/client untouched, and it can be HttpOnly.
• It's signed. Today metadata never leaves the server, so the app can trust it. If it comes back from the browser unsigned, a visitor can set any key, e.g. pick their own A/B variant or set flags the app relies on. The value is <json>.<hmac>, signed with kernel.secret over the client id as well, so it can't be forged or moved to another client.
• Too big means persist right away, not drop. No metadata is ever lost. The value is capped at 2 KB because all cookies share the web server's request header limit (8 KB in nginx and Apache). A request over that limit gets a 400 before PHP runs, so the cookie could never be cleared.

How it works

• StoreCookieSubscriber, for a new client with changed metadata: stores the metadata via PendingMetadataStorageInterface::store() and marks it clean, so StoreMetadataSubscriber skips it. If it can't be stored (too big, not JSON encodable), it stays dirty and is persisted right away as before. Metadata changed after the subscriber has run becomes dirty again and is also persisted right away.
• On the client's next request, PendingMetadataClientContext checks the signature against the client id. This is a new decorator between the cached (32) and the cookie-based (64) context, at priority 48.
  • If the client has no metadata yet, it gets the pending metadata, marked dirty, and the persister writes the row on kernel.finish_request.
  • If the client already has metadata (e.g. a concurrent request persisted it), the existing metadata wins.
  • StoreCookieSubscriber clears the pending cookie.
• TTLs carry over exactly: the payload is Metadata::toArray(), including __expires, and is rebuilt with the constructor.
• The JSON flags match Doctrine's json type (JSON_PRESERVE_ZERO_FRACTION), so metadata looks the same whether it comes from the cookie or the database.
• CookieBasedPendingMetadataStorage is only the default implementation of PendingMetadataStorageInterface (setono_client.pending_metadata_storage.default). It can be replaced, for example by a session-based storage for apps that prefer that trade-off.
• ChangeAwareMetadata gets markDirty() and markClean().

Behaviour changes

• A new client's row appears on its second request, not its first. Code that loads metadata from the database by client id during the first request (e.g. a message handler) won't find it yet. The README explains how to opt out: alias a storage whose store() returns false.
• StoreCookieSubscriber now runs on kernel.response at priority -64 instead of 0. Listeners with the same priority run in registration order, and SyliusGoogleAdsPlugin sets its metadata on kernel.response at priority 0. At 0, this bundle would usually run first, and the gclid would be persisted right away. -64 runs after default-priority listeners and CacheAttributeListener (-10), and before the profiler (-100) collects the response.
• A vetoed cookie also drops a new client's metadata. When PreStoreCookieEvent vetoes the cookie for a new client, its metadata is no longer persisted: the client never receives its id, so nothing could ever read the row.
• New constructor argument and parameter. StoreCookieSubscriber takes PendingMetadataStorageInterface as its third argument, and the bundle now uses %kernel.secret%.

Testing

• Unit tests cover the storage, the context, the subscriber and ChangeAwareMetadata. The extension test covers the new services.
• tests/Functional/NewClientMetadataTest.php runs the real services through HttpKernel, with an in-memory Doctrine manager:
  • a bot hit doesn't touch the database;
  • a returning browser gets its row on request 2, and request 3 doesn't access the database;
  • oversized metadata, and metadata set after the cookie was stored, are persisted right away;
  • a vetoed cookie persists nothing.
• Run locally:
  • PHPUnit on PHP 8.4, and on PHP 8.1 with Symfony 6.4 using both highest and lowest dependencies;
  • PHPStan, ECS, composer-dependency-analyser and composer validate --strict;
  • Infection: 147 of 147 mutants killed (100% MSI).
• Not yet tried in a real application.

[loevgaard]

Doesn't this belong in a try catch?

[loevgaard]

Shouldn't the two 'metadatas' be merged instead?

[loevgaard]

Do we really need this helper?