from __future__ import annotations import random from collections import namedtuple from copy import deepcopy from datetime import timedelta import pytest from django.urls import reverse from rest_framework.exceptions import ErrorDetail from sentry.sentry_metrics.aggregation_option_registry import AggregationOption from sentry.testutils.cases import APITestCase, MetricsEnhancedPerformanceTestCase, SnubaTestCase from sentry.testutils.helpers.datetime import before_now, iso_format from sentry.utils.samples import load_data from sentry.utils.snuba import get_array_column_alias pytestmark = pytest.mark.sentry_metrics HistogramSpec = namedtuple( "HistogramSpec", ["start", "end", "fields", "tags"], defaults=[None, None, [], {}] ) ARRAY_COLUMNS = ["measurements", "span_op_breakdowns"] class OrganizationEventsHistogramEndpointTest(APITestCase, SnubaTestCase): def setUp(self): super().setUp() self.min_ago = iso_format(before_now(minutes=1)) self.data = load_data("transaction") self.features = {} def populate_events(self, specs): start = before_now(minutes=5) for spec in specs: spec = HistogramSpec(*spec) for suffix_key, count in spec.fields: for i in range(count): data = deepcopy(self.data) measurement_name = suffix_key breakdown_name = f"ops.{suffix_key}" data["timestamp"] = iso_format(start) data["start_timestamp"] = iso_format(start - timedelta(seconds=i)) value = random.random() * (spec.end - spec.start) + spec.start data["transaction"] = f"/measurement/{measurement_name}/value/{value}" data["measurements"] = {measurement_name: {"value": value}} data["breakdowns"] = { "span_ops": { breakdown_name: {"value": value}, } } self.store_event(data, self.project.id) def as_response_data(self, specs): data: dict[str, list[dict[str, int]]] = {} for spec in specs: spec = HistogramSpec(*spec) for measurement, count in sorted(spec.fields): if measurement not in data: data[measurement] = [] data[measurement].append({"bin": spec.start, "count": count}) return data def do_request(self, query, features=None): if features is None: features = {"organizations:performance-view": True} features.update(self.features) self.login_as(user=self.user) url = reverse( "sentry-api-0-organization-events-histogram", kwargs={"organization_id_or_slug": self.organization.slug}, ) with self.feature(features): return self.client.get(url, query, format="json") def test_no_projects(self): response = self.do_request({}) assert response.status_code == 200, response.content assert response.data == {} def test_good_params(self): for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "query": "event.type:transaction", "project": [self.project.id], "field": [f"{alias}.foo", f"{alias}.bar"], "numBuckets": 10, } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" def test_good_params_with_optionals(self): for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "query": "event.type:transaction", "project": [self.project.id], "field": [f"{alias}.foo", f"{alias}.bar"], "numBuckets": 10, "precision": 0, "min": 0, "max": 10, } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" def test_bad_params_reverse_min_max(self): for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "query": "event.type:transaction", "project": [self.project.id], "field": [f"{alias}.foo", f"{alias}.bar"], "numBuckets": 10, "precision": 0, "min": 10, "max": 5, } response = self.do_request(query) assert response.data == {"non_field_errors": ["min cannot be greater than max."]} def test_bad_params_missing_fields(self): query = { "project": [self.project.id], "numBuckets": 10, } response = self.do_request(query) assert response.status_code == 400 assert response.data == { "field": [ErrorDetail(string="This field is required.", code="required")], } def test_bad_params_too_many_fields(self): query = { "project": [self.project.id], "field": ["foo", "bar", "baz", "qux", "quux"], "numBuckets": 10, "min": 0, "max": 100, "precision": 0, } response = self.do_request(query) assert response.status_code == 400 assert response.data == { "field": ["Ensure this field has no more than 4 elements."], } def test_bad_params_mixed_fields(self): for array_column in ARRAY_COLUMNS: for other_array_column in ARRAY_COLUMNS: query = { "project": [self.project.id], "field": [ "foo", f"{get_array_column_alias(array_column)}.foo", f"{get_array_column_alias(other_array_column)}.bar", ], "numBuckets": 10, "min": 0, "max": 100, "precision": 0, } response = self.do_request(query) assert response.status_code == 400, f"failing for {array_column}" assert response.data == { "field": [ "You can only generate histogram for one column at a time unless they are all measurements or all span op breakdowns." ], }, f"failing for {array_column}" def test_bad_params_missing_num_buckets(self): query = { "project": [self.project.id], "field": ["foo"], } response = self.do_request(query) assert response.status_code == 400 assert response.data == { "numBuckets": ["This field is required."], } def test_bad_params_invalid_num_buckets(self): for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo", f"{alias}.bar"], "numBuckets": "baz", } response = self.do_request(query) assert response.status_code == 400, f"failing for {array_column}" assert response.data == { "numBuckets": ["A valid integer is required."], }, f"failing for {array_column}" def test_bad_params_invalid_negative_num_buckets(self): for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo", f"{alias}.bar"], "numBuckets": -1, } response = self.do_request(query) assert response.status_code == 400, f"failing for {array_column}" assert response.data == { "numBuckets": ["Ensure this value is greater than or equal to 1."], }, f"failing for {array_column}" def test_bad_params_num_buckets_too_large(self): for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo", f"{alias}.bar"], "numBuckets": 150, } response = self.do_request(query) assert response.status_code == 400, f"failing for {array_column}" assert response.data == { "numBuckets": ["Ensure this value is less than or equal to 100."], }, f"failing for {array_column}" def test_bad_params_invalid_precision_too_small(self): for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo", f"{alias}.bar"], "numBuckets": 10, "precision": -1, } response = self.do_request(query) assert response.status_code == 400, f"failing for {array_column}" assert response.data == { "precision": ["Ensure this value is greater than or equal to 0."], }, f"failing for {array_column}" def test_bad_params_invalid_precision_too_big(self): for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo", f"{alias}.bar"], "numBuckets": 10, "precision": 100, } response = self.do_request(query) assert response.status_code == 400, f"failing for {array_column}" assert response.data == { "precision": ["Ensure this value is less than or equal to 4."], }, f"failing for {array_column}" def test_bad_params_invalid_min(self): for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo", f"{alias}.bar"], "numBuckets": 10, "min": "qux", } response = self.do_request(query) assert response.status_code == 400, f"failing for {array_column}" assert response.data == { "min": ["A valid number is required."], }, f"failing for {array_column}" def test_bad_params_invalid_max(self): for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo", f"{alias}.bar"], "numBuckets": 10, "max": "qux", } response = self.do_request(query) assert response.status_code == 400, f"failing for {array_column}" assert response.data == { "max": ["A valid number is required."], }, f"failing for {array_column}" def test_histogram_empty(self): for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo", f"{alias}.bar"], "numBuckets": 5, } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [(i, i + 1, [(f"{alias}.foo", 0), (f"{alias}.bar", 0)]) for i in range(5)] assert response.data == self.as_response_data(expected), f"failing for {array_column}" def test_histogram_simple(self): # range is [0, 5), so it is divided into 5 buckets of width 1 specs = [ (0, 1, [("foo", 1)]), (1, 2, [("foo", 1)]), (2, 3, [("foo", 1)]), (4, 5, [("foo", 1)]), ] self.populate_events(specs) for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo"], "numBuckets": 5, } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [ (0, 1, [(f"{alias}.foo", 1)]), (1, 2, [(f"{alias}.foo", 1)]), (2, 3, [(f"{alias}.foo", 1)]), (3, 4, [(f"{alias}.foo", 0)]), (4, 5, [(f"{alias}.foo", 1)]), ] assert response.data == self.as_response_data(expected), f"failing for {array_column}" def test_histogram_simple_using_min_max(self): # range is [0, 5), so it is divided into 5 buckets of width 1 specs = [ (0, 1, [("foo", 1)]), (1, 2, [("foo", 1)]), (2, 3, [("foo", 1)]), (4, 5, [("foo", 1)]), ] self.populate_events(specs) for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo"], "numBuckets": 5, "min": 0, "max": 5, } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [ (0, 1, [(f"{alias}.foo", 1)]), (1, 2, [(f"{alias}.foo", 1)]), (2, 3, [(f"{alias}.foo", 1)]), (3, 4, [(f"{alias}.foo", 0)]), (4, 5, [(f"{alias}.foo", 1)]), ] assert response.data == self.as_response_data(expected), f"failing for {array_column}" def test_histogram_simple_using_given_min_above_queried_max(self): # All these events are out of range of the query parameters, # and should not appear in the results. specs = [ (0, 1, [("foo", 1)]), (1, 2, [("foo", 1)]), (2, 3, [("foo", 1)]), (4, 5, [("foo", 1)]), ] self.populate_events(specs) for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo"], "numBuckets": 5, "min": 6, } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [ (6, 7, [(f"{alias}.foo", 0)]), ] assert response.data == self.as_response_data(expected), f"failing for {array_column}" def test_histogram_simple_using_given_max_below_queried_min(self): # All these events are out of range of the query parameters, # and should not appear in the results. specs = [ (6, 7, [("foo", 1)]), (8, 9, [("foo", 1)]), (10, 11, [("foo", 1)]), (12, 13, [("foo", 1)]), ] self.populate_events(specs) for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo"], "numBuckets": 5, "max": 6, } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [ (5, 6, [(f"{alias}.foo", 0)]), ] assert response.data == self.as_response_data(expected), f"failing for {array_column}" def test_histogram_large_buckets(self): # make sure that it works for large width buckets # range is [0, 99], so it is divided into 5 buckets of width 20 specs = [ (0, 0, [("foo", 2)]), (99, 99, [("foo", 2)]), ] self.populate_events(specs) for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo"], "numBuckets": 5, } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [ (0, 20, [(f"{alias}.foo", 2)]), (20, 40, [(f"{alias}.foo", 0)]), (40, 60, [(f"{alias}.foo", 0)]), (60, 80, [(f"{alias}.foo", 0)]), (80, 100, [(f"{alias}.foo", 2)]), ] assert response.data == self.as_response_data(expected), f"failing for {array_column}" def test_histogram_non_zero_offset(self): # range is [10, 15), so it is divided into 5 buckets of width 1 specs = [ (10, 11, [("foo", 1)]), (12, 13, [("foo", 1)]), (13, 14, [("foo", 1)]), (14, 15, [("foo", 1)]), ] self.populate_events(specs) for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo"], "numBuckets": 5, } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [ (10, 11, [(f"{alias}.foo", 1)]), (11, 12, [(f"{alias}.foo", 0)]), (12, 13, [(f"{alias}.foo", 1)]), (13, 14, [(f"{alias}.foo", 1)]), (14, 15, [(f"{alias}.foo", 1)]), ] assert response.data == self.as_response_data(expected), f"failing for {array_column}" def test_histogram_extra_data(self): # range is [11, 16), so it is divided into 5 buckets of width 1 # make sure every bin has some value specs = [ (10, 11, [("foo", 1)]), (11, 12, [("foo", 1)]), (12, 13, [("foo", 1)]), (13, 14, [("foo", 1)]), (14, 15, [("foo", 1)]), (15, 16, [("foo", 1)]), (16, 17, [("foo", 1)]), ] self.populate_events(specs) for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo"], "numBuckets": 5, "min": 11, "max": 16, } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [ (11, 12, [(f"{alias}.foo", 1)]), (12, 13, [(f"{alias}.foo", 1)]), (13, 14, [(f"{alias}.foo", 1)]), (14, 15, [(f"{alias}.foo", 1)]), (15, 16, [(f"{alias}.foo", 1)]), ] assert response.data == self.as_response_data(expected), f"failing for {array_column}" def test_histogram_non_zero_min_large_buckets(self): # range is [10, 59], so it is divided into 5 buckets of width 10 specs = [ (10, 10, [("foo", 1)]), (40, 50, [("foo", 1)]), (59, 59, [("foo", 2)]), ] self.populate_events(specs) for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo"], "numBuckets": 5, } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [ (10, 20, [(f"{alias}.foo", 1)]), (20, 30, [(f"{alias}.foo", 0)]), (30, 40, [(f"{alias}.foo", 0)]), (40, 50, [(f"{alias}.foo", 1)]), (50, 60, [(f"{alias}.foo", 2)]), ] assert response.data == self.as_response_data(expected), f"failing for {array_column}" @pytest.mark.xfail(reason="snuba does not allow - in alias names") def test_histogram_negative_values(self): # range is [-9, -4), so it is divided into 5 buckets of width 1 specs = [ (-9, -8, [("foo", 3)]), (-5, -4, [("foo", 1)]), ] self.populate_events(specs) for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo"], "numBuckets": 5, } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [ (-9, -8, [(f"{alias}.foo", 3)]), (-8, -7, [(f"{alias}.foo", 0)]), (-7, -6, [(f"{alias}.foo", 0)]), (-6, -5, [(f"{alias}.foo", 0)]), (-5, -4, [(f"{alias}.foo", 1)]), ] assert response.data == self.as_response_data(expected), f"failing for {array_column}" @pytest.mark.xfail(reason="snuba does not allow - in alias names") def test_histogram_positive_and_negative_values(self): # range is [-50, 49], so it is divided into 5 buckets of width 10 specs = [ (-50, -50, [("foo", 1)]), (-10, 10, [("foo", 2)]), (49, 49, [("foo", 1)]), ] self.populate_events(specs) for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo"], "numBuckets": 5, } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [ (-50, -30, [(f"{alias}.foo", 1)]), (-30, -10, [(f"{alias}.foo", 0)]), (-10, 10, [(f"{alias}.foo", 2)]), (10, 30, [(f"{alias}.foo", 0)]), (30, 50, [(f"{alias}.foo", 1)]), ] assert response.data == self.as_response_data(expected), f"failing for {array_column}" def test_histogram_increased_precision(self): # range is [1.00, 2.24], so it is divided into 5 buckets of width 0.25 specs = [ (1.00, 1.00, [("foo", 3)]), (2.24, 2.24, [("foo", 1)]), ] self.populate_events(specs) for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo"], "numBuckets": 5, "precision": 2, } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [ (1.00, 1.25, [(f"{alias}.foo", 3)]), (1.25, 1.50, [(f"{alias}.foo", 0)]), (1.50, 1.75, [(f"{alias}.foo", 0)]), (1.75, 2.00, [(f"{alias}.foo", 0)]), (2.00, 2.25, [(f"{alias}.foo", 1)]), ] assert response.data == self.as_response_data(expected), f"failing for {array_column}" def test_histogram_increased_precision_with_min_max(self): # range is [1.25, 2.24], so it is divided into 5 buckets of width 0.25 specs = [ (1.00, 1.25, [("foo", 3)]), (2.00, 2.25, [("foo", 1)]), ] self.populate_events(specs) for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo"], "numBuckets": 3, "precision": 2, "min": 1.25, "max": 2.00, } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [ (1.25, 1.50, [(f"{alias}.foo", 0)]), (1.50, 1.75, [(f"{alias}.foo", 0)]), (1.75, 2.00, [(f"{alias}.foo", 0)]), ] assert response.data == self.as_response_data(expected), f"failing for {array_column}" def test_histogram_increased_precision_large_buckets(self): # range is [10.0000, 59.9999] so it is divided into 5 buckets of width 10 specs = [ (10.0000, 10.0000, [("foo", 1)]), (30.0000, 40.0000, [("foo", 1)]), (59.9999, 59.9999, [("foo", 2)]), ] self.populate_events(specs) for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo"], "numBuckets": 5, "precision": 4, } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [ (10.0000, 20.0000, [(f"{alias}.foo", 1)]), (20.0000, 30.0000, [(f"{alias}.foo", 0)]), (30.0000, 40.0000, [(f"{alias}.foo", 1)]), (40.0000, 50.0000, [(f"{alias}.foo", 0)]), (50.0000, 60.0000, [(f"{alias}.foo", 2)]), ] assert response.data == self.as_response_data(expected), f"failing for {array_column}" def test_histogram_multiple_measures(self): # range is [10, 59] so it is divided into 5 buckets of width 10 specs = [ (10, 10, [("bar", 0), ("baz", 0), ("foo", 1)]), (30, 40, [("bar", 2), ("baz", 0), ("foo", 0)]), (59, 59, [("bar", 0), ("baz", 1), ("foo", 0)]), ] self.populate_events(specs) for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.bar", f"{alias}.baz", f"{alias}.foo"], "numBuckets": 5, } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [ ( 10, 20, [ (f"{alias}.bar", 0), (f"{alias}.baz", 0), (f"{alias}.foo", 1), ], ), ( 20, 30, [ (f"{alias}.bar", 0), (f"{alias}.baz", 0), (f"{alias}.foo", 0), ], ), ( 30, 40, [ (f"{alias}.bar", 2), (f"{alias}.baz", 0), (f"{alias}.foo", 0), ], ), ( 40, 50, [ (f"{alias}.bar", 0), (f"{alias}.baz", 0), (f"{alias}.foo", 0), ], ), ( 50, 60, [ (f"{alias}.bar", 0), (f"{alias}.baz", 1), (f"{alias}.foo", 0), ], ), ] assert response.data == self.as_response_data(expected), f"failing for {array_column}" def test_histogram_max_value_on_edge(self): # range is [11, 21] so it is divided into 5 buckets of width 5 # because using buckets of width 2 will exclude 21, and the next # nice number is 5 specs = [ (11, 11, [("bar", 0), ("baz", 0), ("foo", 1)]), (21, 21, [("bar", 1), ("baz", 1), ("foo", 1)]), ] self.populate_events(specs) for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.bar", f"{alias}.baz", f"{alias}.foo"], "numBuckets": 5, } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [ ( 10, 15, [ (f"{alias}.bar", 0), (f"{alias}.baz", 0), (f"{alias}.foo", 1), ], ), ( 15, 20, [ (f"{alias}.bar", 0), (f"{alias}.baz", 0), (f"{alias}.foo", 0), ], ), ( 20, 25, [ (f"{alias}.bar", 1), (f"{alias}.baz", 1), (f"{alias}.foo", 1), ], ), ] assert response.data == self.as_response_data(expected), f"failing for {array_column}" def test_histogram_bins_exceed_max(self): specs = [ (10, 15, [("bar", 0), ("baz", 0), ("foo", 1)]), (30, 30, [("bar", 1), ("baz", 1), ("foo", 1)]), ] self.populate_events(specs) for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.bar", f"{alias}.baz", f"{alias}.foo"], "numBuckets": 5, "min": 10, "max": 21, } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [ ( 10, 15, [ (f"{alias}.bar", 0), (f"{alias}.baz", 0), (f"{alias}.foo", 1), ], ), ( 15, 20, [ (f"{alias}.bar", 0), (f"{alias}.baz", 0), (f"{alias}.foo", 0), ], ), ( 20, 25, [ (f"{alias}.bar", 0), (f"{alias}.baz", 0), (f"{alias}.foo", 0), ], ), ] assert response.data == self.as_response_data(expected), f"failing for {array_column}" def test_bad_params_invalid_data_filter(self): for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo", f"{alias}.bar"], "numBuckets": 10, "dataFilter": "invalid", } response = self.do_request(query) assert response.status_code == 400, f"failing for {array_column}" assert response.data == { "dataFilter": ['"invalid" is not a valid choice.'], }, f"failing for {array_column}" def test_histogram_all_data_filter(self): specs = [ (0, 1, [("foo", 4)]), (4000, 5000, [("foo", 1)]), ] self.populate_events(specs) for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo"], "numBuckets": 5, "dataFilter": "all", } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [ (0, 1000, [(f"{alias}.foo", 4)]), (1000, 2000, [(f"{alias}.foo", 0)]), (2000, 3000, [(f"{alias}.foo", 0)]), (3000, 4000, [(f"{alias}.foo", 0)]), (4000, 5000, [(f"{alias}.foo", 1)]), ] assert response.data == self.as_response_data(expected), f"failing for {array_column}" def test_histogram_exclude_outliers_data_filter(self): specs = [ (0, 0, [("foo", 4)]), (4000, 4001, [("foo", 1)]), ] self.populate_events(specs) for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo"], "numBuckets": 5, "dataFilter": "exclude_outliers", } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [ (0, 1, [(f"{alias}.foo", 4)]), ] assert response.data == self.as_response_data(expected), f"failing for {array_column}" def test_histogram_missing_measurement_data(self): # make sure there is at least one transaction specs = [ (0, 1, [("foo", 1)]), ] self.populate_events(specs) for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], # make sure to query a measurement that does not exist "field": [f"{alias}.bar"], "numBuckets": 5, "dataFilter": "exclude_outliers", } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [ (0, 1, [(f"{alias}.bar", 0)]), (1, 1, [(f"{alias}.bar", 0)]), (2, 2, [(f"{alias}.bar", 0)]), (3, 3, [(f"{alias}.bar", 0)]), (4, 4, [(f"{alias}.bar", 0)]), ] assert response.data == self.as_response_data(expected), f"failing for {array_column}" def test_histogram_missing_measurement_data_with_explicit_bounds(self): # make sure there is at least one transaction specs = [ (0, 1, [("foo", 1)]), ] self.populate_events(specs) for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], # make sure to query a measurement that does not exist "field": [f"{alias}.bar"], "numBuckets": 5, "dataFilter": "exclude_outliers", "min": 10, } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [ (10, 11, [(f"{alias}.bar", 0)]), (11, 11, [(f"{alias}.bar", 0)]), (12, 12, [(f"{alias}.bar", 0)]), (13, 13, [(f"{alias}.bar", 0)]), (14, 14, [(f"{alias}.bar", 0)]), ] assert response.data == self.as_response_data(expected), f"failing for {array_column}" def test_histogram_ignores_aggregate_conditions(self): # range is [0, 5), so it is divided into 5 buckets of width 1 specs = [ (0, 1, [("foo", 1)]), (1, 2, [("foo", 1)]), (2, 3, [("foo", 1)]), (3, 4, [("foo", 0)]), (4, 5, [("foo", 1)]), ] self.populate_events(specs) for array_column in ARRAY_COLUMNS: alias = get_array_column_alias(array_column) query = { "project": [self.project.id], "field": [f"{alias}.foo"], "numBuckets": 5, "query": "tpm():>0.001", } response = self.do_request(query) assert response.status_code == 200, f"failing for {array_column}" expected = [ (0, 1, [(f"{alias}.foo", 1)]), (1, 2, [(f"{alias}.foo", 1)]), (2, 3, [(f"{alias}.foo", 1)]), (3, 4, [(f"{alias}.foo", 0)]), (4, 5, [(f"{alias}.foo", 1)]), ] assert response.data == self.as_response_data(expected), f"failing for {array_column}" def test_histogram_outlier_filtering_with_no_rows(self): query = { "project": [self.project.id], "field": ["transaction.duration"], "numBuckets": 5, "dataFilter": "exclude_outliers", } response = self.do_request(query) assert response.status_code == 200 expected = [ (0, 1, [("transaction.duration", 0)]), ] assert response.data == self.as_response_data(expected) class OrganizationEventsMetricsEnhancedPerformanceHistogramEndpointTest( MetricsEnhancedPerformanceTestCase ): def setUp(self): super().setUp() self.min_ago = iso_format(before_now(minutes=1)) self.features = {} def populate_events(self, specs): start = before_now(minutes=5) for spec in specs: spec = HistogramSpec(*spec) for suffix_key, count in spec.fields: for i in range(count): self.store_transaction_metric( (spec.end + spec.start) / 2, metric=suffix_key, tags={"transaction": suffix_key, **spec.tags}, timestamp=start, aggregation_option=AggregationOption.HIST, ) def as_response_data(self, specs): data: dict[str, list[dict[str, int]]] = {} for spec in specs: spec = HistogramSpec(*spec) for measurement, count in sorted(spec.fields): if measurement not in data: data[measurement] = [] data[measurement].append({"bin": spec.start, "count": count}) return data def do_request(self, query, features=None): if features is None: features = { "organizations:performance-view": True, "organizations:performance-use-metrics": True, } features.update(self.features) self.login_as(user=self.user) url = reverse( "sentry-api-0-organization-events-histogram", kwargs={"organization_id_or_slug": self.organization.slug}, ) with self.feature(features): return self.client.get(url, query, format="json") def test_no_projects(self): response = self.do_request({}) assert response.status_code == 200, response.content assert response.data == {} def test_histogram_simple(self): specs = [ (0, 1, [("transaction.duration", 5)]), (1, 2, [("transaction.duration", 10)]), (2, 3, [("transaction.duration", 1)]), (4, 5, [("transaction.duration", 15)]), ] self.populate_events(specs) query = { "project": [self.project.id], "field": ["transaction.duration"], "numBuckets": 5, "dataset": "metrics", } response = self.do_request(query) assert response.status_code == 200, response.content expected = [ (0, 1, [("transaction.duration", 6)]), (1, 2, [("transaction.duration", 9)]), (2, 3, [("transaction.duration", 3)]), (3, 4, [("transaction.duration", 8)]), (4, 5, [("transaction.duration", 7)]), ] # Note metrics data is approximate, these values are based on running the test and asserting the results expected_response = self.as_response_data(expected) expected_response["meta"] = {"isMetricsData": True} assert response.data == expected_response def test_multi_histogram(self): specs = [ (0, 1, [("measurements.fcp", 5), ("measurements.lcp", 5)]), (1, 2, [("measurements.fcp", 5), ("measurements.lcp", 5)]), ] self.populate_events(specs) query = { "project": [self.project.id], "field": ["measurements.fcp", "measurements.lcp"], "numBuckets": 2, "dataset": "metrics", } response = self.do_request(query) assert response.status_code == 200, response.content expected = [ (0, 1, [("measurements.fcp", 5), ("measurements.lcp", 5)]), (1, 2, [("measurements.fcp", 5), ("measurements.lcp", 5)]), ] # Note metrics data is approximate, these values are based on running the test and asserting the results expected_response = self.as_response_data(expected) expected_response["meta"] = {"isMetricsData": True} assert response.data == expected_response def test_histogram_exclude_outliers_data_filter(self): specs = [ (0, 0, [("transaction.duration", 4)], {"histogram_outlier": "inlier"}), (1, 1, [("transaction.duration", 4)], {"histogram_outlier": "inlier"}), (4000, 4001, [("transaction.duration", 1)], {"histogram_outlier": "outlier"}), ] self.populate_events(specs) query = { "project": [self.project.id], "field": ["transaction.duration"], "numBuckets": 5, "dataFilter": "exclude_outliers", "dataset": "metrics", } response = self.do_request(query) assert response.status_code == 200, response.content # Metrics approximation means both buckets got merged expected = [ (0, 0, [("transaction.duration", 8)]), (1, 2, [("transaction.duration", 0)]), ] expected_response = self.as_response_data(expected) expected_response["meta"] = {"isMetricsData": True} assert response.data == expected_response class OrganizationEventsMetricsEnhancedPerformanceHistogramEndpointTestWithMetricLayer( OrganizationEventsMetricsEnhancedPerformanceHistogramEndpointTest ): def setUp(self): super().setUp() self.features["organizations:use-metrics-layer"] = True