ref(generic-metrics): Migrate UseCaseKey to UseCaseID for organization metrics (#51776)

Co-authored-by: Radu Woinaroski <5281987+RaduW@users.noreply.github.com>

src/sentry/api/endpoints/organization_metrics.py

@@ -7,7 +7,8 @@ from sentry.api.bases.organization import OrganizationEndpoint
 from sentry.api.exceptions import ResourceDoesNotExist
 from sentry.api.paginator import GenericOffsetPaginator
 from sentry.api.utils import InvalidParams
-from sentry.sentry_metrics.configuration import UseCaseKey
+from sentry.sentry_metrics.use_case_id_registry import UseCaseID
+from sentry.sentry_metrics.utils import string_to_use_case_id
 from sentry.snuba.metrics import (
     QueryDefinition,
     get_metrics,
@@ -21,17 +22,18 @@ from sentry.snuba.sessions_v2 import InvalidField
 from sentry.utils.cursors import Cursor, CursorResult
 
 
-def get_use_case_id(request: Request) -> UseCaseKey:
+def get_use_case_id(request: Request) -> UseCaseID:
     """
-    Get useCase from query params and validate it against UseCaseKey enum type
+    Get useCase from query params and validate it against UseCaseID enum type
     Raise a ParseError if the use_case parameter is invalid.
     """
 
     try:
-        return UseCaseKey(request.GET.get("useCase", "release-health"))
+        use_case_param = request.GET.get("useCase", "sessions")
+        return string_to_use_case_id(use_case_param)
     except ValueError:
         raise ParseError(
-            detail=f"Invalid useCase parameter. Please use one of: {[uc.value for uc in UseCaseKey]}"
+            detail=f"Invalid useCase parameter. Please use one of: {[uc.value for uc in UseCaseID]}"
         )
 
 

src/sentry/ingest/billing_metrics_consumer.py

@@ -12,8 +12,8 @@ from arroyo.types import Commit, Message, Partition
 from django.conf import settings
 
 from sentry.constants import DataCategory
-from sentry.sentry_metrics.configuration import UseCaseKey
 from sentry.sentry_metrics.indexer.strings import SHARED_TAG_STRINGS, TRANSACTION_METRICS_NAMES
+from sentry.sentry_metrics.use_case_id_registry import UseCaseID
 from sentry.sentry_metrics.utils import reverse_resolve_tag_value
 from sentry.utils import json
 from sentry.utils.kafka_config import get_kafka_consumer_cluster_options, get_topic_definition
@@ -143,7 +143,7 @@ class BillingTxCountMetricConsumerStrategy(ProcessingStrategy[KafkaPayload]):
         return bool(
             (tag_value := bucket["tags"].get(self.profile_tag_key))
             and "true"
-            == reverse_resolve_tag_value(UseCaseKey.PERFORMANCE, bucket["org_id"], tag_value)
+            == reverse_resolve_tag_value(UseCaseID.TRANSACTIONS, bucket["org_id"], tag_value)
         )
 
     def _produce_billing_outcomes(self, payload: MetricsBucket) -> None:

src/sentry/release_health/metrics.py

@@ -45,7 +45,7 @@ from sentry.release_health.base import (
 )
 from sentry.release_health.metrics_sessions_v2 import run_sessions_query
 from sentry.sentry_metrics import indexer
-from sentry.sentry_metrics.configuration import UseCaseKey
+from sentry.sentry_metrics.use_case_id_registry import UseCaseID
 from sentry.snuba.metrics import (
     MetricField,
     MetricGroupByField,
@@ -75,7 +75,7 @@ MINUTE = 60  # 60 seconds
 HOUR = MINUTE * 60
 DAY = HOUR * 24
 LEGACY_SESSIONS_DEFAULT_ROLLUP = HOUR
-USE_CASE_ID = UseCaseKey.RELEASE_HEALTH
+USE_CASE_ID = UseCaseID.SESSIONS
 
 logger = logging.getLogger(__name__)
 

src/sentry/release_health/metrics_sessions_v2.py

@@ -52,7 +52,7 @@ from sentry.release_health.base import (
     SessionsQueryResult,
     SessionsQueryValue,
 )
-from sentry.sentry_metrics.configuration import UseCaseKey
+from sentry.sentry_metrics.use_case_id_registry import UseCaseID
 from sentry.snuba.metrics import get_public_name_from_mri
 from sentry.snuba.metrics.datasource import get_series
 from sentry.snuba.metrics.naming_layer import SessionMRI
@@ -570,7 +570,7 @@ def run_sessions_query(
         metrics_results = get_series(
             projects,
             metrics_query,
-            use_case_id=UseCaseKey.RELEASE_HEALTH,
+            use_case_id=UseCaseID.SESSIONS,
             tenant_ids={"organization_id": org_id},
         )
     except OrderByNotSupportedOverCompositeEntityException:

src/sentry/release_health/release_monitor/metrics.py

@@ -19,7 +19,6 @@ from snuba_sdk import (
 
 from sentry.release_health.release_monitor.base import BaseReleaseMonitorBackend, Totals
 from sentry.sentry_metrics import indexer
-from sentry.sentry_metrics.configuration import UseCaseKey
 from sentry.sentry_metrics.indexer.strings import SESSION_METRIC_NAMES
 from sentry.sentry_metrics.use_case_id_registry import UseCaseID
 from sentry.sentry_metrics.utils import resolve_tag_key
@@ -103,9 +102,9 @@ class MetricReleaseMonitorBackend(BaseReleaseMonitorBackend):
         totals: Totals = defaultdict(dict)
         with metrics.timer("release_monitor.fetch_project_release_health_totals.loop"):
             while (time.time() - start_time) < self.MAX_SECONDS:
-                release_key = resolve_tag_key(UseCaseKey.RELEASE_HEALTH, org_id, "release")
+                release_key = resolve_tag_key(UseCaseID.SESSIONS, org_id, "release")
                 release_col = Column(release_key)
-                env_key = resolve_tag_key(UseCaseKey.RELEASE_HEALTH, org_id, "environment")
+                env_key = resolve_tag_key(UseCaseID.SESSIONS, org_id, "environment")
                 env_col = Column(env_key)
                 query = (
                     Query(
@@ -134,7 +133,7 @@ class MetricReleaseMonitorBackend(BaseReleaseMonitorBackend):
                                 Column("metric_id"),
                                 Op.EQ,
                                 indexer.resolve(
-                                    UseCaseKey.RELEASE_HEALTH, org_id, SessionMRI.SESSION.value
+                                    UseCaseID.SESSIONS, org_id, SessionMRI.SESSION.value
                                 ),
                             ),
                         ],

src/sentry/search/events/builder/metrics.py

@@ -36,7 +36,6 @@ from sentry.search.events.types import (
     WhereType,
 )
 from sentry.sentry_metrics import indexer
-from sentry.sentry_metrics.configuration import UseCaseKey
 from sentry.sentry_metrics.use_case_id_registry import UseCaseID
 from sentry.snuba.dataset import Dataset
 from sentry.snuba.metrics.extraction import QUERY_HASH_KEY, OndemandMetricSpec, is_on_demand_query
@@ -708,9 +707,9 @@ class MetricsQueryBuilder(QueryBuilder):
                     metrics_data = get_series(
                         projects=self.params.projects,
                         metrics_query=metric_query,
-                        use_case_id=UseCaseKey.PERFORMANCE
+                        use_case_id=UseCaseID.TRANSACTIONS
                         if self.is_performance
-                        else UseCaseKey.RELEASE_HEALTH,
+                        else UseCaseID.SESSIONS,
                         include_meta=True,
                         tenant_ids=self.tenant_ids,
                     )
@@ -903,9 +902,7 @@ class AlertMetricsQueryBuilder(MetricsQueryBuilder):
             snuba_queries, _ = SnubaQueryBuilder(
                 projects=self.params.projects,
                 metrics_query=metrics_query,
-                use_case_id=UseCaseKey.PERFORMANCE
-                if self.is_performance
-                else UseCaseKey.RELEASE_HEALTH,
+                use_case_id=UseCaseID.TRANSACTIONS if self.is_performance else UseCaseID.SESSIONS,
             ).get_snuba_queries()
 
             if len(snuba_queries) != 1:
@@ -1117,9 +1114,9 @@ class TimeseriesMetricQueryBuilder(MetricsQueryBuilder):
                     metrics_data = get_series(
                         projects=self.params.projects,
                         metrics_query=metric_query,
-                        use_case_id=UseCaseKey.PERFORMANCE
+                        use_case_id=UseCaseID.TRANSACTIONS
                         if self.is_performance
-                        else UseCaseKey.RELEASE_HEALTH,
+                        else UseCaseID.SESSIONS,
                         include_meta=True,
                         tenant_ids=self.tenant_ids,
                     )

src/sentry/sentry_metrics/use_case_id_registry.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Mapping
+from typing import Mapping, Optional
 
 from sentry.sentry_metrics.configuration import UseCaseKey
 
@@ -40,5 +40,5 @@ USE_CASE_ID_WRITES_LIMIT_QUOTA_OPTIONS = {
 }
 
 
-def get_metric_path_from_usecase(use_case: UseCaseID) -> UseCaseKey:
-    return METRIC_PATH_MAPPING[use_case]
+def get_use_case_key(use_case_id: UseCaseID) -> Optional[UseCaseKey]:
+    return METRIC_PATH_MAPPING.get(use_case_id)

src/sentry/sentry_metrics/utils.py

@@ -3,7 +3,8 @@ from typing import Collection, Dict, Mapping, Optional, Sequence, Set, Union, ca
 from sentry.api.utils import InvalidParams
 from sentry.sentry_metrics import indexer
 from sentry.sentry_metrics.configuration import UseCaseKey
-from sentry.sentry_metrics.use_case_id_registry import UseCaseID
+from sentry.sentry_metrics.indexer.base import to_use_case_id
+from sentry.sentry_metrics.use_case_id_registry import METRIC_PATH_MAPPING, UseCaseID
 
 #: Special integer used to represent a string missing from the indexer
 STRING_NOT_FOUND = -1
@@ -16,9 +17,22 @@ class MetricIndexNotFound(InvalidParams):
     pass
 
 
+def string_to_use_case_id(value: str) -> UseCaseID:
+    try:
+        return UseCaseID(value)
+    except ValueError:
+        # param doesn't appear to be a UseCaseID try with the obsolete UseCaseKey
+        # will raise ValueError if it fails
+        return to_use_case_id(UseCaseKey(value))
+
+
 def reverse_resolve_tag_value(
-    use_case_id: UseCaseKey, org_id: int, index: Union[int, str, None], weak: bool = False
+    use_case_id: Union[UseCaseID, UseCaseKey],
+    org_id: int,
+    index: Union[int, str, None],
+    weak: bool = False,
 ) -> Optional[str]:
+    use_case_id = to_use_case_id(use_case_id)
     if isinstance(index, str) or index is None:
         return index
     else:
@@ -70,8 +84,9 @@ def bulk_reverse_resolve_tag_value(
     return {**ret_val, **resolved_indexes}
 
 
-def reverse_resolve(use_case_id: UseCaseKey, org_id: int, index: int) -> str:
+def reverse_resolve(use_case_id: Union[UseCaseID, UseCaseKey], org_id: int, index: int) -> str:
     assert index > 0
+    use_case_id = to_use_case_id(use_case_id)
     resolved = indexer.reverse_resolve(use_case_id, org_id, index)
     # The indexer should never return None for integers > 0:
     if resolved is None:
@@ -93,7 +108,9 @@ def bulk_reverse_resolve(
     return indexer.bulk_reverse_resolve(use_case_id, org_id, indexes_to_resolve)
 
 
-def reverse_resolve_weak(use_case_id: UseCaseKey, org_id: int, index: int) -> Optional[str]:
+def reverse_resolve_weak(
+    use_case_id: Union[UseCaseID, UseCaseKey], org_id: int, index: int
+) -> Optional[str]:
     """
     Resolve an index value back to a string, special-casing 0 to return None.
 
@@ -101,6 +118,7 @@ def reverse_resolve_weak(use_case_id: UseCaseKey, org_id: int, index: int) -> Op
     tuple for metric buckets that are missing that tag, i.e. `tags[123] == 0`.
     """
 
+    use_case_id = to_use_case_id(use_case_id)
     if index == TAG_NOT_SET:
         return None
 
@@ -108,10 +126,11 @@ def reverse_resolve_weak(use_case_id: UseCaseKey, org_id: int, index: int) -> Op
 
 
 def resolve(
-    use_case_id: UseCaseKey,
+    use_case_id: Union[UseCaseID, UseCaseKey],
     org_id: int,
     string: str,
 ) -> int:
+    use_case_id = to_use_case_id(use_case_id)
     resolved = indexer.resolve(use_case_id, org_id, string)
     if resolved is None:
         raise MetricIndexNotFound(f"Unknown string: {string!r}")
@@ -119,26 +138,31 @@ def resolve(
     return resolved
 
 
-def resolve_tag_key(use_case_id: UseCaseKey, org_id: int, string: str) -> str:
+def resolve_tag_key(use_case_id: Union[UseCaseID, UseCaseKey], org_id: int, string: str) -> str:
+    use_case_id = to_use_case_id(use_case_id)
     resolved = resolve(use_case_id, org_id, string)
-    assert use_case_id in (UseCaseKey.PERFORMANCE, UseCaseKey.RELEASE_HEALTH)
-    if use_case_id == UseCaseKey.PERFORMANCE:
+    assert isinstance(use_case_id, UseCaseID)
+    if METRIC_PATH_MAPPING[use_case_id] is UseCaseKey.PERFORMANCE:
         return f"tags_raw[{resolved}]"
     else:
         return f"tags[{resolved}]"
 
 
-def resolve_tag_value(use_case_id: UseCaseKey, org_id: int, string: str) -> Union[str, int]:
+def resolve_tag_value(
+    use_case_id: Union[UseCaseID, UseCaseKey], org_id: int, string: str
+) -> Union[str, int]:
+    use_case_id = to_use_case_id(use_case_id)
     assert isinstance(string, str)
-    assert use_case_id in (UseCaseKey.PERFORMANCE, UseCaseKey.RELEASE_HEALTH)
-    if use_case_id == UseCaseKey.PERFORMANCE:
+    assert isinstance(use_case_id, UseCaseID)
+    if METRIC_PATH_MAPPING[use_case_id] is UseCaseKey.PERFORMANCE:
         return string
     return resolve_weak(use_case_id, org_id, string)
 
 
 def resolve_tag_values(
-    use_case_id: UseCaseKey, org_id: int, strings: Sequence[str]
+    use_case_id: Union[UseCaseID, UseCaseKey], org_id: int, strings: Sequence[str]
 ) -> Sequence[Union[str, int]]:
+    use_case_id = to_use_case_id(use_case_id)
     rv = []
     for string in strings:
         resolved = resolve_tag_value(use_case_id, org_id, string)
@@ -148,7 +172,7 @@ def resolve_tag_values(
     return rv
 
 
-def resolve_weak(use_case_id: UseCaseKey, org_id: int, string: str) -> int:
+def resolve_weak(use_case_id: Union[UseCaseID, UseCaseKey], org_id: int, string: str) -> int:
     """
     A version of `resolve` that returns -1 for missing values.
 
@@ -156,6 +180,7 @@ def resolve_weak(use_case_id: UseCaseKey, org_id: int, string: str) -> int:
     useful to make the WHERE-clause "impossible" with `WHERE x = -1` instead of
     explicitly handling that exception.
     """
+    use_case_id = to_use_case_id(use_case_id)
     resolved = indexer.resolve(use_case_id, org_id, string)
     if resolved is None:
         return STRING_NOT_FOUND
@@ -164,12 +189,13 @@ def resolve_weak(use_case_id: UseCaseKey, org_id: int, string: str) -> int:
 
 
 def resolve_many_weak(
-    use_case_id: UseCaseKey, org_id: int, strings: Sequence[str]
+    use_case_id: Union[UseCaseID, UseCaseKey], org_id: int, strings: Sequence[str]
 ) -> Sequence[int]:
     """
     Resolve multiple values at once, omitting missing ones. This is useful in
     the same way as `resolve_weak` is, e.g. `WHERE x in values`.
     """
+    use_case_id = to_use_case_id(use_case_id)
     rv = []
     for string in strings:
         resolved = resolve_weak(use_case_id, org_id, string)

src/sentry/snuba/entity_subscription.py

@@ -24,7 +24,7 @@ from sentry import features
 from sentry.constants import CRASH_RATE_ALERT_AGGREGATE_ALIAS, CRASH_RATE_ALERT_SESSION_COUNT_ALIAS
 from sentry.exceptions import InvalidQuerySubscription, UnsupportedQuerySubscription
 from sentry.models import Environment, Organization
-from sentry.sentry_metrics.configuration import UseCaseKey
+from sentry.sentry_metrics.use_case_id_registry import UseCaseID
 from sentry.sentry_metrics.utils import (
     MetricIndexNotFound,
     resolve,
@@ -324,29 +324,29 @@ class BaseMetricsEntitySubscription(BaseEntitySubscription, ABC):
             "granularity": self.get_granularity(),
         }
 
-    def _get_use_case_key(self) -> UseCaseKey:
+    def _get_use_case_id(self) -> UseCaseID:
         if self.dataset == Dataset.PerformanceMetrics:
-            return UseCaseKey.PERFORMANCE
+            return UseCaseID.TRANSACTIONS
         else:
-            return UseCaseKey.RELEASE_HEALTH
+            return UseCaseID.SESSIONS
 
     def resolve_tag_key_if_needed(self, string: str) -> str:
         if self.use_metrics_layer:
             return string
 
-        return resolve_tag_key(self._get_use_case_key(), self.org_id, string)
+        return resolve_tag_key(self._get_use_case_id(), self.org_id, string)
 
     def resolve_tag_value_if_needed(self, string: str) -> Union[str, int]:
         if self.use_metrics_layer:
             return string
 
-        return resolve_tag_value(self._get_use_case_key(), self.org_id, string)
+        return resolve_tag_value(self._get_use_case_id(), self.org_id, string)
 
     def resolve_tag_values_if_needed(self, strings: Sequence[str]) -> Sequence[Union[str, int]]:
         if self.use_metrics_layer:
             return strings
 
-        return resolve_tag_values(self._get_use_case_key(), self.org_id, strings)
+        return resolve_tag_values(self._get_use_case_id(), self.org_id, strings)
 
     def _get_environment_condition(self, environment_name: str) -> Condition:
         return Condition(
@@ -445,10 +445,10 @@ class BaseCrashRateMetricsEntitySubscription(BaseMetricsEntitySubscription):
         value_col_name = alias if alias else "value"
         try:
             translated_data: Dict[str, Any] = {}
-            session_status = resolve_tag_key(UseCaseKey.RELEASE_HEALTH, org_id, "session.status")
+            session_status = resolve_tag_key(UseCaseID.SESSIONS, org_id, "session.status")
             for row in data:
                 tag_value = reverse_resolve_tag_value(
-                    UseCaseKey.RELEASE_HEALTH, org_id, row[session_status]
+                    UseCaseID.SESSIONS, org_id, row[session_status]
                 )
                 if tag_value is None:
                     raise MetricIndexNotFound()
@@ -540,7 +540,7 @@ class BaseCrashRateMetricsEntitySubscription(BaseMetricsEntitySubscription):
                 Condition(
                     Column("metric_id"),
                     Op.EQ,
-                    resolve(UseCaseKey.RELEASE_HEALTH, self.org_id, self.metric_key.value),
+                    resolve(UseCaseID.SESSIONS, self.org_id, self.metric_key.value),
                 )
             ]
 

src/sentry/snuba/metrics/datasource.py

@@ -1,8 +1,5 @@
 from __future__ import annotations
 
-from sentry.sentry_metrics.indexer.base import to_use_case_id
-from sentry.sentry_metrics.use_case_id_registry import UseCaseID
-
 """
 Module that gets both metadata and time series from Snuba.
 For metadata, it fetch metrics metadata (metric names, tag names, tag values, ...) from snuba.
@@ -27,7 +24,7 @@ from snuba_sdk.conditions import ConditionGroup
 from sentry.api.utils import InvalidParams
 from sentry.models import Project
 from sentry.sentry_metrics import indexer
-from sentry.sentry_metrics.configuration import UseCaseKey
+from sentry.sentry_metrics.use_case_id_registry import UseCaseID
 from sentry.sentry_metrics.utils import (
     MetricIndexNotFound,
     bulk_reverse_resolve,
@@ -94,7 +91,7 @@ def _get_metrics_for_entity(
 def get_available_derived_metrics(
     projects: Sequence[Project],
     supported_metric_ids_in_entities: Dict[MetricType, Sequence[int]],
-    use_case_id: UseCaseKey,
+    use_case_id: UseCaseID,
 ) -> Set[str]:
     """
     Function that takes as input a dictionary of the available ids in each entity, and in turn
@@ -142,7 +139,7 @@ def get_available_derived_metrics(
     return found_derived_metrics.intersection(public_derived_metrics)
 
 
-def get_metrics(projects: Sequence[Project], use_case_id: UseCaseKey) -> Sequence[MetricMeta]:
+def get_metrics(projects: Sequence[Project], use_case_id: UseCaseID) -> Sequence[MetricMeta]:
     ENTITY_TO_DATASET = {
         "sessions": {
             "c": "metrics_counters",
@@ -224,7 +221,7 @@ def get_custom_measurements(
 
 
 def _get_metrics_filter_ids(
-    projects: Sequence[Project], metric_mris: Sequence[str], use_case_id: UseCaseKey
+    projects: Sequence[Project], metric_mris: Sequence[str], use_case_id: UseCaseID
 ) -> Set[int]:
     """
     Returns a set of metric_ids that map to input metric names and raises an exception if
@@ -263,7 +260,7 @@ def _validate_requested_derived_metrics_in_input_metrics(
     projects: Sequence[Project],
     metric_mris: Sequence[str],
     supported_metric_ids_in_entities: Dict[MetricType, Sequence[int]],
-    use_case_id: UseCaseKey,
+    use_case_id: UseCaseID,
 ) -> None:
     """
     Function that takes metric_mris list and a mapping of entity to its metric ids, and ensures
@@ -292,7 +289,7 @@ def _fetch_tags_or_values_for_metrics(
     metric_names: Optional[Sequence[str]],
     referrer: str,
     column: str,
-    use_case_id: UseCaseKey,
+    use_case_id: UseCaseID,
 ) -> Tuple[Union[Sequence[Tag], Sequence[TagValue]], Optional[str]]:
     assert len({p.organization_id for p in projects}) == 1
 
@@ -306,7 +303,7 @@ def _fetch_tags_or_values_for_mri(
     metric_mris: Optional[Sequence[str]],
     referrer: str,
     column: str,
-    use_case_key: UseCaseKey,
+    use_case_id: UseCaseID,
 ) -> Tuple[Union[Sequence[Tag], Sequence[TagValue]], Optional[str]]:
     """
     Function that takes as input projects, metric_mris, and a column, and based on the column
@@ -316,7 +313,6 @@ def _fetch_tags_or_values_for_mri(
     metric_names, then the type (i.e. mapping to the entity) is also returned
     """
     org_id = projects[0].organization_id
-    use_case_id = to_use_case_id(use_case_key)
 
     if metric_mris is not None:
         private_derived_metrics = set(get_derived_metrics(exclude_private=False).keys()) - set(
@@ -327,7 +323,7 @@ def _fetch_tags_or_values_for_mri(
 
     try:
         metric_ids = _get_metrics_filter_ids(
-            projects=projects, metric_mris=metric_mris, use_case_id=use_case_key
+            projects=projects, metric_mris=metric_mris, use_case_id=use_case_id
         )
     except MetricDoesNotExistInIndexer:
         raise InvalidParams(
@@ -345,7 +341,7 @@ def _fetch_tags_or_values_for_mri(
     release_health_metric_types = ("counter", "set", "distribution")
     performance_metric_types = ("generic_counter", "generic_set", "generic_distribution")
 
-    if use_case_key == UseCaseKey.RELEASE_HEALTH:
+    if use_case_id == UseCaseID.SESSIONS:
         metric_types = release_health_metric_types
     else:
         metric_types = performance_metric_types
@@ -402,7 +398,7 @@ def _fetch_tags_or_values_for_mri(
             projects,
             metric_mris=metric_mris,
             supported_metric_ids_in_entities=supported_metric_ids_in_entities,
-            use_case_id=use_case_key,
+            use_case_id=use_case_id,
         )
 
         # Only return tags/tag values that occur in all metrics
@@ -441,7 +437,7 @@ def _fetch_tags_or_values_for_mri(
 
 
 def get_single_metric_info(
-    projects: Sequence[Project], metric_name: str, use_case_id: UseCaseKey
+    projects: Sequence[Project], metric_name: str, use_case_id: UseCaseID
 ) -> MetricMetaWithTagKeys:
     assert projects
 
@@ -477,7 +473,7 @@ def get_single_metric_info(
 
 
 def get_tags(
-    projects: Sequence[Project], metrics: Optional[Sequence[str]], use_case_id: UseCaseKey
+    projects: Sequence[Project], metrics: Optional[Sequence[str]], use_case_id: UseCaseID
 ) -> Sequence[Tag]:
     """Get all metric tags for the given projects and metric_names"""
     assert projects
@@ -489,7 +485,7 @@ def get_tags(
                 metric_mris=metrics,
                 column="tags.key",
                 referrer="snuba.metrics.meta.get_tags",
-                use_case_key=use_case_id,
+                use_case_id=use_case_id,
             )
         else:
             tags, _ = _fetch_tags_or_values_for_metrics(
@@ -508,7 +504,7 @@ def get_tag_values(
     projects: Sequence[Project],
     tag_name: str,
     metric_names: Optional[Sequence[str]],
-    use_case_id: UseCaseKey,
+    use_case_id: UseCaseID,
 ) -> Sequence[TagValue]:
     """Get all known values for a specific tag"""
     assert projects
@@ -567,7 +563,7 @@ class GroupLimitFilters:
 
 
 def _get_group_limit_filters(
-    metrics_query: MetricsQuery, results: List[Mapping[str, int]], use_case_id: UseCaseKey
+    metrics_query: MetricsQuery, results: List[Mapping[str, int]], use_case_id: UseCaseID
 ) -> Optional[GroupLimitFilters]:
     if not metrics_query.groupby or not results:
         return None
@@ -697,7 +693,7 @@ def _prune_extra_groups(results: dict, filters: GroupLimitFilters) -> None:
 def get_series(
     projects: Sequence[Project],
     metrics_query: MetricsQuery,
-    use_case_id: UseCaseKey,
+    use_case_id: UseCaseID,
     include_meta: bool = False,
     tenant_ids: dict[str, Any] | None = None,
 ) -> dict: