Merge main into expand/collapse-all branch

Resolve conflicts in instrumentation-browser, schema-renderer and
configuration-builder-page: keep the SectionExpansionProvider/toolbar
wiring while adopting the i18n labels introduced on main.

Author: lucacavenaghi97

ecosystem-automation/collector-watcher/src/collector_watcher/schema_copier.py

@@ -25,6 +25,7 @@
 import shutil
 from pathlib import Path
 
+import yaml
 from watcher_common.content_hashing import compute_content_hash
 
 logger = logging.getLogger(__name__)
@@ -44,7 +45,8 @@ def store_schema(self, repo_path: Path, schemas_dir: Path) -> str | None:
         The destination is ``schemas_dir / f"{schema_hash}.yaml"``. If a file
         with that name already exists (because the same schema content was
         stored previously), the copy is skipped — the existing file is the
-        canonical record. Returns the schema hash on success.
+        canonical record. Returns the schema hash on success. The schema hash
+        is computed from the normalized YAML content (ignoring comments and key order).
 
         Args:
             repo_path: Path to the checked-out collector repository.
@@ -61,7 +63,7 @@ def store_schema(self, repo_path: Path, schemas_dir: Path) -> str | None:
             logger.debug("Schema file not found in repo at %s, skipping store", src)
             return None
 
-        schema_hash = compute_content_hash(src.read_bytes())
+        schema_hash = self.compute_schema_hash(src)
         dst = schemas_dir / f"{schema_hash}.yaml"
         if dst.exists():
             logger.debug("Schema %s already stored at %s, skipping copy", schema_hash, dst)
@@ -74,8 +76,9 @@ def store_schema(self, repo_path: Path, schemas_dir: Path) -> str | None:
 
     def compute_schema_hash(self, schema_path: Path) -> str:
         """
-        Compute the content hash of a schema file.
+        Compute the content hash of a schema file, ignoring comments and formatting.
 
+        The hash is computed from the normalized YAML representation of the schema.
         Returns ``UNKNOWN_HASH`` when the file is absent — used by component
         YAMLs scanned from older collector tags that pre-date the schema file.
 
@@ -87,4 +90,8 @@ def compute_schema_hash(self, schema_path: Path) -> str:
         """
         if not schema_path.exists():
             return UNKNOWN_HASH
