fix(electric-telemetry): Fix process_type parsing for request processes that have a request id that is not the standard 20 bytes. (#4658)

## Summary

Fixes an unbounded `process_type` cardinality leak in telemetry for
request-handling processes.

## Problem

`process_type` for request-handling processes is derived from the
process label set by `Electric.Plug.LabelProcessPlug`, which looks like:

```
Request F-jPUudNHxbD8lIAABQG - GET /v1/shape?table=users&offset=-1
```

`parse_binary_label/1` is meant to strip the request id and query,
collapsing this to a bounded `GET /v1/shape`. But it did so with a
fixed-width binary match that assumes the request id is exactly 20
bytes:

```elixir
"Request " <> <<_req_id::binary-20, " - ", rest::binary>> -> ...
```

That holds for ids `Plug.RequestId` self-generates, but `Plug.RequestId`
reuses an incoming `x-request-id` header when a client/proxy supplies
one. A UUID (36 chars), an Envoy/nginx id, or an LB trace id is not 20
bytes, so the clause falls through to the generic branch that returns
the first 20 bytes of the whole label — i.e. `Request <first 12 chars of
the id>`. Every distinct incoming request id that GCs slowly then adds a
permanent new series to `prometheus_metrics_dist` for events like
`vm.monitor.long_gc` and `vm.monitor.long_schedule`. Request handlers
building large shape responses are exactly the processes that trip those
monitors, so the table grows without bound when a fronting proxy injects
`x-request-id`.

## Solution

Keep the fast fixed-width binary match for the common 20-byte case
(`Plug.RequestId`'s self-generated ids), and add a slow path that only
runs when the id is a different length: it splits on the `" - "`
delimiter regardless of request-id length, then strips the query string.
All requests to a route collapse to a single `process_type` (e.g. `GET
/v1/shape`) regardless of request-id source or length. A `"Request "`
label with no delimiter falls back to truncation.

---

## Also includes: unrelated CI fix

CI for this PR was failing on `Electric.ShapeCacheTest` (in
`sync-service`, unrelated to the telemetry change). The cause is a
semantic merge collision already on `main`: #4635 changed `wait_until`'s
signature to `wait_until(fun, timeout_ms)` (function first), while #4651
added a new call site at `shape_cache_test.exs:1582` using the old arg
order `wait_until(1000, fn -> ... end)`. The two merged cleanly in git
but not in meaning, so the slow suite raised a `FunctionClauseError` on
every run. This PR swaps the arguments to match the current signature,
unblocking both `main` and this PR.

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: robacourt

.changeset/process-type-request-id-cardinality.md

@@ -0,0 +1,5 @@
+---
+"@core/electric-telemetry": patch
+---
+
+Fix `process_type` parsing for request processes that have a request id that is not the standard 20 bytes.

packages/electric-telemetry/lib/electric/telemetry/processes.ex

@@ -262,26 +262,43 @@ defmodule ElectricTelemetry.Processes do
   defp parse_binary_label(label) do
     case label do
       "Request " <> <<_req_id::binary-20, " - ", rest::binary>> ->
+        # Fast path: the request id is exactly 20 bytes, as generated by Plug.RequestId.
         # This is a request process with the label assigned by Electric.Plug.LabelProcessPlug.
         # We group all requests together to be able to see their aggregated mem footprint.
+        parse_request_label(rest)
+
+      "Request " <> rest ->
+        # Slow path: the request id has a non-default length (e.g. a UUID or a proxy-supplied
+        # x-request-id), so the fixed-width match above failed. Split on the " - " delimiter
+        # instead so all requests to a route collapse to a single label regardless of id length.
+        case :binary.split(rest, " - ") do
+          [_req_id, request] -> parse_request_label(request)
+          _ -> truncate_label(label)
+        end
 
-        # Cut off the URL query part, leaving only the `<method> <path>` prefix.
-        part_len =
-          case :binary.match(rest, "?") do
-            {pos, _} ->
-              pos
+      _ ->
+        truncate_label(label)
+    end
+  end
 
-            :nomatch ->
-              # No query string means only path is present. It is either a request to the health endpoint or something unexpected.
-              byte_size(rest)
-          end
+  defp parse_request_label(request) do
+    # Cut off the URL query part, leaving only the `<method> <path>` prefix.
+    part_len =
+      case :binary.match(request, "?") do
+        {pos, _} ->
+          pos
 
-        :binary.part(rest, 0, part_len)
+        :nomatch ->
+          # No query string means only path is present. It is either a request to the health endpoint or something unexpected.
+          byte_size(request)
+      end
 
-      _ ->
-        # Opportunistic grouping by truncating long labels.
-        part_len = min(20, byte_size(label))
-        :binary.part(label, 0, part_len)
-    end
+    :binary.part(request, 0, part_len)
+  end
+
+  defp truncate_label(label) do
+    # Opportunistic grouping by truncating long labels.
+    part_len = min(20, byte_size(label))
+    :binary.part(label, 0, part_len)
   end
 end

packages/electric-telemetry/test/electric/telemetry/processes_test.exs

@@ -16,6 +16,27 @@ defmodule ElectricTelemetry.ProcessesTest do
       assert "GET /v1/health" = proc_type(pid)
     end
 
+    test "groups request labels with a non-default-length request id (e.g. a proxy-supplied UUID)" do
+      pid =
+        spawn_with_label(
+          "Request 123e4567-e89b-12d3-a456-426614174000 - GET /v1/shape?table=users&offset=-1"
+        )
+
+      assert "GET /v1/shape" = proc_type(pid)
+    end
+
+    test "groups request labels with a shorter-than-default request id" do
+      pid = spawn_with_label("Request abc123 - GET /v1/health")
+
+      assert "GET /v1/health" = proc_type(pid)
+    end
+
+    test "request label with no \" - \" delimiter is truncated" do
+      pid = spawn_with_label("Request something-without-delimiter")
+
+      assert "Request something-wi" = proc_type(pid)
+    end
+
     test "non-request binary labels are truncated to 20 chars" do
       pid = spawn_with_label("some_long_label_that_exceeds_twenty_characters")
 

packages/sync-service/test/electric/shape_cache_test.exs

@@ -1579,10 +1579,13 @@ defmodule Electric.ShapeCacheTest do
       # explicit `start_consumer_for_handle/2` call is required. The
       # continue runs asynchronously after `start_supervised!` returns,
       # so we wait for the registry to populate.
-      assert wait_until(1000, fn ->
-               not is_nil(Electric.Shapes.ConsumerRegistry.whereis(stack_id, shape_handle)) and
-                 not is_nil(Electric.Shapes.ConsumerRegistry.whereis(stack_id, dep_handle))
-             end)
+      assert wait_until(
+               fn ->
+                 not is_nil(Electric.Shapes.ConsumerRegistry.whereis(stack_id, shape_handle)) and
+                   not is_nil(Electric.Shapes.ConsumerRegistry.whereis(stack_id, dep_handle))
+               end,
+               1000
+             )
 
       # Materializer should be started
       assert Process.alive?(