ref(discover) Remove reference event support (#20817)

We no longer use this parameter in the discover UI. It used to be used
for generating conditions for related events and time series results
based on a 'reference' event. Because we no longer use this code and it
adds a non-trivial amount of complexity I'd like to not have it anymore.

src/sentry/api/bases/organization_events.py

@@ -50,12 +50,6 @@ class OrganizationEventsEndpointBase(OrganizationEndpoint):
         if orderby:
             return orderby
 
-    def reference_event(self, request, organization, start, end):
-        fields = request.GET.getlist("field")[:]
-        reference_event_id = request.GET.get("referenceEvent")
-        if reference_event_id:
-            return discover.ReferenceEvent(organization, reference_event_id, fields, start, end)
-
     def get_snuba_query_args_legacy(self, request, organization):
         params = self.get_filter_params(request, organization)
         query = request.GET.get("query")
@@ -233,12 +227,8 @@ class OrganizationEventsV2EndpointBase(OrganizationEventsEndpointBase):
                     "eps()": "eps(%d)" % rollup,
                 }
                 query_columns = [column_map.get(column, column) for column in columns]
-                reference_event = self.reference_event(
-                    request, organization, params.get("start"), params.get("end")
-                )
-
             with sentry_sdk.start_span(op="discover.endpoint", description="base.stats_query"):
-                result = get_event_stats(query_columns, query, params, rollup, reference_event)
+                result = get_event_stats(query_columns, query, params, rollup)
 
         serializer = SnubaTSResultSerializer(organization, None, request.user)
 

src/sentry/api/endpoints/organization_events.py

@@ -117,9 +117,6 @@ class OrganizationEventsV2Endpoint(OrganizationEventsV2EndpointBase):
                 selected_columns=request.GET.getlist("field")[:],
                 query=request.GET.get("query"),
                 params=params,
-                reference_event=self.reference_event(
-                    request, organization, params.get("start"), params.get("end")
-                ),
                 orderby=self.get_orderby(request),
                 offset=offset,
                 limit=limit,

src/sentry/api/endpoints/organization_events_stats.py

@@ -41,7 +41,7 @@ class OrganizationEventsStatsEndpoint(OrganizationEventsV2EndpointBase):
                 elif limit <= 0:
                     return Response({"detail": "If topEvents needs to be at least 1"}, status=400)
 
-        def get_event_stats(query_columns, query, params, rollup, reference_event):
+        def get_event_stats(query_columns, query, params, rollup):
             if top_events:
                 return discover.top_events_timeseries(
                     timeseries_columns=query_columns,
@@ -59,7 +59,6 @@ class OrganizationEventsStatsEndpoint(OrganizationEventsV2EndpointBase):
                 query=query,
                 params=params,
                 rollup=rollup,
-                reference_event=reference_event,
                 referrer="api.organization-event-stats",
             )
 

src/sentry/api/endpoints/organization_events_trends.py

@@ -109,7 +109,7 @@ class OrganizationEventsTrendsEndpoint(OrganizationEventsV2EndpointBase):
             )
 
         def on_results(events_results):
