ui: Support UTF-8 label names in matchers

[B0go]

Fixes #5042

Summary

The Elm UI parser now accepts any UTF-8 character in label names except reserved characters used in matcher syntax. This enables proper handling of:

• Dotted label names (OpenTelemetry semantic conventions): host.name, service.namespace
• Hyphenated label names (Kubernetes): cluster-id, app-name
• Non-ASCII UTF-8 characters: Προμηθεύς (Prometheus in Greek)

Changes

The isVarChar function was changed from a whitelist approach ([a-zA-Z_0-9]) to a blacklist approach that rejects only reserved characters per the Prometheus documentation: { } ! = ~ , \ " ' `` and whitespace.

Testing

Added 8 new test cases covering:

• Dotted label names with all operators (=, !=, =, !)
• Hyphenated label names
• Greek UTF-8 label names
• Filter parsing with multiple dotted labels

Local tests using the compiled version

Which user-facing changes does this PR introduce?

[BUGFIX] UI: Support UTF-8 label names in matchers (e.g., host.name, service.namespace, cluster-id).

Summary by CodeRabbit

• Bug Fixes

  • Improved filter parsing and label-name validation: parsing now rejects whitespace and reserved syntax characters while allowing broader Unicode label characters.

• Tests

  • Expanded test coverage for filter parsing: dotted names, operators (including regex/not), hyphens, UTF-8, and added a new parseFilter test.

[TheMeier]

LGTM but the reservedChar definition is missing some of the whitespaces in https://pkg.go.dev/unicode#IsSpace
which is used in https://github.com/prometheus/alertmanager/blob/main/matcher/parse/lexer.go#L134

[B0go]

Thanks @TheMeier! Good catch - I've added the missing Latin-1 whitespace characters from unicode.IsSpace: vertical tab (0x0B), form feed (0x0C), NEL (0x85), and NBSP (0xA0).

[SoloJacobs]

Hmm, I think this PR is definitely an improvement. But it does not correctly handle all the whitespace such as EM space echo -e "host\u2003name".

We should probably use the full IsSpace implementation, although maybe the current behaviour is acceptable.

[coderabbitai]

📝 Walkthrough

Walkthrough

Replaced ASCII-only variable character predicate with a deny-list that disallows whitespace and specific syntax characters, allowing UTF-8 characters (including dots) in label names. Added Unicode space detection and a syntaxChars set. Tests expanded to cover dotted, hyphenated, UTF-8 label keys and comma-separated filter parsing.

Changes

