Update Snuba SDK to use Request class (#33980)

* feat: Use Request from new Snuba SDK

The new version of the Snuba SDK sends a Request object to Snuba instead of the
Query class. This allows separating out flags that are not specific to the Query
and makes the Query interface easier to use. It also adds a mandatory app_id to
the Request, but that can be left as "default" until it starts getting used.

The actual format of the JSON sent to Snuba has not changed, so this change
should have no impact on the actual queries being run. It is simply moving some
fields into a new class.

* Group hash and level files

* Subscriptions and CDC changes

* Release health changes

* Discover query builder and visibility team tests

* Metrics and metrics tests

* Outcomes, sessions and reports

requirements-base.txt

@@ -57,7 +57,7 @@ rfc3986-validator==0.1.1
 sentry-arroyo==0.0.16
 sentry-relay==0.8.10
 sentry-sdk>=1.4.3,<1.6.0
-snuba-sdk==0.1.5
+snuba-sdk==1.0.0
 simplejson==3.17.2
 statsd==3.3
 structlog==21.1.0

src/sentry/api/endpoints/group_hashes_split.py

@@ -136,7 +136,7 @@ def _split_group(group: Group, hash: str, hierarchical_hashes: Optional[Sequence
 
 def _get_full_hierarchical_hashes(group: Group, hash: str) -> Optional[Sequence[str]]:
     query = (
-        Query("events", Entity("events"))
+        Query(Entity("events"))
         .set_select(
             [
                 Column("hierarchical_hashes"),
@@ -156,8 +156,10 @@ def _get_full_hierarchical_hashes(group: Group, hash: str) -> Optional[Sequence[
             ]
         )
     )
-
-    data = snuba.raw_snql_query(query, referrer="group_split.get_full_hierarchical_hashes")["data"]
+    request = Request(dataset="events", app_id="grouping", query=query)
+    data = snuba.raw_snql_query(request, referrer="group_split.get_full_hierarchical_hashes")[
+        "data"
+    ]
     if not data:
         return None
 
@@ -311,7 +313,7 @@ def _render_trees(group: Group, user):
     # the road.
 
     query = (
-        Query("events", Entity("events"))
+        Query(Entity("events"))
         .set_select(
             [
                 Function("count", [], "event_count"),
@@ -381,8 +383,10 @@ def _render_trees(group: Group, user):
     )
 
     rv = []
-
-    for row in snuba.raw_snql_query(query, referrer="api.group_split.render_grouping_tree")["data"]:
+    request = Request(dataset="events", app_id="grouping", query=query)
+    for row in snuba.raw_snql_query(request, referrer="api.group_split.render_grouping_tree")[
+        "data"
+    ]:
         if len(row["hash_slice"]) == 0:
             hash = row["primary_hash"]
             parent_hash = child_hash = None

src/sentry/api/endpoints/grouping_level_new_issues.py

@@ -3,6 +3,7 @@ import datetime
 from django.core.cache import cache
 from rest_framework.request import Request
 from rest_framework.response import Response
+from snuba_sdk import Request as SnubaRequest
 from snuba_sdk.conditions import Condition, Op
 from snuba_sdk.orderby import Direction, OrderBy
 from snuba_sdk.query import Column, Entity, Function, Query
@@ -98,13 +99,13 @@ def _get_hash_for_parent_level(group: Group, id: int, levels_overview: LevelsOve
 
     if return_hash is None:
         query = (
-            Query("events", Entity("events"))
+            Query(Entity("events"))
             .set_select([Function("arrayElement", [Column("hierarchical_hashes"), id + 1], "hash")])
             .set_where(_get_group_filters(group))
             .set_limit(1)
         )
-
-        return_hash: str = get_path(snuba.raw_snql_query(query), "data", 0, "hash")  # type: ignore
+        request = SnubaRequest(dataset="events", app_id="grouping", query=query)
+        return_hash: str = get_path(snuba.raw_snql_query(request), "data", 0, "hash")  # type: ignore
         cache.set(cache_key, return_hash)
 
     assert return_hash
@@ -113,7 +114,7 @@ def _get_hash_for_parent_level(group: Group, id: int, levels_overview: LevelsOve
 
 def _query_snuba(group: Group, id: int, offset=None, limit=None):
     query = (
-        Query("events", Entity("events"))
+        Query(Entity("events"))
         .set_select(
             [
                 Function(
@@ -184,7 +185,8 @@ def _query_snuba(group: Group, id: int, offset=None, limit=None):
     if limit is not None:
         query = query.set_limit(limit)
 
-    return snuba.raw_snql_query(query, referrer="api.group_hashes_levels.get_level_new_issues")[
+    request = SnubaRequest(dataset="events", app_id="grouping", query=query)
+    return snuba.raw_snql_query(request, referrer="api.group_hashes_levels.get_level_new_issues")[
         "data"
     ]
 

src/sentry/api/endpoints/grouping_levels.py

@@ -1,5 +1,6 @@
 from dataclasses import dataclass
 
+from snuba_sdk import Request as SnubaRequest
 from snuba_sdk.query import Column, Entity, Function, Query
 
 from sentry import features
@@ -111,7 +112,7 @@ class LevelsOverview:
 
 def get_levels_overview(group):
     query = (
-        Query("events", Entity("events"))
+        Query(Entity("events"))
         .set_select(
             [
                 Column("primary_hash"),
@@ -124,8 +125,8 @@ def get_levels_overview(group):
         .set_where(_get_group_filters(group))
         .set_groupby([Column("primary_hash")])
     )
-
-    res = snuba.raw_snql_query(query, referrer="api.group_hashes_levels.get_levels_overview")
+    request = SnubaRequest(dataset="events", app_id="grouping", query=query)
+    res = snuba.raw_snql_query(request, referrer="api.group_hashes_levels.get_levels_overview")
 
     if not res["data"]:
         raise NoEvents()

src/sentry/release_health/base.py

@@ -29,6 +29,8 @@ ReleaseName = str
 EnvironmentName = str
 DateString = str
 
+SnubaAppID = "metrics.release_health"
+
 #: The functions supported by `run_sessions_query`
 SessionsQueryFunction = Literal[
     "sum(session)",

src/sentry/release_health/metrics.py

@@ -20,7 +20,7 @@ from typing import (
 )
 
 import pytz
-from snuba_sdk import Column, Condition, Direction, Entity, Function, Op, OrderBy, Query
+from snuba_sdk import Column, Condition, Direction, Entity, Function, Op, OrderBy, Query, Request
 from snuba_sdk.expressions import Expression, Granularity, Limit, Offset
 from snuba_sdk.query import SelectableExpression
 
@@ -49,6 +49,7 @@ from sentry.release_health.base import (
     SessionCounts,
     SessionsQueryConfig,
     SessionsQueryResult,
+    SnubaAppID,
     StatsPeriod,
     UserCounts,
 )
@@ -193,7 +194,6 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
         session_status = resolve_tag_key(org_id, "session.status")
 
         count_query = Query(
-            dataset=Dataset.Metrics.value,
             match=Entity(EntityKey.MetricsCounters.value),
             select=[Function("sum", [Column("value")], "value")],
             where=[
@@ -209,9 +209,9 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
             ],
             granularity=Granularity(rollup),
         )
-
+        request = Request(dataset=Dataset.Metrics.value, app_id=SnubaAppID, query=count_query)
         count_data = raw_snql_query(
-            count_query, referrer="release_health.metrics.get_crash_free_data", use_cache=False
+            request, referrer="release_health.metrics.get_crash_free_data", use_cache=False
         )["data"]
 
         for row in count_data:
@@ -303,7 +303,6 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
 
         def _count_sessions(total: bool, referrer: str) -> Dict[Any, int]:
             query = Query(
-                dataset=Dataset.Metrics.value,
                 match=Entity(EntityKey.MetricsCounters.value),
                 select=[Function("sum", [Column("value")], "value")],
                 where=_get_common_where(total)
@@ -315,10 +314,10 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
                 groupby=_get_common_groupby(total),
                 granularity=Granularity(LEGACY_SESSIONS_DEFAULT_ROLLUP),
             )
-
+            request = Request(dataset=Dataset.Metrics.value, app_id=SnubaAppID, query=query)
             return _convert_results(
                 raw_snql_query(
-                    query,
+                    request,
                     referrer=referrer,
                     use_cache=False,
                 )["data"],
@@ -327,7 +326,6 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
 
         def _count_users(total: bool, referrer: str) -> Dict[Any, int]:
             query = Query(
-                dataset=Dataset.Metrics.value,
                 match=Entity(EntityKey.MetricsSets.value),
                 select=[Function("uniq", [Column("value")], "value")],
                 where=_get_common_where(total)
@@ -337,10 +335,10 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
                 groupby=_get_common_groupby(total),
                 granularity=Granularity(LEGACY_SESSIONS_DEFAULT_ROLLUP),
             )
-
+            request = Request(dataset=Dataset.Metrics.value, app_id=SnubaAppID, query=query)
             return _convert_results(
                 raw_snql_query(
-                    query,
+                    request,
                     referrer=referrer,
                     use_cache=False,
                 )["data"],
@@ -484,7 +482,6 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
             # Take care of initial values for session.started by querying the
             # init counter. This should take care of most cases on its own.
             init_sessions_query = Query(
-                dataset=Dataset.Metrics.value,
                 match=Entity(EntityKey.MetricsCounters.value),
                 select=select,
                 where=where
@@ -500,9 +497,11 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
                 ],
                 granularity=Granularity(LEGACY_SESSIONS_DEFAULT_ROLLUP),
             )
-
+            request = Request(
+                dataset=Dataset.Metrics.value, app_id=SnubaAppID, query=init_sessions_query
+            )
             rows = raw_snql_query(
-                init_sessions_query,
+                request,
                 referrer="release_health.metrics.get_release_sessions_time_bounds.init_sessions",
                 use_cache=False,
             )["data"]
@@ -517,7 +516,6 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
             # session update that lowers session.started. We don't know if that
             # testcase matters particularly.
             terminal_sessions_query = Query(
-                dataset=Dataset.Metrics.value,
                 match=Entity(EntityKey.MetricsDistributions.value),
                 select=select,
                 where=where
@@ -530,9 +528,12 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
                 ],
                 granularity=Granularity(LEGACY_SESSIONS_DEFAULT_ROLLUP),
             )
+            request = Request(
+                dataset=Dataset.Metrics.value, app_id=SnubaAppID, query=terminal_sessions_query
+            )
             rows.extend(
                 raw_snql_query(
-                    terminal_sessions_query,
+                    request,
                     referrer="release_health.metrics.get_release_sessions_time_bounds.terminal_sessions",
                     use_cache=False,
                 )["data"]
@@ -629,16 +630,15 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
         group_by_clause = query_cols
 
         query = Query(
-            dataset=Dataset.Metrics.value,
             match=Entity(EntityKey.MetricsCounters.value),
             select=query_cols,
             where=where_clause,
             groupby=group_by_clause,
             granularity=Granularity(24 * 60 * 60),  # daily
         )
-
+        request = Request(dataset=Dataset.Metrics.value, app_id=SnubaAppID, query=query)
         result = raw_snql_query(
-            query, referrer="release_health.metrics.check_has_health_data", use_cache=False
+            request, referrer="release_health.metrics.check_has_health_data", use_cache=False
         )
 
         return {extract_row_info(row) for row in result["data"]}
@@ -660,7 +660,6 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
 
         releases_ids = resolve_many_weak(organization_id, release_versions)
         query = Query(
-            dataset=Dataset.Metrics.value,
             match=Entity(EntityKey.MetricsCounters.value),
             select=[Column(release_column_name)],
             where=[
@@ -673,9 +672,9 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
             ],
             groupby=[Column(release_column_name)],
         )
-
+        request = Request(dataset=Dataset.Metrics.value, app_id=SnubaAppID, query=query)
         result = raw_snql_query(
-            query,
+            request,
             referrer="release_health.metrics.check_releases_have_health_data",
             use_cache=False,
         )
@@ -703,32 +702,35 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
         ]
 
         for row in raw_snql_query(
-            Query(
+            Request(
                 dataset=Dataset.Metrics.value,
-                match=Entity(EntityKey.MetricsDistributions.value),
-                select=aggregates
-                + [
-                    Function(
-                        alias="percentiles",
-                        function="quantiles(0.5,0.9)",
-                        parameters=[Column("value")],
-                    )
-                ],
-                where=where
-                + [
-                    Condition(
-                        Column("metric_id"),
-                        Op.EQ,
-                        resolve(org_id, SessionMRI.RAW_DURATION.value),
-                    ),
-                    Condition(
-                        Column(resolve_tag_key(org_id, "session.status")),
-                        Op.EQ,
-                        resolve_weak(org_id, "exited"),
-                    ),
-                ],
-                groupby=aggregates,
-                granularity=Granularity(rollup),
+                app_id=SnubaAppID,
+                query=Query(
+                    match=Entity(EntityKey.MetricsDistributions.value),
+                    select=aggregates
+                    + [
+                        Function(
+                            alias="percentiles",
+                            function="quantiles(0.5,0.9)",
+                            parameters=[Column("value")],
+                        )
+                    ],
+                    where=where
+                    + [
+                        Condition(
+                            Column("metric_id"),
+                            Op.EQ,
+                            resolve(org_id, SessionMRI.RAW_DURATION.value),
+                        ),
+                        Condition(
+                            Column(resolve_tag_key(org_id, "session.status")),
+                            Op.EQ,
+                            resolve_weak(org_id, "exited"),
+                        ),
+                    ],
+                    groupby=aggregates,
+                    granularity=Granularity(rollup),
+                ),
             ),
             referrer="release_health.metrics.get_session_duration_data_for_overview",
         )["data"]:
@@ -760,16 +762,21 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
         ]
 
         for row in raw_snql_query(
-            Query(
+            Request(
                 dataset=Dataset.Metrics.value,
-                match=Entity(EntityKey.MetricsSets.value),
-                select=aggregates + [Function("uniq", [Column("value")], "value")],
-                where=where
-                + [
-                    Condition(Column("metric_id"), Op.EQ, resolve(org_id, SessionMRI.ERROR.value)),
-                ],
-                groupby=aggregates,
-                granularity=Granularity(rollup),
+                app_id=SnubaAppID,
+                query=Query(
+                    match=Entity(EntityKey.MetricsSets.value),
+                    select=aggregates + [Function("uniq", [Column("value")], "value")],
+                    where=where
+                    + [
+                        Condition(
+                            Column("metric_id"), Op.EQ, resolve(org_id, SessionMRI.ERROR.value)
+                        ),
+                    ],
+                    groupby=aggregates,
+                    granularity=Granularity(rollup),
+                ),
             ),
             referrer="release_health.metrics.get_errored_sessions_for_overview",
         )["data"]:
@@ -797,25 +804,28 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
         rv_sessions: Dict[Tuple[int, str, str], int] = {}
 
         for row in raw_snql_query(
-            Query(
+            Request(
                 dataset=Dataset.Metrics.value,
-                match=Entity(EntityKey.MetricsCounters.value),
-                select=aggregates + [Function("sum", [Column("value")], "value")],
-                where=where
-                + [
-                    Condition(
-                        Column("metric_id"), Op.EQ, resolve(org_id, SessionMRI.SESSION.value)
-                    ),
-                    Condition(
-                        Column(session_status_column_name),
-                        Op.IN,
-                        resolve_many_weak(
-                            org_id, ["abnormal", "crashed", "init", "errored_preaggr"]
+                app_id=SnubaAppID,
+                query=Query(
+                    match=Entity(EntityKey.MetricsCounters.value),
+                    select=aggregates + [Function("sum", [Column("value")], "value")],
+                    where=where
+                    + [
+                        Condition(
+                            Column("metric_id"), Op.EQ, resolve(org_id, SessionMRI.SESSION.value)
                         ),
-                    ),
-                ],
-                groupby=aggregates,
-                granularity=Granularity(rollup),
+                        Condition(
+                            Column(session_status_column_name),
+                            Op.IN,
+                            resolve_many_weak(
+                                org_id, ["abnormal", "crashed", "init", "errored_preaggr"]
+                            ),
+                        ),
+                    ],
+                    groupby=aggregates,
+                    granularity=Granularity(rollup),
+                ),
             ),
             referrer="release_health.metrics.get_abnormal_and_crashed_sessions_for_overview",
         )["data"]:
@@ -856,13 +866,16 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
         ]
 
         for row in raw_snql_query(
-            Query(
+            Request(
                 dataset=Dataset.Metrics.value,
-                match=Entity(EntityKey.MetricsSets.value),
-                select=select,
-                where=where,
-                groupby=aggregates,
-                granularity=Granularity(rollup),
+                app_id=SnubaAppID,
+                query=Query(
+                    match=Entity(EntityKey.MetricsSets.value),
+                    select=select,
+                    where=where,
+                    groupby=aggregates,
+                    granularity=Granularity(rollup),
+                ),
             ),
             referrer="release_health.metrics.get_users_and_crashed_users_for_overview",
         )["data"]:
@@ -914,23 +927,26 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
         )
 
         for row in raw_snql_query(
-            Query(
+            Request(
                 dataset=Dataset.Metrics.value,
-                match=Entity(entity),
-                select=aggregates + [value_column],
-                where=where
-                + [
-                    Condition(Column("metric_id"), Op.EQ, metric_name),
-                    Condition(Column("timestamp"), Op.GTE, stats_start),
-                    Condition(Column("timestamp"), Op.LT, now),
-                    Condition(
-                        Column(session_status_column_name),
-                        Op.EQ,
-                        session_init_tag_value,
-                    ),
-                ],
-                granularity=Granularity(stats_rollup),
-                groupby=aggregates,
+                app_id=SnubaAppID,
+                query=Query(
+                    match=Entity(entity),
+                    select=aggregates + [value_column],
+                    where=where
+                    + [
+                        Condition(Column("metric_id"), Op.EQ, metric_name),
+                        Condition(Column("timestamp"), Op.GTE, stats_start),
+                        Condition(Column("timestamp"), Op.LT, now),
+                        Condition(
+                            Column(session_status_column_name),
+                            Op.EQ,
+                            session_init_tag_value,
+                        ),
+                    ],
+                    granularity=Granularity(stats_rollup),
+                    groupby=aggregates,
+                ),
             ),
             referrer="release_health.metrics.get_health_stats_for_overview",
         )["data"]:
@@ -1147,13 +1163,16 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
                     columns = [Function(aggregation_function, [Column("value")], "value")]
 
                     data = raw_snql_query(
-                        Query(
+                        Request(
                             dataset=Dataset.Metrics.value,
-                            match=Entity(entity_key.value),
-                            select=columns,
-                            where=where,
-                            groupby=[Column(status_key)],
-                            granularity=Granularity(LEGACY_SESSIONS_DEFAULT_ROLLUP),
+                            app_id=SnubaAppID,
+                            query=Query(
+                                match=Entity(entity_key.value),
+                                select=columns,
+                                where=where,
+                                groupby=[Column(status_key)],
+                                granularity=Granularity(LEGACY_SESSIONS_DEFAULT_ROLLUP),
+                            ),
                         ),
                         referrer=referrer,
                     )["data"]
@@ -1261,15 +1280,15 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
         ]
 
         query = Query(
-            dataset=Dataset.Metrics.value,
             match=Entity(EntityKey.MetricsCounters.value),
             select=query_cols,
             where=where_clause,
             groupby=query_cols,
             granularity=Granularity(LEGACY_SESSIONS_DEFAULT_ROLLUP),
         )
+        request = Request(dataset=Dataset.Metrics.value, app_id=SnubaAppID, query=query)
         result = raw_snql_query(
-            query,
+            request,
             referrer="release_health.metrics.get_changed_project_release_model_adoptions",
             use_cache=False,
         )
@@ -1317,15 +1336,15 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
         ]
 
         query = Query(
-            dataset=Dataset.Metrics.value,
             match=Entity(EntityKey.MetricsCounters.value),
             select=query_cols,
             where=where_clause,
             groupby=group_by,
             granularity=Granularity(LEGACY_SESSIONS_DEFAULT_ROLLUP),
         )
+        request = Request(dataset=Dataset.Metrics.value, app_id=SnubaAppID, query=query)
         rows = raw_snql_query(
-            query,
+            request,
             referrer="release_health.metrics.get_oldest_health_data_for_releases",
             use_cache=False,
         )["data"]
@@ -1395,17 +1414,16 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
         ]
 
         query = Query(
-            dataset=Dataset.Metrics.value,
             match=match,
             select=query_columns,
             where=where,
             having=having,
             granularity=Granularity(granularity),
         )
-
-        rows = raw_snql_query(query, referrer="release_health.metrics.get_project_releases_count")[
-            "data"
-        ]
+        request = Request(dataset=Dataset.Metrics.value, app_id=SnubaAppID, query=query)
+        rows = raw_snql_query(
+            request, referrer="release_health.metrics.get_project_releases_count"
+        )["data"]
 
         ret_val: int = rows[0]["count"] if rows else 0
         return ret_val
@@ -1430,23 +1448,26 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
         session_status_healthy = indexer.resolve(org_id, "exited")
         if session_status_healthy is not None:
             duration_series_data = raw_snql_query(
-                Query(
+                Request(
                     dataset=Dataset.Metrics.value,
-                    where=where
-                    + [
-                        Condition(
-                            Column("metric_id"),
-                            Op.EQ,
-                            resolve(org_id, SessionMRI.RAW_DURATION.value),
-                        ),
-                        Condition(Column(session_status_key), Op.EQ, session_status_healthy),
-                    ],
-                    granularity=Granularity(rollup),
-                    match=Entity(EntityKey.MetricsDistributions.value),
-                    select=[
-                        Function("quantiles(0.5, 0.90)", [Column("value")], alias="quantiles"),
-                    ],
-                    groupby=[Column("bucketed_time")],
+                    app_id=SnubaAppID,
+                    query=Query(
+                        where=where
+                        + [
+                            Condition(
+                                Column("metric_id"),
+                                Op.EQ,
+                                resolve(org_id, SessionMRI.RAW_DURATION.value),
+                            ),
+                            Condition(Column(session_status_key), Op.EQ, session_status_healthy),
+                        ],
+                        granularity=Granularity(rollup),
+                        match=Entity(EntityKey.MetricsDistributions.value),
+                        select=[
+                            Function("quantiles(0.5, 0.90)", [Column("value")], alias="quantiles"),
+                        ],
+                        groupby=[Column("bucketed_time")],
+                    ),
                 ),
                 referrer="release_health.metrics.get_project_release_stats_durations",
             )["data"]
@@ -1476,18 +1497,23 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
         rollup: int,
     ) -> Tuple[Mapping[datetime, SessionCounts], SessionCounts]:
         session_series_data = raw_snql_query(
-            Query(
+            Request(
                 dataset=Dataset.Metrics.value,
-                where=where
-                + [
-                    Condition(Column("metric_id"), Op.EQ, resolve(org_id, SessionMRI.SESSION.value))
-                ],
-                granularity=Granularity(rollup),
-                match=Entity(EntityKey.MetricsCounters.value),
-                select=[
-                    Function("sum", [Column("value")], alias="value"),
-                ],
-                groupby=[Column("bucketed_time"), Column(session_status_key)],
+                app_id=SnubaAppID,
+                query=Query(
+                    where=where
+                    + [
+                        Condition(
+                            Column("metric_id"), Op.EQ, resolve(org_id, SessionMRI.SESSION.value)
+                        )
+                    ],
+                    granularity=Granularity(rollup),
+                    match=Entity(EntityKey.MetricsCounters.value),
+                    select=[
+                        Function("sum", [Column("value")], alias="value"),
+                    ],
+                    groupby=[Column("bucketed_time"), Column(session_status_key)],
+                ),
             ),
             referrer="release_health.metrics.get_project_release_stats_sessions_series",
         )["data"]
@@ -1518,16 +1544,23 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
                 logger.warning("Unexpected session.status '%s'", status)
 
         session_error_series_data = raw_snql_query(
-            Query(
+            Request(
                 dataset=Dataset.Metrics.value,
-                where=where
-                + [Condition(Column("metric_id"), Op.EQ, resolve(org_id, SessionMRI.ERROR.value))],
-                granularity=Granularity(rollup),
-                match=Entity(EntityKey.MetricsSets.value),
-                select=[
-                    Function("uniq", [Column("value")], alias="value"),
-                ],
-                groupby=[Column("bucketed_time")],
+                app_id=SnubaAppID,
+                query=Query(
+                    where=where
+                    + [
+                        Condition(
+                            Column("metric_id"), Op.EQ, resolve(org_id, SessionMRI.ERROR.value)
+                        )
+                    ],
+                    granularity=Granularity(rollup),
+                    match=Entity(EntityKey.MetricsSets.value),
+                    select=[
+                        Function("uniq", [Column("value")], alias="value"),
+                    ],
+                    groupby=[Column("bucketed_time")],
+                ),
             ),
             referrer="release_health.metrics.get_project_release_stats_sessions_error_series",
         )["data"]
@@ -1571,31 +1604,45 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
     ) -> Tuple[Mapping[datetime, UserCounts], UserCounts]:
 
         user_series_data = raw_snql_query(
-            Query(
+            Request(
                 dataset=Dataset.Metrics.value,
-                where=where
-                + [Condition(Column("metric_id"), Op.EQ, resolve(org_id, SessionMRI.USER.value))],
-                granularity=Granularity(rollup),
-                match=Entity(EntityKey.MetricsSets.value),
-                select=[
-                    Function("uniq", [Column("value")], alias="value"),
-                ],
-                groupby=[Column("bucketed_time"), Column(session_status_key)],
+                app_id=SnubaAppID,
+                query=Query(
+                    where=where
+                    + [
+                        Condition(
+                            Column("metric_id"), Op.EQ, resolve(org_id, SessionMRI.USER.value)
+                        )
+                    ],
+                    granularity=Granularity(rollup),
+                    match=Entity(EntityKey.MetricsSets.value),
+                    select=[
+                        Function("uniq", [Column("value")], alias="value"),
+                    ],
+                    groupby=[Column("bucketed_time"), Column(session_status_key)],
+                ),
             ),
             referrer="release_health.metrics.get_project_release_stats_user_series",
         )["data"]
 
         user_totals_data = raw_snql_query(
-            Query(
+            Request(
                 dataset=Dataset.Metrics.value,
-                where=where
-                + [Condition(Column("metric_id"), Op.EQ, resolve(org_id, SessionMRI.USER.value))],
-                granularity=Granularity(LEGACY_SESSIONS_DEFAULT_ROLLUP),
-                match=Entity(EntityKey.MetricsSets.value),
-                select=[
-                    Function("uniq", [Column("value")], alias="value"),
-                ],
-                groupby=[Column(session_status_key)],
+                app_id=SnubaAppID,
+                query=Query(
+                    where=where
+                    + [
+                        Condition(
+                            Column("metric_id"), Op.EQ, resolve(org_id, SessionMRI.USER.value)
+                        )
+                    ],
+                    granularity=Granularity(LEGACY_SESSIONS_DEFAULT_ROLLUP),
+                    match=Entity(EntityKey.MetricsSets.value),
+                    select=[
+                        Function("uniq", [Column("value")], alias="value"),
+                    ],
+                    groupby=[Column(session_status_key)],
+                ),
             ),
             referrer="release_health.metrics.get_project_release_stats_user_totals",
         )["data"]
@@ -1793,16 +1840,15 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
             where_clause.append(Condition(Column(env_id), Op.EQ, snuba_env_id))
 
         query = Query(
-            dataset=Dataset.Metrics.value,
             match=Entity(EntityKey.MetricsCounters.value),
             select=columns,
             where=where_clause,
             granularity=Granularity(rollup),
         )
-
-        rows = raw_snql_query(query, referrer="release_health.metrics.get_project_sessions_count")[
-            "data"
-        ]
+        request = Request(dataset=Dataset.Metrics.value, app_id=SnubaAppID, query=query)
+        rows = raw_snql_query(
+            request, referrer="release_health.metrics.get_project_sessions_count"
+        )["data"]
 
         ret_val: int = int(rows[0]["value"]) if rows else 0
         return ret_val
@@ -1851,7 +1897,6 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
         group_by = [Column("project_id")]
 
         query = Query(
-            dataset=Dataset.Metrics.value,
             match=Entity(EntityKey.MetricsCounters.value),
             select=columns,
             where=where_clause,
@@ -1860,9 +1905,9 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
                 rollup if rollup is not None else LEGACY_SESSIONS_DEFAULT_ROLLUP
             ),
         )
-
+        request = Request(dataset=Dataset.Metrics.value, app_id=SnubaAppID, query=query)
         rows = raw_snql_query(
-            query, referrer="release_health.metrics.get_num_sessions_per_project"
+            request, referrer="release_health.metrics.get_num_sessions_per_project"
         )["data"]
 
         return [(row["project_id"], int(row["value"])) for row in rows]
@@ -2020,7 +2065,6 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
         order_by_clause.append(OrderBy(Column("project_id"), Direction.DESC))
 
         query = Query(
-            dataset=Dataset.Metrics.value,
             match=entity,
             select=query_cols,
             where=where_clause,
@@ -2031,9 +2075,9 @@ class MetricsReleaseHealthBackend(ReleaseHealthBackend):
             limit=Limit(limit) if limit is not None else None,
             granularity=Granularity(LEGACY_SESSIONS_DEFAULT_ROLLUP),
         )
-
+        request = Request(dataset=Dataset.Metrics.value, app_id=SnubaAppID, query=query)
         rows = raw_snql_query(
-            query,
+            request,
             referrer="release_health.metrics.get_project_releases_by_stability",
             use_cache=False,
         )

src/sentry/release_health/metrics_sessions_v2.py

@@ -515,7 +515,7 @@ def _get_filter_conditions(conditions: Any) -> ConditionGroup:
     dummy_entity = EntityKey.MetricsSets.value
     return json_to_snql(
         {"selected_columns": ["value"], "conditions": conditions}, entity=dummy_entity
-    ).where
+    ).query.where
 
 
 def _extract_status_filter_from_conditions(

src/sentry/release_health/release_monitor/metrics.py

@@ -14,6 +14,7 @@ from snuba_sdk import (
     Op,
     OrderBy,
     Query,
+    Request,
 )
 
 from sentry.release_health.release_monitor.base import BaseReleaseMonitorBackend, Totals
@@ -39,7 +40,6 @@ class MetricReleaseMonitorBackend(BaseReleaseMonitorBackend):
             while (time.time() - start_time) < self.MAX_SECONDS:
                 query = (
                     Query(
-                        dataset=Dataset.Metrics.value,
                         match=Entity(EntityKey.OrgMetricsCounters.value),
                         select=[
                             Column("org_id"),
@@ -66,8 +66,11 @@ class MetricReleaseMonitorBackend(BaseReleaseMonitorBackend):
                     .set_limit(self.CHUNK_SIZE + 1)
                     .set_offset(offset)
                 )
+                request = Request(
+                    dataset=Dataset.Metrics.value, app_id="release_health", query=query
+                )
                 data = raw_snql_query(
-                    query, referrer="release_monitor.fetch_projects_with_recent_sessions"
+                    request, referrer="release_monitor.fetch_projects_with_recent_sessions"
                 )["data"]
                 count = len(data)
                 more_results = count > self.CHUNK_SIZE
@@ -104,7 +107,6 @@ class MetricReleaseMonitorBackend(BaseReleaseMonitorBackend):
                 env_col = Column(env_key)
                 query = (
                     Query(
-                        dataset=Dataset.Metrics.value,
                         match=Entity(EntityKey.MetricsCounters.value),
                         select=[
                             Function("sum", [Column("value")], "sessions"),
@@ -142,10 +144,12 @@ class MetricReleaseMonitorBackend(BaseReleaseMonitorBackend):
                     .set_limit(self.CHUNK_SIZE + 1)
                     .set_offset(offset)
                 )
-
+                request = Request(
+                    dataset=Dataset.Metrics.value, app_id="release_health", query=query
+                )
                 with metrics.timer("release_monitor.fetch_project_release_health_totals.query"):
                     data = raw_snql_query(
-                        query, referrer="release_monitor.fetch_project_release_health_totals"
+                        request, referrer="release_monitor.fetch_project_release_health_totals"
                     )["data"]
                     count = len(data)
                     more_results = count > self.CHUNK_SIZE

src/sentry/release_health/release_monitor/sessions.py

@@ -4,7 +4,7 @@ from collections import defaultdict
 from datetime import datetime, timedelta
 from typing import Mapping, Sequence
 
-from snuba_sdk import Column, Condition, Direction, Entity, Granularity, Op, OrderBy, Query
+from snuba_sdk import Column, Condition, Direction, Entity, Granularity, Op, OrderBy, Query, Request
 
 from sentry.release_health.release_monitor.base import BaseReleaseMonitorBackend, Totals
 from sentry.utils import metrics
@@ -24,7 +24,6 @@ class SessionReleaseMonitorBackend(BaseReleaseMonitorBackend):
             while (time.time() - start_time) < self.MAX_SECONDS:
                 query = (
                     Query(
-                        dataset="sessions",
                         match=Entity("org_sessions"),
                         select=[
                             Column("org_id"),
@@ -46,7 +45,8 @@ class SessionReleaseMonitorBackend(BaseReleaseMonitorBackend):
                     .set_limit(self.CHUNK_SIZE + 1)
                     .set_offset(offset)
                 )
-                data = raw_snql_query(query, referrer="tasks.monitor_release_adoption")["data"]
+                request = Request(dataset="sessions", app_id="sessions_release_health", query=query)
+                data = raw_snql_query(request, referrer="tasks.monitor_release_adoption")["data"]
                 count = len(data)
                 more_results = count > self.CHUNK_SIZE
                 offset += self.CHUNK_SIZE
@@ -83,7 +83,6 @@ class SessionReleaseMonitorBackend(BaseReleaseMonitorBackend):
                 ):
                     query = (
                         Query(
-                            dataset="sessions",
                             match=Entity("sessions"),
                             select=[
                                 Column("sessions"),
@@ -113,9 +112,11 @@ class SessionReleaseMonitorBackend(BaseReleaseMonitorBackend):
                         .set_limit(self.CHUNK_SIZE + 1)
                         .set_offset(offset)
                     )
-
+                    request = Request(
+                        dataset="sessions", app_id="sessions_release_health", query=query
+                    )
                     data = raw_snql_query(
-                        query, referrer="tasks.process_projects_with_sessions.session_count"
+                        request, referrer="tasks.process_projects_with_sessions.session_count"
                     )["data"]
                     count = len(data)
                     more_results = count > self.CHUNK_SIZE

src/sentry/search/events/builder.py

@@ -6,12 +6,12 @@ import sentry_sdk
 from django.utils import timezone
 from django.utils.functional import cached_property
 from parsimonious.exceptions import ParseError
+from snuba_sdk import Flags, Request
 from snuba_sdk.aliased_expression import AliasedExpression
 from snuba_sdk.column import Column
 from snuba_sdk.conditions import And, BooleanCondition, Condition, Op, Or
 from snuba_sdk.entity import Entity
 from snuba_sdk.expressions import Granularity, Limit, Offset
-from snuba_sdk.flags import Turbo
 from snuba_sdk.function import CurriedFunction, Function
 from snuba_sdk.orderby import Direction, LimitBy, OrderBy
 from snuba_sdk.query import Query
@@ -129,7 +129,7 @@ class QueryBuilder:
         self.auto_aggregations = auto_aggregations
         self.limit = self.resolve_limit(limit)
         self.offset = None if offset is None else Offset(offset)
-        self.turbo = Turbo(turbo)
+        self.turbo = turbo
         self.sample_rate = sample_rate
 
         (
@@ -1124,22 +1124,25 @@ class QueryBuilder:
         """
         return self.function_alias_map[function.alias].field  # type: ignore
 
-    def get_snql_query(self) -> Query:
+    def get_snql_query(self) -> Request:
         self.validate_having_clause()
 
-        return Query(
+        return Request(
             dataset=self.dataset.value,
-            match=Entity(self.dataset.value, sample=self.sample_rate),
-            select=self.columns,
-            array_join=self.array_join,
-            where=self.where,
-            having=self.having,
-            groupby=self.groupby,
-            orderby=self.orderby,
-            limit=self.limit,
-            offset=self.offset,
-            limitby=self.limitby,
-            turbo=self.turbo,
+            app_id="default",
+            query=Query(
+                match=Entity(self.dataset.value, sample=self.sample_rate),
+                select=self.columns,
+                array_join=self.array_join,
+                where=self.where,
+                having=self.having,
+                groupby=self.groupby,
+                orderby=self.orderby,
+                limit=self.limit,
+                offset=self.offset,
+                limitby=self.limitby,
+            ),
+            flags=Flags(turbo=self.turbo),
         )
 
     def run_query(self, referrer: str, use_cache: bool = False) -> Any:
@@ -1248,17 +1251,20 @@ class TimeseriesQueryBuilder(UnresolvedQuery):
         # Casting for now since QueryFields/QueryFilter are only partially typed
         return self.aggregates
 
-    def get_snql_query(self) -> Query:
-        return Query(
+    def get_snql_query(self) -> Request:
+        return Request(
             dataset=self.dataset.value,
-            match=Entity(self.dataset.value),
-            select=self.select,
-            where=self.where,
-            having=self.having,
-            groupby=self.groupby,
-            orderby=[OrderBy(self.time_column, Direction.ASC)],
-            granularity=self.granularity,
-            limit=self.limit,
+            app_id="default",
+            query=Query(
+                match=Entity(self.dataset.value),
+                select=self.select,
+                where=self.where,
+                having=self.having,
+                groupby=self.groupby,
+                orderby=[OrderBy(self.time_column, Direction.ASC)],
+                granularity=self.granularity,
+                limit=self.limit,
+            ),
         )
 
     def run_query(self, referrer: str, use_cache: bool = False) -> Any:
@@ -1883,7 +1889,6 @@ class MetricsQueryBuilder(QueryBuilder):
                     referrer_suffix = "primary"
 
                 query = Query(
-                    dataset=self.dataset.value,
                     match=query_details.entity,
                     select=select,
                     array_join=self.array_join,
@@ -1894,10 +1899,15 @@ class MetricsQueryBuilder(QueryBuilder):
                     limit=self.limit,
                     offset=offset,
                     limitby=self.limitby,
-                    turbo=self.turbo,
+                )
+                request = Request(
+                    dataset=self.dataset.value,
+                    app_id="default",
+                    query=query,
+                    flags=Flags(turbo=self.turbo),
                 )
                 current_result = raw_snql_query(
-                    query,
+                    request,
                     f"{referrer}.{referrer_suffix}",
                     use_cache,
                 )
@@ -2011,7 +2021,7 @@ class TimeseriesMetricQueryBuilder(MetricsQueryBuilder):
             self.time_alias,
         )
 
-    def get_snql_query(self) -> List[Query]:
+    def get_snql_query(self) -> List[Request]:
         """Because of the way metrics are structured a single request can result in >1 snql query
 
         This is because different functions will use different entities
@@ -2019,20 +2029,23 @@ class TimeseriesMetricQueryBuilder(MetricsQueryBuilder):
         # No need for primary from the query framework since there's no orderby to worry about
         _, query_framework = self._create_query_framework()
 
-        queries: List[Query] = []
+        queries: List[Request] = []
         for query_details in query_framework.values():
             if len(query_details.functions) > 0:
                 queries.append(
-                    Query(
+                    Request(
                         dataset=self.dataset.value,
-                        match=query_details.entity,
-                        select=query_details.functions,
-                        where=self.where,
-                        having=self.having,
-                        groupby=self.groupby,
-                        orderby=[OrderBy(self.time_column, Direction.ASC)],
-                        granularity=self.granularity,
-                        limit=self.limit,
+                        app_id="default",
+                        query=Query(
+                            match=query_details.entity,
+                            select=query_details.functions,
+                            where=self.where,
+                            having=self.having,
+                            groupby=self.groupby,
+                            orderby=[OrderBy(self.time_column, Direction.ASC)],
+                            granularity=self.granularity,
+                            limit=self.limit,
+                        ),
                     )
                 )