-        return compute_content_hash(schema_path.read_bytes())
+
+        with open(schema_path, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+        normalized_yaml = yaml.safe_dump(data, sort_keys=True)
+        return compute_content_hash(normalized_yaml)

ecosystem-automation/collector-watcher/tests/test_schema_copier.py

@@ -20,6 +20,7 @@
 from pathlib import Path
 
 import pytest
+import yaml
 from collector_watcher.schema_copier import (
     SCHEMA_RELATIVE_PATH,
     UNKNOWN_HASH,
@@ -75,7 +76,10 @@ def test_store_schema_returns_hash_matching_content(fake_repo, schemas_dir):
     schema_hash = copier.store_schema(fake_repo, schemas_dir)
 
     src = fake_repo / SCHEMA_RELATIVE_PATH
-    expected = hashlib.sha256(src.read_bytes()).hexdigest()[:12]
+    with open(src, "r", encoding="utf-8") as f:
+        data = yaml.safe_load(f)
+    normalized = yaml.safe_dump(data, sort_keys=True)
+    expected = hashlib.sha256(normalized.encode("utf-8")).hexdigest()[:12]
     assert schema_hash == expected
 
 
@@ -169,7 +173,10 @@ def test_compute_schema_hash_matches_sha256(fake_repo):
     copier = CollectorSchemaCopier()
     result = copier.compute_schema_hash(schema_path)
 
-    expected = hashlib.sha256(schema_path.read_bytes()).hexdigest()[:12]
+    with open(schema_path, "r", encoding="utf-8") as f:
+        data = yaml.safe_load(f)
+    normalized = yaml.safe_dump(data, sort_keys=True)
+    expected = hashlib.sha256(normalized.encode("utf-8")).hexdigest()[:12]
     assert result == expected
 
 
@@ -201,6 +208,20 @@ def test_compute_schema_hash_returns_unknown_when_absent(temp_dir):
     assert result == UNKNOWN_HASH
 
 
+def test_compute_schema_hash_ignores_comments(fake_repo):
+    schema_path = fake_repo / SCHEMA_RELATIVE_PATH
+    copier = CollectorSchemaCopier()
+
+    h1 = copier.compute_schema_hash(schema_path)
+
+    content = schema_path.read_text(encoding="utf-8")
+    content_with_comments = f"# This is a comment\n{content}\n# Another comment\n"
+    schema_path.write_text(content_with_comments, encoding="utf-8")
+
+    h2 = copier.compute_schema_hash(schema_path)
+    assert h1 == h2
+
+
 # ---------------------------------------------------------------------------
 # Round-trip: store then hash the stored copy
 # ---------------------------------------------------------------------------

ecosystem-automation/explorer-db-builder/src/explorer_db_builder/declarative_name_corrections.py

@@ -51,15 +51,55 @@ def apply_declarative_name_corrections(inventory: dict[str, Any]) -> dict[str, A
             for config in item.get("configurations") or []:
                 if not isinstance(config, dict):
                     continue
-                current = config.get("declarative_name")
-                corrected = DECLARATIVE_NAME_CORRECTIONS.get(current)
+                original_name = config.get("declarative_name")
+                corrected = DECLARATIVE_NAME_CORRECTIONS.get(original_name)
+
                 if corrected is not None:
                     config["declarative_name"] = corrected
                     logger.debug(
                         "Corrected declarative_name %r -> %r for config %r",
-                        current,
+                        original_name,
                         corrected,
                         config.get("name"),
                     )
 
+                current_name = config.get("declarative_name")
+                if current_name == "java.common.service_peer_mapping":
+                    config["declarative_type"] = "structured_list"
+                    config["declarative_schema"] = {
+                        "type": "object",
+                        "required": ["peer", "service_name"],
+                        "properties": {
+                            "peer": {
+                                "type": "string",
+                                "description": "Host name or IP address to match against."
+                            },
+                            "service_name": {
+                                "type": "string",
+                                "description": "Peer service name to record for matching peers.",
+                            },
+                        },
+                    }
+                elif current_name and current_name.endswith("url_template_rules"):
+                    config["declarative_type"] = "structured_list"
+                    config["declarative_schema"] = {
+                        "type": "object",
+                        "required": ["pattern", "template"],
+                        "properties": {
+                            "pattern": {
+                                "type": "string",
+                                "description": "Regular expression matched against the request URL.",
+                            },
+                            "template": {
+                                "type": "string",
+                                "description": "Template used to derive the low-cardinality route.",
+                            },
+                            "override": {
+                                "type": "boolean",
+                                "default": False,
+                                "description": "Whether this rule overrides an already-applied template.",
+                            },
+                        },
+                    }
+
     return inventory

ecosystem-automation/explorer-db-builder/tests/test_declarative_name_corrections.py

@@ -110,3 +110,47 @@ def test_config_without_declarative_name_is_ignored(self):
         apply_declarative_name_corrections(inventory)
 
         assert "declarative_name" not in inventory["libraries"][0]["configurations"][0]
+
+    def test_injects_structured_list_schema_for_service_peer_mapping(self):
+        """java.common.service_peer_mapping receives a structured_list schema injection."""
+        inventory = {
+            "libraries": [
+                {
+                    "name": "some-lib",
+                    "configurations": [
+                        {"declarative_name": "java.common.service_peer_mapping"}
+                    ],
+                }
+            ]
+        }
+
+        apply_declarative_name_corrections(inventory)
+
+        config = inventory["libraries"][0]["configurations"][0]
+        assert config["declarative_type"] == "structured_list"
+        assert config["declarative_schema"]["type"] == "object"
+        assert "peer" in config["declarative_schema"]["required"]
+        assert "service_name" in config["declarative_schema"]["required"]
+
+    def test_injects_structured_list_schema_for_url_template_rules(self):
+        """url_template_rules receives a structured_list schema injection."""
+        inventory = {
+            "libraries": [
+                {
+                    "name": "some-lib",
+                    "configurations": [
+                        {"declarative_name": "some.prefix.url_template_rules"}
+                    ],
+                }
+            ]
+        }
+
+        apply_declarative_name_corrections(inventory)
+
+        config = inventory["libraries"][0]["configurations"][0]
+        assert config["declarative_type"] == "structured_list"
+        assert config["declarative_schema"]["type"] == "object"
+        assert "pattern" in config["declarative_schema"]["required"]
+        assert "template" in config["declarative_schema"]["required"]
+        assert "override" in config["declarative_schema"]["properties"]
+