-            def get_event_stats(query_columns, query, params, rollup, reference_event):
+            def get_event_stats(query_columns, query, params, rollup):
                 return discover.top_events_timeseries(
                     query_columns,
                     selected_columns,

src/sentry/snuba/discover.py

@@ -7,7 +7,6 @@ import logging
 
 from collections import namedtuple
 from copy import deepcopy
-from datetime import timedelta
 from math import ceil, floor
 
 from sentry import options
@@ -22,7 +21,7 @@ from sentry.api.event_search import (
 
 from sentry import eventstore
 
-from sentry.models import Project, ProjectStatus, Group
+from sentry.models import Group
 from sentry.tagstore.base import TOP_VALUES_DEFAULT_LIMIT
 from sentry.utils.snuba import (
     Dataset,
@@ -37,10 +36,8 @@ from sentry.utils.snuba import (
 )
 
 __all__ = (
-    "ReferenceEvent",
     "PaginationResult",
     "InvalidSearchQuery",
-    "create_reference_event_conditions",
     "query",
     "key_transaction_query",
     "timeseries_query",
@@ -53,9 +50,6 @@ __all__ = (
 
 logger = logging.getLogger(__name__)
 
-ReferenceEvent = namedtuple("ReferenceEvent", ["organization", "slug", "fields", "start", "end"])
-ReferenceEvent.__new__.__defaults__ = (None, None)
-
 PaginationResult = namedtuple("PaginationResult", ["next", "previous", "oldest", "latest"])
 FacetResult = namedtuple("FacetResult", ["key", "value", "count"])
 
@@ -76,81 +70,6 @@ def is_real_column(col):
     return True
 
 
-def find_reference_event(reference_event):
-    try:
-        project_slug, event_id = reference_event.slug.split(":")
-    except ValueError:
-        raise InvalidSearchQuery("Invalid reference event format")
-
-    column_names = [
-        resolve_discover_column(col) for col in reference_event.fields if is_real_column(col)
-    ]
-    # We don't need to run a query if there are no columns
-    if not column_names:
-        return None
-
-    try:
-        project = Project.objects.get(
-            slug=project_slug,
-            organization=reference_event.organization,
-            status=ProjectStatus.VISIBLE,
-        )
-    except Project.DoesNotExist:
-        raise InvalidSearchQuery("Invalid reference event project")
-
-    start = None
-    end = None
-    if reference_event.start:
-        start = reference_event.start - timedelta(seconds=5)
-    if reference_event.end:
-        end = reference_event.end + timedelta(seconds=5)
-
-    # We use raw_query here because generating conditions from an eventstore
-    # event requires non-trivial translation from the flat list of fields into
-    # structured fields like message, stack, and tags.
-    event = raw_query(
-        selected_columns=column_names,
-        filter_keys={"project_id": [project.id], "event_id": [event_id]},
-        start=start,
-        end=end,
-        dataset=Dataset.Discover,
-        limit=1,
-        referrer="discover.find_reference_event",
-    )
-    if "error" in event or len(event["data"]) != 1:
-        raise InvalidSearchQuery("Unable to find reference event")
-
-    return event["data"][0]
-
-
-def create_reference_event_conditions(reference_event):
-    """
-    Create a list of conditions based on a Reference object.
-
-    This is useful when you want to get results that match an exemplar
-    event. A use case of this is generating pagination links for, or getting
-    timeseries results of the records inside a single aggregated row.
-
-    reference_event (ReferenceEvent) The reference event to build conditions from.
-    """
-    conditions = []
-    event_data = find_reference_event(reference_event)
-    if event_data is None:
-        return conditions
-
-    field_names = [resolve_discover_column(col) for col in reference_event.fields]
-    for (i, field) in enumerate(reference_event.fields):
-        value = event_data.get(field_names[i], None)
-        # If the value is a sequence use the first element as snuba
-        # doesn't support `=` or `IN` operations on fields like exception_frames.filename
-        if isinstance(value, (list, set)) and value:
-            value = value.pop()
-        if value:
-            conditions.append([field, "=", value])
-
-    return conditions
-
-
 # TODO (evanh) This whole function is here because we are using the max value to
 # calculate the entire bucket width. If we could do that in a smarter way,
 # we could avoid this whole calculation.
@@ -382,7 +301,6 @@ def query(
     orderby=None,
     offset=None,
     limit=50,
-    reference_event=None,
     referrer=None,
     auto_fields=False,
     use_aggregate_conditions=False,
@@ -404,8 +322,6 @@ def query(
     orderby (None|str|Sequence[str]) The field to order results by.
     offset (None|int) The record offset to read.
     limit (int) The number of records to fetch.
-    reference_event (ReferenceEvent) A reference event object. Used to generate additional
-                    conditions based on the provided reference.
     referrer (str|None) A referrer string to help locate the origin of this query.
     auto_fields (bool) Set to true to have project + eventid fields automatically added.
     conditions (Sequence[any]) List of conditions that are passed directly to snuba without
@@ -466,11 +382,6 @@ def query(
             resolve_field_list(selected_columns, snuba_filter, auto_fields=auto_fields)
         )
 
-        if reference_event:
-            ref_conditions = create_reference_event_conditions(reference_event)
-            if ref_conditions:
-                snuba_filter.conditions.extend(ref_conditions)
-
         # Resolve the public aliases into the discover dataset names.
         snuba_filter, translated_columns = resolve_discover_aliases(
             snuba_filter, function_translations
@@ -586,18 +497,12 @@ def key_transaction_query(selected_columns, user_query, params, orderby, referre
     )
 
 
-def get_timeseries_snuba_filter(
-    selected_columns, query, params, rollup, reference_event=None, default_count=True
-):
+def get_timeseries_snuba_filter(selected_columns, query, params, rollup, default_count=True):
     snuba_filter = get_filter(query, params)
     if not snuba_filter.start and not snuba_filter.end:
         raise InvalidSearchQuery("Cannot get timeseries result without a start and end.")
 
     snuba_filter.update_with(resolve_field_list(selected_columns, snuba_filter, auto_fields=False))
-    if reference_event:
-        ref_conditions = create_reference_event_conditions(reference_event)
-        if ref_conditions:
-            snuba_filter.conditions.extend(ref_conditions)
 
     # Resolve the public aliases into the discover dataset names.
     snuba_filter, translated_columns = resolve_discover_aliases(snuba_filter)
@@ -660,7 +565,7 @@ def key_transaction_timeseries_query(selected_columns, query, params, rollup, re
         return SnubaTSResult({"data": result}, snuba_filter.start, snuba_filter.end, rollup)
 
 
-def timeseries_query(selected_columns, query, params, rollup, reference_event=None, referrer=None):
+def timeseries_query(selected_columns, query, params, rollup, referrer=None):
     """
     High-level API for doing arbitrary user timeseries queries against events.
 
@@ -678,17 +583,13 @@ def timeseries_query(selected_columns, query, params, rollup, reference_event=No
     query (str) Filter query string to create conditions from.
     params (Dict[str, str]) Filtering parameters with start, end, project_id, environment,
     rollup (int) The bucket width in seconds
-    reference_event (ReferenceEvent) A reference event object. Used to generate additional
-                    conditions based on the provided reference.
     referrer (str|None) A referrer string to help locate the origin of this query.
     """
     with sentry_sdk.start_span(
         op="discover.discover", description="timeseries.filter_transform"
     ) as span:
         span.set_data("query", query)
-        snuba_filter, _ = get_timeseries_snuba_filter(
-            selected_columns, query, params, rollup, reference_event
-        )
+        snuba_filter, _ = get_timeseries_snuba_filter(selected_columns, query, params, rollup)
 
     with sentry_sdk.start_span(op="discover.discover", description="timeseries.snuba_query"):
         result = raw_query(

src/sentry/static/sentry/app/actionCreators/events.tsx

@@ -33,7 +33,6 @@ type Options = {
   query?: string;
   yAxis?: string | string[];
   field?: string[];
-  referenceEvent?: string;
   keyTransactions?: boolean;
   topEvents?: number;
   orderby?: string;
@@ -67,7 +66,6 @@ export const doEventsRequest = (
     query,
     yAxis,
     field,
-    referenceEvent,
     keyTransactions,
     topEvents,
     orderby,
@@ -82,7 +80,6 @@ export const doEventsRequest = (
       query,
       yAxis,
       field,
-      referenceEvent,
       topEvents,
       orderby,
     }).filter(([, value]) => typeof value !== 'undefined')

src/sentry/static/sentry/app/components/charts/eventsRequest.tsx

@@ -103,10 +103,6 @@ type EventsRequestPartialProps = {
    * List of fields to group with when doing a topEvents request.
    */
   field?: string[];
-  /**
-   * Reference event to use when generating additional conditions.
-   */
-  referenceEvent?: string;
   /**
    * Initial loading state
    */
@@ -200,7 +196,6 @@ class EventsRequest extends React.PureComponent<EventsRequestProps, EventsReques
     yAxis: PropTypes.oneOfType([PropTypes.string, PropTypes.arrayOf(PropTypes.string)]),
 
     field: PropTypes.arrayOf(PropTypes.string),
-    referenceEvent: PropTypes.string,
     keyTransactions: PropTypes.bool,
     topEvents: PropTypes.number,
     orderby: PropTypes.string,

tests/sentry/snuba/test_discover.py

@@ -436,54 +436,6 @@ class QueryIntegrationTest(SnubaTestCase, TestCase):
                 use_aggregate_conditions=True,
             )
 
-    def test_reference_event(self):
-        two_minutes = before_now(minutes=2)
-        five_minutes = before_now(minutes=5)
-        self.store_event(
-            data={"event_id": "a" * 32, "message": "oh no", "timestamp": iso_format(two_minutes)},
-            project_id=self.project.id,
-        )
-        self.store_event(
-            data={
-                "event_id": "b" * 32,
-                "message": "no match",
-                "timestamp": iso_format(two_minutes),
-            },
-            project_id=self.project.id,
-        )
-        ref = discover.ReferenceEvent(
-            self.organization,
-            "{}:{}".format(self.project.slug, "a" * 32),
-            ["message", "count()"],
-            two_minutes,
-            two_minutes,
-        )
-        result = discover.query(
-            selected_columns=["id", "message"],
-            query="",
-            reference_event=ref,
-            params={"project_id": [self.project.id]},
-        )
-        assert len(result["data"]) == 2
-        for row in result["data"]:
-            assert row["message"] == "oh no"
-
-        # make an invalid reference with old dates
-        ref = discover.ReferenceEvent(
-            self.organization,
-            "{}:{}".format(self.project.slug, "a" * 32),
-            ["message", "count()"],
-            five_minutes,
-            five_minutes,
-        )
-        with pytest.raises(InvalidSearchQuery):
-            discover.query(
-                selected_columns=["id", "message"],
-                query="",
-                reference_event=ref,
-                params={"project_id": [self.project.id]},
-            )
-
 
 class QueryTransformTest(TestCase):
     """
@@ -2001,207 +1953,6 @@ class TimeseriesQueryTest(SnubaTestCase, TestCase):
             if "count" in d:
                 assert d["count"] == 2
 
-    def test_reference_event(self):
-        ref = discover.ReferenceEvent(
-            self.organization,
-            "{}:{}".format(self.project.slug, "a" * 32),
-            ["message", "count()", "last_seen"],
-        )
-        result = discover.timeseries_query(
-            selected_columns=["count()"],
-            query="",
-            params={
-                "start": self.day_ago,
-                "end": self.day_ago + timedelta(hours=3),
-                "project_id": [self.project.id],
-            },
-            reference_event=ref,
-            rollup=3600,
-        )
-        assert len(result.data["data"]) == 4
-        assert [1, 1] == [val["count"] for val in result.data["data"] if "count" in val]
-
-
-class CreateReferenceEventConditionsTest(SnubaTestCase, TestCase):
-    def test_bad_slug_format(self):
-        ref = discover.ReferenceEvent(self.organization, "lol", ["title"])
-        with pytest.raises(InvalidSearchQuery):
-            discover.create_reference_event_conditions(ref)
-
-    def test_unknown_project(self):
-        event = self.store_event(
-            data={"message": "oh no!", "timestamp": iso_format(before_now(seconds=1))},
-            project_id=self.project.id,
-        )
-        ref = discover.ReferenceEvent(
-            self.organization, "nope:{}".format(event.event_id), ["title"]
-        )
-        with pytest.raises(InvalidSearchQuery):
-            discover.create_reference_event_conditions(ref)
-
-    def test_unknown_event(self):
-        with pytest.raises(InvalidSearchQuery):
-            slug = "{}:deadbeef".format(self.project.slug)
-            ref = discover.ReferenceEvent(self.organization, slug, ["message"])
-            discover.create_reference_event_conditions(ref)
-
-    def test_unknown_event_and_no_fields(self):
-        slug = "{}:deadbeef".format(self.project.slug)
-        ref = discover.ReferenceEvent(self.organization, slug, [])
-        result = discover.create_reference_event_conditions(ref)
-        assert len(result) == 0
-
-    def test_no_fields(self):
-        event = self.store_event(
-            data={
-                "message": "oh no!",
-                "transaction": "/issues/{issue_id}",
-                "timestamp": iso_format(before_now(seconds=1)),
-            },
-            project_id=self.project.id,
-        )
-        slug = "{}:{}".format(self.project.slug, event.event_id)
-        ref = discover.ReferenceEvent(self.organization, slug, [])
-        result = discover.create_reference_event_conditions(ref)
-        assert len(result) == 0
-
-    def test_basic_fields(self):
-        event = self.store_event(
-            data={
-                "message": "oh no!",
-                "transaction": "/issues/{issue_id}",
-                "timestamp": iso_format(before_now(seconds=1)),
-            },
-            project_id=self.project.id,
-        )
-
-        slug = "{}:{}".format(self.project.slug, event.event_id)
-        ref = discover.ReferenceEvent(
-            self.organization, slug, ["message", "transaction", "unknown-field"]
-        )
-        result = discover.create_reference_event_conditions(ref)
-        assert result == [
-            ["message", "=", "oh no! /issues/{issue_id}"],
-            ["transaction", "=", "/issues/{issue_id}"],
-        ]
-
-    def test_geo_field(self):
-        event = self.store_event(
-            data={
-                "message": "oh no!",
-                "transaction": "/issues/{issue_id}",
-                "user": {
-                    "id": 1,
-                    "geo": {"country_code": "US", "region": "CA", "city": "San Francisco"},
-                },
-                "timestamp": iso_format(before_now(seconds=1)),
-            },
-            project_id=self.project.id,
-        )
-        slug = "{}:{}".format(self.project.slug, event.event_id)
-        ref = discover.ReferenceEvent(
-            self.organization, slug, ["geo.city", "geo.region", "geo.country_code"]
-        )
-        result = discover.create_reference_event_conditions(ref)
-        assert result == [
-            ["geo.city", "=", "San Francisco"],
-            ["geo.region", "=", "CA"],
-            ["geo.country_code", "=", "US"],
-        ]
-
-    def test_sdk_field(self):
-        event = self.store_event(
-            data={
-                "message": "oh no!",
-                "transaction": "/issues/{issue_id}",
-                "sdk": {"name": "sentry-python", "version": "5.0.12"},
-                "timestamp": iso_format(before_now(seconds=1)),
-            },
-            project_id=self.project.id,
-        )
-        slug = "{}:{}".format(self.project.slug, event.event_id)
-        ref = discover.ReferenceEvent(self.organization, slug, ["sdk.version", "sdk.name"])
-        result = discover.create_reference_event_conditions(ref)
-        assert result == [["sdk.version", "=", "5.0.12"], ["sdk.name", "=", "sentry-python"]]
-
-    def test_error_field(self):
-        data = load_data("php")
-        data["timestamp"] = iso_format(before_now(seconds=1))
-        event = self.store_event(data=data, project_id=self.project.id)
-
-        slug = "{}:{}".format(self.project.slug, event.event_id)
-        ref = discover.ReferenceEvent(
-            self.organization, slug, ["error.value", "error.type", "error.handled"]
-        )
-        result = discover.create_reference_event_conditions(ref)
-        assert result == [
-            ["error.value", "=", "This is a test exception sent from the Raven CLI."],
-            ["error.type", "=", "Exception"],
-        ]
-
-    def test_stack_field(self):
-        data = load_data("php")
-        data["timestamp"] = iso_format(before_now(seconds=1))
-        event = self.store_event(data=data, project_id=self.project.id)
-
-        slug = "{}:{}".format(self.project.slug, event.event_id)
-        ref = discover.ReferenceEvent(self.organization, slug, ["stack.filename", "stack.function"])
-        result = discover.create_reference_event_conditions(ref)
-        assert result == [
-            ["stack.filename", "=", "/Users/example/Development/raven-php/bin/raven"],
-            ["stack.function", "=", "raven_cli_test"],
-        ]
-
-    def test_tag_value(self):
-        event = self.store_event(
-            data={
-                "message": "oh no!",
-                "timestamp": iso_format(before_now(seconds=1)),
-                "tags": {"customer_id": 1, "color": "red"},
-            },
-            project_id=self.project.id,
-        )
-        slug = "{}:{}".format(self.project.slug, event.event_id)
-        ref = discover.ReferenceEvent(self.organization, slug, ["nope", "color", "customer_id"])
-        result = discover.create_reference_event_conditions(ref)
-        assert result == [["color", "=", "red"], ["customer_id", "=", "1"]]
-
-    def test_context_value(self):
-        event = self.store_event(
-            data={
-                "message": "oh no!",
-                "timestamp": iso_format(before_now(seconds=1)),
-                "contexts": {
-                    "os": {"version": "10.14.6", "type": "os", "name": "Mac OS X"},
-                    "browser": {"type": "browser", "name": "Firefox", "version": "69"},
-                    "gpu": {"type": "gpu", "name": "nvidia 8600", "vendor": "nvidia"},
-                },
-            },
-            project_id=self.project.id,
-        )
-        slug = "{}:{}".format(self.project.slug, event.event_id)
-        ref = discover.ReferenceEvent(self.organization, slug, ["gpu.name", "browser.name"])
-        result = discover.create_reference_event_conditions(ref)
-        assert result == [["gpu.name", "=", "nvidia 8600"], ["browser.name", "=", "Firefox"]]
-
-    def test_issue_field(self):
-        event = self.store_event(
-            data={
-                "message": "oh no!",
-                "timestamp": iso_format(before_now(seconds=1)),
-                "contexts": {
-                    "os": {"version": "10.14.6", "type": "os", "name": "Mac OS X"},
-                    "browser": {"type": "browser", "name": "Firefox", "version": "69"},
-                    "gpu": {"type": "gpu", "name": "nvidia 8600", "vendor": "nvidia"},
-                },
-            },
-            project_id=self.project.id,
-        )
-        slug = "{}:{}".format(self.project.slug, event.event_id)
-        ref = discover.ReferenceEvent(self.organization, slug, ["issue.id"])
-        result = discover.create_reference_event_conditions(ref)
-        assert result == [["issue.id", "=", event.group_id]]
-
 
 def format_project_event(project_slug, event_id):
     return "{}:{}".format(project_slug, event_id)

tests/snuba/api/endpoints/test_organization_events_stats.py

@@ -391,78 +391,6 @@ class OrganizationEventsStatsEndpointTest(APITestCase, SnubaTestCase):
         for row in rows:
             assert row[1][0]["count"] == 1
 
-    def test_with_field_and_reference_event_invalid(self):
-        with self.feature("organizations:discover-basic"):
-            response = self.client.get(
-                self.url,
-                format="json",
-                data={
-                    "start": iso_format(self.day_ago),
-                    "end": iso_format(self.day_ago + timedelta(hours=2)),
-                    "interval": "1h",
-                    "referenceEvent": "nope-invalid",
-                    "yAxis": "count()",
-                },
-            )
-        assert response.status_code == 400, response.content
-        assert "reference" in response.content
-
-    def test_only_reference_event(self):
-        # Create a new event that message matches events made in setup
-        event = self.store_event(
-            data={
-                "event_id": "e" * 32,
-                "message": "oh my",
-                "timestamp": iso_format(self.day_ago + timedelta(minutes=2)),
-                "tags": {"sentry:user": "bob@example.com"},
-                "fingerprint": ["group3"],
-            },
-            project_id=self.project.id,
-        )
-        with self.feature("organizations:discover-basic"):
-            response = self.client.get(
-                self.url,
-                format="json",
-                data={
-                    "start": iso_format(self.day_ago),
-                    "end": iso_format(self.day_ago + timedelta(hours=2)),
-                    "interval": "1h",
-                    "referenceEvent": "%s:%s" % (self.project.slug, event.event_id),
-                    "yAxis": "count()",
-                },
-            )
-        assert response.status_code == 200, response.content
-        # Because we didn't send fields, the reference event is not applied
-        assert [attrs for time, attrs in response.data["data"]] == [[{"count": 2}], [{"count": 2}]]
-
-    def test_field_and_reference_event(self):
-        # Create a new event that message matches events made in setup
-        event = self.store_event(
-            data={
-                "event_id": "e" * 32,
-                "message": "oh my",
-                "timestamp": iso_format(self.day_ago + timedelta(minutes=2)),
-                "tags": {"sentry:user": "bob@example.com"},
-                "fingerprint": ["group3"],
-            },
-            project_id=self.project.id,
-        )
-        with self.feature("organizations:discover-basic"):
-            response = self.client.get(
-                self.url,
-                format="json",
-                data={
-                    "start": iso_format(self.day_ago),
-                    "end": iso_format(self.day_ago + timedelta(hours=2)),
-                    "field": ["message", "count()"],
-                    "interval": "1h",
-                    "referenceEvent": "%s:%s" % (self.project.slug, event.event_id),
-                    "yAxis": "count()",
-                },
-            )
-        assert response.status_code == 200, response.content
-        assert [attrs for time, attrs in response.data["data"]] == [[{"count": 1}], [{"count": 1}]]
-
     def test_transaction_events(self):
         prototype = {
             "type": "transaction",

tests/snuba/api/endpoints/test_organization_events_v2.py

@@ -1263,46 +1263,6 @@ class OrganizationEventsV2EndpointTest(APITestCase, SnubaTestCase):
         assert len(data) == 1
         assert data[0]["count"] == 0
 
-    def test_reference_event(self):
-        project = self.create_project()
-        reference = self.store_event(
-            data={
-                "event_id": "a" * 32,
-                "transaction": "/example",
-                "message": "how to make fast",
-                "timestamp": self.two_min_ago,
-            },
-            project_id=project.id,
-        )
-        self.store_event(
-            data={
-                "event_id": "b" * 32,
-                "transaction": "/example",
-                "message": "how to make more faster?",
-                "timestamp": self.min_ago,
-            },
-            project_id=project.id,
-        )
-        self.store_event(
-            data={
-                "event_id": "c" * 32,
-                "transaction": "/nomatch",
-                "message": "how to make fast",
-                "timestamp": self.min_ago,
-            },
-            project_id=project.id,
-        )
-        query = {
-            "field": ["transaction", "count()"],
-            "query": "",
-            "referenceEvent": "{}:{}".format(project.slug, reference.event_id),
-        }
-        response = self.do_request(query)
-        assert response.status_code == 200, response.content
-        assert len(response.data["data"]) == 1
-        data = response.data["data"]
-        assert data[0]["transaction"] == "/example"
-
     def test_stack_wildcard_condition(self):
         project = self.create_project()
         data = load_data("javascript")