Cohort / File(s)	Summary
Core Parsing Logic ui/app/src/Utils/Filter.elm	Replaced isVarChar (ASCII-only) with isReservedChar deny-list; added isSpace (Unicode space detection) and syntaxChars set ({, }, !, =, ~, ,, \, ", ', `). Parser now accepts characters when not (isReservedChar c), enabling UTF-8 and dots in label names. Removed Char import.
Test Coverage ui/app/tests/Filter.elm	Updated module export to include parseFilter. Expanded parseMatcher tests for dotted keys (single/multiple segments), =~/!~, !=, hyphenated names, UTF-8 names, and a negative NBSP case. Added parseFilter tests validating comma-separated filters (including dotted labels).

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~20 minutes

Poem

🐰 I hopped past ASCII gates at last,
Dots and UTF‑8 no longer cast.
Reserved marks kept off the trail,
Parsers whisper, never fail.
A tiny hop — tests green and fast.

🚥 Pre-merge checks | ✅ 5

✅ Passed checks (5 passed)

Check name	Status	Explanation
Title check	✅ Passed	The title 'ui: Support UTF-8 label names in matchers' clearly and concisely describes the main change, following the 'area: description' convention specified in the template.
Description check	✅ Passed	The description covers the main requirement (Fixes #5042), explains the changes made, includes test cases added, provides release notes, and follows most of the template guidance. One test case addition is mentioned but detailed verification is limited.
Linked Issues check	✅ Passed	The PR code changes directly address issue #5042 by replacing the ASCII-only whitelist with a blacklist approach that accepts UTF-8 characters except reserved syntax characters, enabling dotted labels, hyphens, and non-ASCII names in matchers. Eight test cases were added covering the specified scenarios.
Out of Scope Changes check	✅ Passed	All code changes are scoped to supporting UTF-8 label names in matchers: Filter.elm modifications for character validation and Filter.elm test expansions. No unrelated changes detected.
Docstring Coverage	✅ Passed	No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests

---

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

Tip

You can validate your CodeRabbit configuration file in your editor.

If your editor has YAML language server, you can enable auto-completion and validation by adding # yaml-language-server: $schema=https://coderabbit.ai/integrations/schema.v2.json at the top of your CodeRabbit configuration file.

[B0go]

We should probably use the full IsSpace implementation, although maybe the current behaviour is acceptable.

Good point @SoloJacobs, I evolved the implementation by introducing isSpace and covering all the characters in the Golang equivalent. Thanks

[coderabbitai]

🧹 Nitpick comments (1)

ui/app/tests/Filter.elm (1)

29-58: Cover the last operator branch and one Unicode-whitespace rejection case.

The new suite hits =, !=, and =~, but !~ is still uncovered, and the hand-maintained whitespace blacklist has no direct regression test yet. One dotted-key !~ case plus a NBSP failure case would keep both edges from drifting.

Suggested test additions

         , test "should parse dotted label name with regex match" <|
             \() ->
                 Expect.equal
                     (Just (Matcher "host.name" RegexMatch "server-.*"))
                     (Utils.Filter.parseMatcher "host.name=~\"server-.*\"")
+        , test "should parse dotted label name with not regex match" <|
+            \() ->
+                Expect.equal
+                    (Just (Matcher "host.name" NotRegexMatch "server-.*"))
+                    (Utils.Filter.parseMatcher "host.name!~\"server-.*\"")
         , test "should parse dotted label name with not equal" <|
             \() ->
                 Expect.equal
                     (Just (Matcher "host.type" NotEq "test"))
                     (Utils.Filter.parseMatcher "host.type!=\"test\"")
@@
         , test "should parse UTF-8 label name" <|
             \() ->
                 Expect.equal
                     (Just (Matcher "Προμηθεύς" Eq "alerts"))
                     (Utils.Filter.parseMatcher "Προμηθεύς=\"alerts\"")
+        , test "should reject NBSP in label name" <|
+            \() ->
+                let
+                    nbsp =
+                        String.fromChar (Char.fromCode 0xA0)
+                in
+                Expect.equal
+                    Nothing
+                    (Utils.Filter.parseMatcher ("host" ++ nbsp ++ "name=\"server-01\""))

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@ui/app/tests/Filter.elm` around lines 29 - 58, Add tests exercising the
uncovered not-regex operator and the Unicode-whitespace rejection: add a case
asserting Utils.Filter.parseMatcher returns Just (Matcher "<dotted-key>"
RegexNotMatch "<pattern>") (or the code's NotRegex/NotRegexMatch variant—use the
exact constructor used elsewhere) for a dotted key using the "!~" operator
(e.g., "host.name!~\"server-.*\""), and add a negative test that parsing fails
(returns Nothing) when the input contains a non-breaking space (U+00A0) inside
the label or around the operator (e.g., "label\u00A0=\"value\"" or similar) to
ensure the hand-maintained whitespace blacklist rejects NBSP; reference
Utils.Filter.parseMatcher and the Matcher constructor to locate where to add
these tests.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Nitpick comments:
In `@ui/app/tests/Filter.elm`:
- Around line 29-58: Add tests exercising the uncovered not-regex operator and
the Unicode-whitespace rejection: add a case asserting Utils.Filter.parseMatcher
returns Just (Matcher "<dotted-key>" RegexNotMatch "<pattern>") (or the code's
NotRegex/NotRegexMatch variant—use the exact constructor used elsewhere) for a
dotted key using the "!~" operator (e.g., "host.name!~\"server-.*\""), and add a
negative test that parsing fails (returns Nothing) when the input contains a
non-breaking space (U+00A0) inside the label or around the operator (e.g.,
"label\u00A0=\"value\"" or similar) to ensure the hand-maintained whitespace
blacklist rejects NBSP; reference Utils.Filter.parseMatcher and the Matcher
constructor to locate where to add these tests.

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Run ID: c47cb22c-b3bc-4e15-abad-2da67a8c76d4

📥 Commits

Reviewing files that changed from the base of the PR and between 35cbf8d and 024c839.

📒 Files selected for processing (3)

• ui/app/script.js
• ui/app/src/Utils/Filter.elm
• ui/app/tests/Filter.elm

[coderabbitai]

🧹 Nitpick comments (1)

ui/app/tests/Filter.elm (1)

125-146: Add parseFilter parity tests for hyphenated and UTF-8 keys.

parseFilter now has good dotted-key coverage, but adding filter-level tests for hyphenated/UTF-8 keys (and NBSP rejection) would better protect the full parser pipeline.

✅ Suggested test additions

 parseFilter : Test
 parseFilter =
     describe "parseFilter"
         [ test "should parse filter with dotted label names" <|
             \() ->
                 Expect.equal
                     (Just
                         [ Matcher "host.name" Eq "server-01"
                         , Matcher "service.namespace" Eq "myapp"
                         ]
                     )
                     (Utils.Filter.parseFilter "{host.name=\"server-01\", service.namespace=\"myapp\"}")
         , test "should parse filter with mixed label names" <|
             \() ->
                 Expect.equal
                     (Just
                         [ Matcher "alertname" Eq "MyAlert"
                         , Matcher "host.name" Eq "server-01"
                         ]
                     )
                     (Utils.Filter.parseFilter "{alertname=\"MyAlert\", host.name=\"server-01\"}")
+        , test "should parse filter with hyphenated and UTF-8 label names" <|
+            \() ->
+                Expect.equal
+                    (Just
+                        [ Matcher "cluster-id" Eq "prod-us-east"
+                        , Matcher "Προμηθεύς" Eq "alerts"
+                        ]
+                    )
+                    (Utils.Filter.parseFilter "{cluster-id=\"prod-us-east\", Προμηθεύς=\"alerts\"}")
+        , test "should reject NBSP in filter label name" <|
+            \() ->
+                let
+                    nbsp =
+                        String.fromChar (Char.fromCode 0xA0)
+                in
+                Expect.equal
+                    Nothing
+                    (Utils.Filter.parseFilter ("{host" ++ nbsp ++ "name=\"server-01\"}"))
         ]

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@ui/app/tests/Filter.elm` around lines 125 - 146, Add parity tests to
parseFilter to cover hyphenated and UTF-8 keys and ensure NBSP rejection: extend
the parseFilter Test (using Utils.Filter.parseFilter, Matcher and Eq) with cases
that assert parsing succeeds for keys like "my-key" and UTF-8 keys (e.g.,
"médecin" or non-ASCII characters) returning the expected Matcher list, and add
a negative test that passes a filter containing a non-breaking space (NBSP) in a
key and asserts the result is Nothing; keep the same test structure and
Expect.equal comparisons as the existing dotted-key cases.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Nitpick comments:
In `@ui/app/tests/Filter.elm`:
- Around line 125-146: Add parity tests to parseFilter to cover hyphenated and
UTF-8 keys and ensure NBSP rejection: extend the parseFilter Test (using
Utils.Filter.parseFilter, Matcher and Eq) with cases that assert parsing
succeeds for keys like "my-key" and UTF-8 keys (e.g., "médecin" or non-ASCII
characters) returning the expected Matcher list, and add a negative test that
passes a filter containing a non-breaking space (NBSP) in a key and asserts the
result is Nothing; keep the same test structure and Expect.equal comparisons as
the existing dotted-key cases.

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Run ID: 990d4460-0ab5-4a06-a9cc-fdaf5affa7d7

📥 Commits

Reviewing files that changed from the base of the PR and between 024c839 and 8fce24c.

📒 Files selected for processing (1)

• ui/app/tests/Filter.elm

[SoloJacobs]

LGTM, very nice 👍

[coderabbitai]

🧹 Nitpick comments (1)

ui/app/tests/Filter.elm (1)

125-146: Consider adding one mixed-operator parseFilter case.

parseFilter tests currently exercise only Eq. Adding one comma-separated case with =~, !~, and != would lock in full operator behavior for multi-matcher filters.

Suggested test addition

 parseFilter : Test
 parseFilter =
     describe "parseFilter"
         [ test "should parse filter with dotted label names" <|
             \() ->
                 Expect.equal
                     (Just
                         [ Matcher "host.name" Eq "server-01"
                         , Matcher "service.namespace" Eq "myapp"
                         ]
                     )
                     (Utils.Filter.parseFilter "{host.name=\"server-01\", service.namespace=\"myapp\"}")
         , test "should parse filter with mixed label names" <|
             \() ->
                 Expect.equal
                     (Just
                         [ Matcher "alertname" Eq "MyAlert"
                         , Matcher "host.name" Eq "server-01"
                         ]
                     )
                     (Utils.Filter.parseFilter "{alertname=\"MyAlert\", host.name=\"server-01\"}")
+        , test "should parse filter with dotted labels and mixed operators" <|
+            \() ->
+                Expect.equal
+                    (Just
+                        [ Matcher "host.name" RegexMatch "server-.*"
+                        , Matcher "service.namespace" NotRegexMatch "dev-.*"
+                        , Matcher "cluster-id" NotEq "staging"
+                        ]
+                    )
+                    (Utils.Filter.parseFilter "{host.name=~\"server-.*\", service.namespace!~\"dev-.*\", cluster-id!=\"staging\"}")
         ]

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@ui/app/tests/Filter.elm` around lines 125 - 146, Add a new test case inside
the parseFilter describe block to validate mixed operators for multi-matcher
filters: call Utils.Filter.parseFilter with a comma-separated input that uses
=~, !~ and != (in addition to =) and assert it returns Just with Matchers using
the appropriate operators (e.g., Matcher "labelA" ReMatches "...", Matcher
"labelB" NotReMatches "...", Matcher "labelC" NotEq "..." etc.). Place the case
alongside the existing tests in the parseFilter Test value so it verifies
operator parsing for multi-matcher inputs.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Nitpick comments:
In `@ui/app/tests/Filter.elm`:
- Around line 125-146: Add a new test case inside the parseFilter describe block
to validate mixed operators for multi-matcher filters: call
Utils.Filter.parseFilter with a comma-separated input that uses =~, !~ and !=
(in addition to =) and assert it returns Just with Matchers using the
appropriate operators (e.g., Matcher "labelA" ReMatches "...", Matcher "labelB"
NotReMatches "...", Matcher "labelC" NotEq "..." etc.). Place the case alongside
the existing tests in the parseFilter Test value so it verifies operator parsing
for multi-matcher inputs.

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Run ID: 1aa65b87-022b-4650-82a7-38f46006e99d

📥 Commits

Reviewing files that changed from the base of the PR and between 8fce24c and 8a1428d.

📒 Files selected for processing (3)

• ui/app/script.js
• ui/app/src/Utils/Filter.elm
• ui/app/tests/Filter.elm

[B0go]

Thanks @SoloJacobs, do you have any idea on when a next release might be live?

[SoloJacobs]

I keep this file, up to date: https://github.com/prometheus/alertmanager/blob/main/RELEASE.md (It often changes, but no such plans, yet).