ref: delete some dead methods from tagstore (#83010)

no callers in sentry or getsentry

<!-- Describe your PR here. -->

src/sentry/tagstore/base.py

@@ -28,39 +28,30 @@ class TagStorage(Service):
         [
             "get_tag_key",
             "get_tag_keys",
-            "get_tag_value",
             "get_tag_values",
             "get_group_tag_key",
             "get_group_tag_keys",
-            "get_group_tag_value",
-            "get_group_tag_values",
             "get_group_list_tag_value",
             "get_generic_group_list_tag_value",
             "get_tag_keys_for_projects",
             "get_groups_user_counts",
             "get_generic_groups_user_counts",
-            "get_group_event_filter",
             "get_group_tag_value_count",
             "get_top_group_tag_values",
             "get_first_release",
             "get_last_release",
             "get_release_tags",
-            "get_group_tag_values_for_users",
             "get_group_tag_keys_and_top_values",
             "get_tag_value_paginator",
             "get_group_tag_value_paginator",
             "get_tag_value_paginator_for_projects",
             "get_group_tag_value_iter",
-            "get_group_tag_value_qs",
-            "get_group_seen_values_for_environments",
         ]
     )
 
     __all__ = (
         frozenset(
             [
-                "is_valid_key",
-                "is_valid_value",
                 "is_reserved_key",
                 "prefix_reserved_key",
                 "get_standardized_key",
@@ -71,17 +62,6 @@ class TagStorage(Service):
         | __read_methods__
     )
 
-    def setup_merge(self, grouptagkey_model, grouptagvalue_model):
-        from sentry.tasks import merge
-
-        merge.EXTRA_MERGE_MODELS += [grouptagvalue_model, grouptagkey_model]
-
-    def is_valid_key(self, key):
-        return bool(TAG_KEY_RE.match(key))
-
-    def is_valid_value(self, value):
-        return "\n" not in value
-
     def is_reserved_key(self, key):
         return key in INTERNAL_TAG_KEYS
 
@@ -150,12 +130,6 @@ class TagStorage(Service):
         """
         raise NotImplementedError
 
-    def get_tag_value(self, project_id, environment_id, key, value, tenant_ids=None):
-        """
-        >>> get_tag_value(1, 2, "key1", "value1")
-        """
-        raise NotImplementedError
-
     def get_tag_values(self, project_id, environment_id, key, tenant_ids=None):
         """
         >>> get_tag_values(1, 2, "key1")
@@ -174,20 +148,6 @@ class TagStorage(Service):
         """
         raise NotImplementedError
 
-    def get_group_tag_value(
-        self, project_id, group_id, environment_id, key, value, tenant_ids=None
-    ):
-        """
-        >>> get_group_tag_value(1, 2, 3, "key1", "value1")
-        """
-        raise NotImplementedError
-
-    def get_group_tag_values(self, group, environment_id, key, tenant_ids=None):
-        """
-        >>> get_group_tag_values(group, 3, "key1")
-        """
-        raise NotImplementedError
-
     def get_group_list_tag_value(
         self, project_ids, group_id_list, environment_ids, key, value, tenant_ids=None
     ):
@@ -201,14 +161,6 @@ class TagStorage(Service):
     ):
         raise NotImplementedError
 
-    def get_group_event_filter(
-        self, project_id, group_id, environment_ids, tags, start, end, tenant_ids=None
-    ):
-        """
-        >>> get_group_event_filter(1, 2, 3, {'key1': 'value1', 'key2': 'value2'})
-        """
-        raise NotImplementedError
-
     def get_tag_value_paginator(
         self,
         project_id,
@@ -271,12 +223,6 @@ class TagStorage(Service):
         """
         raise NotImplementedError
 
-    def get_group_tag_value_qs(self, project_id, group_id, environment_id, key, value=None):
-        """
-        >>> get_group_tag_value_qs(1, 2, 3, 'environment')
-        """
-        raise NotImplementedError
-
     def get_groups_user_counts(
         self,
         project_ids,
@@ -330,12 +276,6 @@ class TagStorage(Service):
         """
         raise NotImplementedError
 
-    def get_group_tag_values_for_users(self, event_users, limit=100, tenant_ids=None):
-        """
-        >>> get_group_tag_values_for_users([EventUser(1), EventUser(2)])
-        """
-        raise NotImplementedError
-
     def get_group_tag_keys_and_top_values(
         self,
         group,
@@ -362,8 +302,3 @@ class TagStorage(Service):
                 tk.count = self.get_group_tag_value_count(group, environment_id, tk.key)
 
         return tag_keys
-
-    def get_group_seen_values_for_environments(
-        self, project_ids, group_id_list, environment_ids, start=None, end=None, tenant_ids=None
-    ):
-        raise NotImplementedError

src/sentry/tagstore/exceptions.py

@@ -2,13 +2,5 @@ class TagKeyNotFound(Exception):
     pass
 
 
-class TagValueNotFound(Exception):
-    pass
-
-
 class GroupTagKeyNotFound(Exception):
     pass
-
-
-class GroupTagValueNotFound(Exception):
-    pass

src/sentry/tagstore/snuba/backend.py

@@ -12,7 +12,7 @@ from django.core.cache import cache
 from sentry_relay.consts import SPAN_STATUS_CODE_TO_NAME
 from snuba_sdk import Column, Condition, Direction, Entity, Function, Op, OrderBy, Query, Request
 
-from sentry import analytics, features, options
+from sentry import features, options
 from sentry.api.utils import default_start_end_dates
 from sentry.issues.grouptype import GroupCategory
 from sentry.models.group import Group
@@ -37,12 +37,7 @@ from sentry.search.events.filter import _flip_field_sort
 from sentry.snuba.dataset import Dataset
 from sentry.snuba.referrer import Referrer
 from sentry.tagstore.base import TOP_VALUES_DEFAULT_LIMIT, TagKeyStatus, TagStorage
-from sentry.tagstore.exceptions import (
-    GroupTagKeyNotFound,
-    GroupTagValueNotFound,
-    TagKeyNotFound,
-    TagValueNotFound,
-)
+from sentry.tagstore.exceptions import GroupTagKeyNotFound, TagKeyNotFound
 from sentry.tagstore.types import GroupTagKey, GroupTagValue, TagKey, TagValue
 from sentry.utils import metrics, snuba
 from sentry.utils.hashlib import md5_text
@@ -114,32 +109,6 @@ def _translate_filter_keys(project_ids, group_ids, environment_ids) -> dict[str,
 
 
 class SnubaTagStorage(TagStorage):
-    def __get_tag_key(self, project_id, group_id, environment_id, key):
-        tag = f"tags[{key}]"
-        filters = {"project_id": get_project_list(project_id)}
-        if environment_id:
-            filters["environment"] = [environment_id]
-        if group_id is not None:
-            filters["group_id"] = [group_id]
-        conditions = [[tag, "!=", ""], DEFAULT_TYPE_CONDITION]
-        aggregations = [["uniq", tag, "values_seen"], ["count()", "", "count"]]
-
-        result = snuba.query(
-            dataset=Dataset.Events,
-            conditions=conditions,
-            filter_keys=filters,
-            aggregations=aggregations,
-            referrer="tagstore.__get_tag_key",
-        )
-        if result is None or result["count"] == 0:
-            raise TagKeyNotFound if group_id is None else GroupTagKeyNotFound
-        else:
-            data = {"key": key, "values_seen": result["values_seen"], "count": result["count"]}
-            if group_id is None:
-                return TagKey(**data)
-            else:
-                return GroupTagKey(group_id=group_id, **data)
-
     def __get_tag_key_and_top_values(
         self,
         project_id,
@@ -373,37 +342,6 @@ class SnubaTagStorage(TagStorage):
             results.add(ctor(**params))
         return results
 
-    def __get_tag_value(self, project_id, group_id, environment_id, key, value, tenant_ids=None):
-        tag = f"tags[{key}]"
-        filters = {"project_id": get_project_list(project_id)}
-        if environment_id:
-            filters["environment"] = [environment_id]
-        if group_id is not None:
-            filters["group_id"] = [group_id]
-        conditions = [[tag, "=", value]]
-        aggregations = [
-            ["count()", "", "times_seen"],
-            ["min", SEEN_COLUMN, "first_seen"],
-            ["max", SEEN_COLUMN, "last_seen"],
-        ]
-
-        data = snuba.query(
-            dataset=Dataset.Events,
-            conditions=conditions,
-            filter_keys=filters,
-            aggregations=aggregations,
-            referrer="tagstore.__get_tag_value",
-            tenant_ids=tenant_ids,
-        )
-        if not data["times_seen"] > 0:
-            raise TagValueNotFound if group_id is None else GroupTagValueNotFound
-        else:
-            data.update({"key": key, "value": value})
-            if group_id is None:
-                return TagValue(**fix_tag_value_data(data))
-            else:
-                return GroupTagValue(group_id=group_id, **fix_tag_value_data(data))
-
     def get_tag_key(
         self,
         project_id,
@@ -485,11 +423,6 @@ class SnubaTagStorage(TagStorage):
             **optimize_kwargs,
         )
 
-    def get_tag_value(self, project_id, environment_id, key, value, tenant_ids=None):
-        return self.__get_tag_value(
-            project_id, None, environment_id, key, value, tenant_ids=tenant_ids
-        )
-
     def get_tag_values(self, project_id, environment_id, key, tenant_ids=None):
         key = self.__get_tag_key_and_top_values(
             project_id,
@@ -528,27 +461,6 @@ class SnubaTagStorage(TagStorage):
             **kwargs,
         )
 
-    def get_group_tag_value(
-        self, project_id, group_id, environment_id, key, value, tenant_ids=None
-    ):
-        return self.__get_tag_value(
-            project_id, group_id, environment_id, key, value, tenant_ids=tenant_ids
-        )
-
-    def get_group_tag_values(self, group, environment_id, key, tenant_ids=None):
-        # NB this uses a 'top' values function, but the limit is None so it should
-        # return all values for this key.
-        key = self.__get_tag_key_and_top_values(
-            group.project_id,
-            group,
-            environment_id,
-            key,
-            limit=None,
-            raise_on_empty=False,
-            tenant_ids=tenant_ids,
-        )
-        return set(key.top_values)
-
     def __get_group_list_tag_value(
         self,
         project_ids,
@@ -658,34 +570,6 @@ class SnubaTagStorage(TagStorage):
             for group_id, data in nested_groups.items()
         }
 
-    def get_group_seen_values_for_environments(
-        self, project_ids, group_id_list, environment_ids, start=None, end=None, tenant_ids=None
-    ):
-        # Get the total times seen, first seen, and last seen across multiple environments
-        filters = {"project_id": project_ids, "group_id": group_id_list}
-        if environment_ids:
-            filters["environment"] = environment_ids
-
-        aggregations = [
-            ["count()", "", "times_seen"],
-            ["min", SEEN_COLUMN, "first_seen"],
-            ["max", SEEN_COLUMN, "last_seen"],
-        ]
-
-        result = snuba.query(
-            dataset=Dataset.Events,
-            start=start,
-            end=end,
-            groupby=["group_id"],
-            conditions=[DEFAULT_TYPE_CONDITION],
-            filter_keys=filters,
-            aggregations=aggregations,
-            referrer="tagstore.get_group_seen_values_for_environments",
-            tenant_ids=tenant_ids,
-        )
-
-        return {issue: fix_tag_value_data(data) for issue, data in result.items()}
-
     def apply_group_filters_conditions(self, group: Group, conditions, filters):
         dataset = Dataset.Events
         if group:
@@ -842,47 +726,6 @@ class SnubaTagStorage(TagStorage):
 
         return None
 
-    def get_group_tag_values_for_users(self, event_users, limit=100, tenant_ids=None):
-        """While not specific to a group_id, this is currently only used in issues, so the Events dataset is used"""
-        filters = {"project_id": [eu.project_id for eu in event_users]}
-        conditions = [
-            ["tags[sentry:user]", "IN", [_f for _f in [eu.tag_value for eu in event_users] if _f]]
-        ]
-        aggregations = [
-            ["count()", "", "times_seen"],
-            ["min", SEEN_COLUMN, "first_seen"],
-            ["max", SEEN_COLUMN, "last_seen"],
-        ]
-
-        result = snuba.query(
-            dataset=Dataset.Events,
-            groupby=["group_id", "user_id"],
-            conditions=conditions,
-            filter_keys=filters,
-            aggregations=aggregations,
-            orderby="-last_seen",
-            limit=limit,
-            referrer="tagstore.get_group_tag_values_for_users",
-            tenant_ids=tenant_ids,
-        )
-
-        values = []
-        for issue, users in result.items():
-            for name, data in users.items():
-                values.append(
-                    GroupTagValue(
-                        group_id=issue, key="sentry:user", value=name, **fix_tag_value_data(data)
-                    )
-                )
-        for project_id in {eu.project_id for eu in event_users}:
-            analytics.record(
-                "eventuser_endpoint.request",
-                project_id=project_id,
-                endpoint="sentry.tagstore.snuba.backend.SnubaTagStorage.get_group_tag_values_for_users",
-            )
-
-        return values
-
     def __get_groups_user_counts(
         self,
         project_ids,
@@ -1517,40 +1360,3 @@ class SnubaTagStorage(TagStorage):
             [(int(getattr(gtv, score_field).timestamp() * 1000), gtv) for gtv in group_tag_values],
             reverse=desc,
         )
-
-    def get_group_tag_value_qs(self, project_id, group_id, environment_id, key, value=None):
-        # This method is not implemented because it is only used by the Django
-        # search backend.
-        raise NotImplementedError
-
-    def get_group_event_filter(
-        self, project_id, group_id, environment_ids, tags, start, end, tenant_ids=None
-    ):
-        filters = {"project_id": get_project_list(project_id), "group_id": [group_id]}
-        if environment_ids:
-            filters["environment"] = environment_ids
-
-        conditions = []
-        for tag_name, tag_val in tags.items():
-            operator = "IN" if isinstance(tag_val, list) else "="
-            conditions.append([f"tags[{tag_name}]", operator, tag_val])
-
-        result = snuba.raw_query(
-            dataset=Dataset.Events,
-            start=start,
-            end=end,
-            selected_columns=["event_id"],
-            conditions=conditions,
-            orderby="-timestamp",
-            filter_keys=filters,
-            limit=1000,
-            referrer="tagstore.get_group_event_filter",
-            tenant_ids=tenant_ids,
-        )
-
-        event_id_set = {row["event_id"] for row in result["data"]}
-
-        if not event_id_set:
-            return None
-
-        return {"event_id__in": event_id_set}

src/sentry/tasks/merge.py

@@ -4,7 +4,6 @@ from typing import Any
 
 from django.db import DataError, IntegrityError, router, transaction
 from django.db.models import F
-from django.db.models.base import Model
 
 from sentry import eventstream, similarity, tsdb
 from sentry.silo.base import SiloMode
@@ -14,9 +13,6 @@ from sentry.tsdb.base import TSDBModel
 logger = logging.getLogger("sentry.merge")
 delete_logger = logging.getLogger("sentry.deletions.async")
 
-# populated in `TagStorage.setup_merge`
-EXTRA_MERGE_MODELS: list[type[Model]] = []
-
 
 @instrumented_task(
     name="sentry.tasks.merge.merge_groups",
@@ -90,7 +86,7 @@ def merge_groups(
             extra={"transaction_id": transaction_id, "old_object_id": from_object_id},
         )
     else:
-        model_list = tuple(EXTRA_MERGE_MODELS) + (
+        model_list = (
             Activity,
             GroupAssignee,
             GroupEnvironment,

tests/sentry/api/serializers/test_release.py

@@ -76,12 +76,8 @@ class ReleaseSerializerTest(TestCase, SnubaTestCase):
         assert result["version"] == release.version
         # should be sum of all projects
         assert result["newGroups"] == 2
-        tagvalue1 = tagstore.backend.get_tag_value(
-            project.id,
-            None,
-            "sentry:release",
-            release_version,
-            tenant_ids={"organization_id": 1, "referrer": "r"},
+        (tagvalue1,) = tagstore.backend.get_release_tags(
+            1, [project.id], environment_id=None, versions=[release_version]
         )
         assert result["lastEvent"] == tagvalue1.last_seen
         assert result["commitCount"] == 1

tests/snuba/tagstore/test_tagstore_backend.py

@@ -15,18 +15,12 @@ from sentry.search.events.constants import (
     SEMVER_BUILD_ALIAS,
     SEMVER_PACKAGE_ALIAS,
 )
-from sentry.tagstore.exceptions import (
-    GroupTagKeyNotFound,
-    GroupTagValueNotFound,
-    TagKeyNotFound,
-    TagValueNotFound,
-)
+from sentry.tagstore.exceptions import GroupTagKeyNotFound, TagKeyNotFound
 from sentry.tagstore.snuba.backend import SnubaTagStorage
 from sentry.tagstore.types import GroupTagValue, TagValue
 from sentry.testutils.abstract import Abstract
 from sentry.testutils.cases import PerformanceIssueTestCase, SnubaTestCase, TestCase
 from sentry.testutils.helpers.datetime import before_now
-from sentry.utils.eventuser import EventUser
 from sentry.utils.samples import load_data
 from tests.sentry.issues.test_utils import SearchIssueTestMixin
 
@@ -575,51 +569,6 @@ class TagStorageTest(TestCase, SnubaTestCase, SearchIssueTestMixin, PerformanceI
         }
         assert set(keys) == {"biz", "environment", "foo", "sentry:user", "level", "sentry:release"}
 
-    def test_get_group_tag_value(self):
-        with pytest.raises(GroupTagValueNotFound):
-            self.ts.get_group_tag_value(
-                project_id=self.proj1.id,
-                group_id=self.proj1group1.id,
-                environment_id=self.proj1env1.id,
-                key="foo",
-                value="notreal",
-                tenant_ids={"referrer": "r", "organization_id": 1234},
-            )
-
-        assert (
-            self.ts.get_group_tag_values(
-                group=self.proj1group1,
-                environment_id=self.proj1env1.id,
-                key="notreal",
-                tenant_ids={"referrer": "r", "organization_id": 1234},
-            )
-            == set()
-        )
-
-        assert (
-            list(
-                self.ts.get_group_tag_values(
-                    group=self.proj1group1,
-                    environment_id=self.proj1env1.id,
-                    tenant_ids={"referrer": "r", "organization_id": 1234},
-                    key="foo",
-                )
-            )[0].value
-            == "bar"
-        )
-
-        assert (
-            self.ts.get_group_tag_value(
-                project_id=self.proj1.id,
-                group_id=self.proj1group1.id,
-                environment_id=self.proj1env1.id,
-                key="foo",
-                value="bar",
-                tenant_ids={"referrer": "r", "organization_id": 1234},
-            ).value
-            == "bar"
-        )
-
     def test_get_tag_key(self):
         with pytest.raises(TagKeyNotFound):
             self.ts.get_tag_key(
@@ -629,16 +578,6 @@ class TagStorageTest(TestCase, SnubaTestCase, SearchIssueTestMixin, PerformanceI
                 tenant_ids={"referrer": "r", "organization_id": 1234},
             )
 
-    def test_get_tag_value(self):
-        with pytest.raises(TagValueNotFound):
-            self.ts.get_tag_value(
-                project_id=self.proj1.id,
-                environment_id=self.proj1env1.id,
-                key="foo",
-                value="notreal",
-                tenant_ids={"referrer": "r", "organization_id": 1234},
-            )
-
     def test_get_tag_value_label(self):
         assert self.ts.get_tag_value_label("foo", "notreal") == "notreal"
         assert self.ts.get_tag_value_label("sentry:user", None) is None
@@ -694,56 +633,6 @@ class TagStorageTest(TestCase, SnubaTestCase, SearchIssueTestMixin, PerformanceI
             tenant_ids={"referrer": "r", "organization_id": 1234},
         ) == {self.proj1group1.id: 3, self.proj1group2.id: 1}
 
-    @mock.patch("sentry.analytics.record")
-    def test_get_group_tag_values_for_users(self, mock_record):
-        result = self.ts.get_group_tag_values_for_users(
-            [
-                EventUser(
-                    project_id=self.proj1.id,
-                    email=None,
-                    username=None,
-                    name=None,
-                    ip_address=None,
-                    user_ident="user1",
-                )
-            ],
-            tenant_ids={"referrer": "r", "organization_id": 1234},
-        )
-        assert len(result) == 2
-        assert {v.group_id for v in result} == {self.proj1group1.id, self.proj1group2.id}
-        assert {v.last_seen for v in result} == {
-            self.now - timedelta(seconds=1),
-            self.now - timedelta(seconds=2),
-        }
-        result.sort(key=lambda x: x.last_seen)
-        assert result[0].last_seen == self.now - timedelta(seconds=2)
-        assert result[1].last_seen == self.now - timedelta(seconds=1)
-        for v in result:
-            assert v.value == "user1"
-
-        result = self.ts.get_group_tag_values_for_users(
-            [
-                EventUser(
-                    project_id=self.proj1.id,
-                    email=None,
-                    username=None,
-                    name=None,
-                    ip_address=None,
-                    user_ident="user2",
-                )
-            ],
-            tenant_ids={"referrer": "r", "organization_id": 1234},
-        )
-        assert len(result) == 1
-        assert result[0].value == "user2"
-        assert result[0].last_seen == self.now - timedelta(seconds=2)
-
-        mock_record.assert_called_with(
-            "eventuser_endpoint.request",
-            project_id=self.proj1.id,
-            endpoint="sentry.tagstore.snuba.backend.SnubaTagStorage.get_group_tag_values_for_users",
-        )
-
     def test_get_release_tags(self):
         tags = list(
             self.ts.get_release_tags(self.proj1.organization_id, [self.proj1.id], None, ["100"])
@@ -815,80 +704,6 @@ class TagStorageTest(TestCase, SnubaTestCase, SearchIssueTestMixin, PerformanceI
             tags[0].times_seen == 2
         )  # Isn't 3 because start was limited by the ReleaseProjectEnvironment entry
 
-    def test_get_group_event_filter(self):
-        assert self.ts.get_group_event_filter(
-            self.proj1.id,
-            self.proj1group1.id,
-            [self.proj1env1.id],
-            {"foo": "bar"},
-            None,
-            None,
-            tenant_ids={"referrer": "r", "organization_id": 1234},
-        ) == {"event_id__in": {"1" * 32, "2" * 32}}
-
-        assert self.ts.get_group_event_filter(
-            self.proj1.id,
-            self.proj1group1.id,
-            [self.proj1env1.id],
-            {"foo": "bar"},
-            (self.now - timedelta(seconds=1)),
-            None,
-            tenant_ids={"referrer": "r", "organization_id": 1234},
-        ) == {"event_id__in": {"1" * 32}}
-
-        assert self.ts.get_group_event_filter(
-            self.proj1.id,
-            self.proj1group1.id,
-            [self.proj1env1.id],
-            {"foo": "bar"},
-            None,
-            (self.now - timedelta(seconds=1)),
-            tenant_ids={"referrer": "r", "organization_id": 1234},
-        ) == {"event_id__in": {"2" * 32}}
-
-        assert self.ts.get_group_event_filter(
-            self.proj1.id,
-            self.proj1group1.id,
-            [self.proj1env1.id, self.proj1env2.id],
-            {"foo": "bar"},
-            None,
-            None,
-            tenant_ids={"referrer": "r", "organization_id": 1234},
-        ) == {"event_id__in": {"1" * 32, "2" * 32, "4" * 32}}
-
-        assert self.ts.get_group_event_filter(
-            self.proj1.id,
-            self.proj1group1.id,
-            [self.proj1env1.id],
-            {"foo": "bar", "sentry:release": "200"},  # AND
-            None,
-            None,
-            tenant_ids={"referrer": "r", "organization_id": 1234},
-        ) == {"event_id__in": {"2" * 32}}
-
-        assert self.ts.get_group_event_filter(
-            self.proj1.id,
-            self.proj1group2.id,
-            [self.proj1env1.id],
-            {"browser": "chrome"},
-            None,
-            None,
-            tenant_ids={"referrer": "r", "organization_id": 1234},
-        ) == {"event_id__in": {"3" * 32}}
-
-        assert (
-            self.ts.get_group_event_filter(
-                self.proj1.id,
-                self.proj1group2.id,
-                [self.proj1env1.id],
-                {"browser": "ie"},
-                None,
-                None,
-                tenant_ids={"referrer": "r", "organization_id": 1234},
-            )
-            is None
-        )
-
     def test_get_tag_value_paginator(self):
         from sentry.tagstore.types import TagValue
 
@@ -1294,33 +1109,6 @@ class TagStorageTest(TestCase, SnubaTestCase, SearchIssueTestMixin, PerformanceI
         # top key should be "quux" as it's the most recent than "bar"
         assert top_key.value == "quux"
 
-    def test_get_group_seen_values_for_environments(self):
-        assert self.ts.get_group_seen_values_for_environments(
-            [self.proj1.id],
-            [self.proj1group1.id],
-            [self.proj1env1.id],
-            tenant_ids={"referrer": "r", "organization_id": 1234},
-        ) == {
-            self.proj1group1.id: {
-                "first_seen": self.now - timedelta(seconds=2),
-                "last_seen": self.now - timedelta(seconds=1),
-                "times_seen": 2,
-            }
-        }
-
-        # test where there should be no results because of time filters
-        assert (
-            self.ts.get_group_seen_values_for_environments(
-                [self.proj1.id],
-                [self.proj1group1.id],
-                [self.proj1env1.id],
-                start=self.now - timedelta(hours=5),
-                end=self.now - timedelta(hours=4),
-                tenant_ids={"referrer": "r", "organization_id": 1234},
-            )
-            == {}
-        )
-
 
 class ProfilingTagStorageTest(TestCase, SnubaTestCase, SearchIssueTestMixin):
     def setUp(self):

tests/snuba/tasks/test_unmerge.py

@@ -11,7 +11,7 @@ from unittest.mock import patch
 
 from django.utils import timezone
 
-from sentry import eventstream, tagstore, tsdb
+from sentry import eventstream, tsdb
 from sentry.eventstore.models import Event
 from sentry.models.environment import Environment
 from sentry.models.group import Group
@@ -273,16 +273,6 @@ class UnmergeTestCase(TestCase, SnubaTestCase):
             merge_groups.delay([merge_source.id], source.id)
             eventstream.backend.end_merge(eventstream_state)
 
-        assert {
-            (gtv.value, gtv.times_seen)
-            for gtv in tagstore.backend.get_group_tag_values(
-                source,
-                production_environment.id,
-                "color",
-                tenant_ids={"referrer": "get_tag_values", "organization_id": 1},
-            )
-        } == {("red", 6), ("green", 5), ("blue", 5)}
-
         similar_items = features.compare(source)
         assert len(similar_items) == 2
         assert similar_items[0][0] == source.id
@@ -333,16 +323,6 @@ class UnmergeTestCase(TestCase, SnubaTestCase):
             )
         ) == {("production", time_from_now(10), time_from_now(15))}
 
-        assert {
-            (gtv.value, gtv.times_seen)
-            for gtv in tagstore.backend.get_group_tag_values(
-                destination,
-                production_environment.id,
-                "color",
-                tenant_ids={"referrer": "get_tag_values", "organization_id": 1},
-            )
-        } == {("red", 4), ("green", 3), ("blue", 3)}
-
         destination_event_ids = set(
             map(lambda event: event.event_id, list(events.values())[0] + list(events.values())[2])
         )
@@ -364,16 +344,6 @@ class UnmergeTestCase(TestCase, SnubaTestCase):
             ("staging", time_from_now(16), time_from_now(16)),
         }
 
-        assert {
-            (gtk.value, gtk.times_seen)
-            for gtk in tagstore.backend.get_group_tag_values(
-                destination,
-                production_environment.id,
-                "color",
-                tenant_ids={"referrer": "get_tag_values", "organization_id": 1},
-            )
-        } == {("red", 4), ("blue", 3), ("green", 3)}
-
         rollup_duration = 3600
 
         time_series = tsdb.backend.get_range(