[Discover] [Metrics] Hide internal dimensions from metrics breakdown selector and flyout (elastic#259905)

## Summary

Filter out internal/metadata dimensions (_metric_names_hash, unit,
labels._*) from the parsed metrics response so they don't appear in the
breakdown dimension selector or the view-details flyout. The filtering
is extensible via constant collections for exact names and prefix
patterns.

Resolves
[elastic/observability-dev#5412](elastic/observability-dev#5412)

Internal dimensions like `_metric_names_hash`, `unit`, and `labels._*`
are visible in the breakdown dimension selector and the view-details
flyout. These are internal/metadata fields that shouldn't be exposed to
users.

This PR filters them out in `parseMetricsResponse` before they reach the
UI, using:
- A `Set` for exact-match names (`_metric_names_hash`, `unit`)
- A prefix array for pattern matching (`labels._`)

This is a client-side filter; when/if the server-side `METRICS_INFO`
command excludes these natively, the filter becomes a harmless no-op.

## Test plan

- [ ] Open Discover with metrics data stream
- [ ] Verify `_metric_names_hash`, `unit`, and `labels._*` do **not**
appear in the breakdown dimension selector
- [ ] Click View Details on a metric and verify those dimensions are
absent from the flyout
- [ ] Verify legitimate `labels.*` dimensions (e.g.,
`labels.environment`) still appear

Co-authored-by: Lucas Francisco López <lucaslopezf@gmail.com>

Author: justinkambic

src/platform/packages/shared/kbn-unified-chart-section-viewer/src/components/observability/metrics/utils/parse_metrics_response.test.ts

@@ -205,6 +205,103 @@ describe('parseMetricsResponse', () => {
     expect(dimensionNames).toContain('container.id');
   });
 
+  describe('internal dimension filtering', () => {
+    it('filters out internal dimension _metric_names_hash', () => {
+      const response: MetricsESQLResponse[] = [
+        {
+          metric_name: 'cpu.usage',
+          data_stream: 'my-index',
+          unit: ['percent'],
+          metric_type: 'gauge',
+          field_type: ES_FIELD_TYPES.DOUBLE,
+          dimension_fields: ['host.name', '_metric_names_hash'],
+        },
+      ];
+      const result = parseMetricsResponse(response);
+      expect(result.metricItems[0].dimensionFields).toEqual([{ name: 'host.name' }]);
+      expect(result.allDimensions).toEqual([{ name: 'host.name' }]);
+    });
+
+    it('filters out internal dimension unit', () => {
+      const response: MetricsESQLResponse[] = [
+        {
+          metric_name: 'cpu.usage',
+          data_stream: 'my-index',
+          unit: ['percent'],
+          metric_type: 'gauge',
+          field_type: ES_FIELD_TYPES.DOUBLE,
+          dimension_fields: ['host.name', 'unit'],
+        },
+      ];
+      const result = parseMetricsResponse(response);
+      expect(result.metricItems[0].dimensionFields).toEqual([{ name: 'host.name' }]);
+      expect(result.allDimensions).toEqual([{ name: 'host.name' }]);
+    });
+
+    it('filters out internal dimensions with labels._ prefix', () => {
+      const response: MetricsESQLResponse[] = [
+        {
+          metric_name: 'cpu.usage',
+          data_stream: 'my-index',
+          unit: ['percent'],
+          metric_type: 'gauge',
+          field_type: ES_FIELD_TYPES.DOUBLE,
+          dimension_fields: ['host.name', 'labels._foo_', 'labels._bar_baz_'],
+        },
+      ];
+      const result = parseMetricsResponse(response);
+      expect(result.metricItems[0].dimensionFields).toEqual([{ name: 'host.name' }]);
+      expect(result.allDimensions).toEqual([{ name: 'host.name' }]);
+    });
+
+    it('filters out all internal dimensions while keeping valid ones', () => {
+      const response: MetricsESQLResponse[] = [
+        {
+          metric_name: 'cpu.usage',
+          data_stream: 'my-index',
+          unit: ['percent'],
+          metric_type: 'gauge',
+          field_type: ES_FIELD_TYPES.DOUBLE,
+          dimension_fields: [
+            'host.name',
+            '_metric_names_hash',
+            'unit',
+            'labels._internal_',
+            'pod.name',
+          ],
+        },
+      ];
+      const result = parseMetricsResponse(response);
+      expect(result.metricItems[0].dimensionFields).toEqual([
+        { name: 'host.name' },
+        { name: 'pod.name' },
+      ]);
+      expect(result.allDimensions).toEqual([{ name: 'host.name' }, { name: 'pod.name' }]);
+    });
+
+    it('does not filter non-internal labels dimensions', () => {
+      const response: MetricsESQLResponse[] = [
+        {
+          metric_name: 'cpu.usage',
+          data_stream: 'my-index',
+          unit: ['percent'],
+          metric_type: 'gauge',
+          field_type: ES_FIELD_TYPES.DOUBLE,
+          dimension_fields: ['labels.environment', 'labels.team'],
+        },
+      ];
+      const result = parseMetricsResponse(response);
+      expect(result.metricItems[0].dimensionFields).toEqual([
+        { name: 'labels.environment' },
+        { name: 'labels.team' },
+      ]);
+      expect(result.allDimensions).toEqual([
+        { name: 'labels.environment' },
+        { name: 'labels.team' },
+      ]);
+    });
+  });
+
   describe('with getFieldType', () => {
     const getFieldType = (name: string): string | undefined => {
       const types: Record<string, string> = {

src/platform/packages/shared/kbn-unified-chart-section-viewer/src/components/observability/metrics/utils/parse_metrics_response.ts

@@ -18,6 +18,25 @@ import { ALLOWED_METRIC_TYPES } from '../../../../common/constants';
 
 const ALLOWED_METRIC_TYPES_SET = new Set(ALLOWED_METRIC_TYPES);
 
+/**
+ * Dimension names that are internal metadata and should not be exposed to users.
+ * See: https://github.com/elastic/observability-dev/issues/5412
+ */
+const INTERNAL_DIMENSION_EXACT_NAMES = new Set(['_metric_names_hash', 'unit']);
+
+/**
+ * Dimension name prefixes that indicate internal metadata fields.
+ * Any dimension whose name starts with one of these prefixes will be hidden.
+ */
+const INTERNAL_DIMENSION_PREFIXES = ['labels._'];
+
+const isInternalDimension = (name: string): boolean => {
+  if (INTERNAL_DIMENSION_EXACT_NAMES.has(name)) {
+    return true;
+  }
+  return INTERNAL_DIMENSION_PREFIXES.some((prefix) => name.startsWith(prefix));
+};
+
 export const parseMetricsResponse = (
   response: MetricsESQLResponse[],
   getFieldType?: (name: string) => string | undefined
@@ -44,7 +63,9 @@ export const parseMetricsResponse = (
     const dataStreams = toArray(metric.data_stream);
     const units = toArray(metric.unit);
     const fieldTypes = toArray(metric.field_type);
-    const dimensions = toArray(metric.dimension_fields);
+    const dimensions = toArray(metric.dimension_fields).filter(
+      (name) => !isInternalDimension(name)
+    );
 
     const dimensionFields = dimensions.map((name) => {
       allDimensionsSet.add(name);