import math
import uuid
from datetime import timedelta, timezone
from unittest import mock
import pytest
from django.test import override_settings
from django.urls import reverse
from django.utils import timezone as django_timezone
from snuba_sdk.column import Column
from snuba_sdk.function import Function
from sentry.discover.models import TeamKeyTransaction
from sentry.issues.grouptype import ProfileFileIOGroupType
from sentry.models.group import GroupStatus
from sentry.models.projectteam import ProjectTeam
from sentry.models.releaseprojectenvironment import ReleaseStages
from sentry.models.transaction_threshold import (
ProjectTransactionThreshold,
ProjectTransactionThresholdOverride,
TransactionMetric,
)
from sentry.search.events import constants
from sentry.testutils.cases import (
APITestCase,
PerformanceIssueTestCase,
ProfilesSnubaTestCase,
SnubaTestCase,
)
from sentry.testutils.helpers import parse_link_header
from sentry.testutils.helpers.datetime import before_now, freeze_time, iso_format
from sentry.testutils.silo import region_silo_test
from sentry.testutils.skips import requires_not_arm64
from sentry.types.group import GroupSubStatus
from sentry.utils import json
from sentry.utils.samples import load_data
from tests.sentry.issues.test_utils import SearchIssueTestMixin
MAX_QUERYABLE_TRANSACTION_THRESHOLDS = 1
class OrganizationEventsEndpointTestBase(APITestCase, SnubaTestCase):
viewname = "sentry-api-0-organization-events"
referrer = "api.organization-events"
def setUp(self):
super().setUp()
self.nine_mins_ago = before_now(minutes=9)
self.ten_mins_ago = before_now(minutes=10)
self.ten_mins_ago_iso = iso_format(self.ten_mins_ago)
self.eleven_mins_ago = before_now(minutes=11)
self.eleven_mins_ago_iso = iso_format(self.eleven_mins_ago)
self.transaction_data = load_data("transaction", timestamp=self.ten_mins_ago)
self.features = {}
def client_get(self, *args, **kwargs):
return self.client.get(*args, **kwargs)
def reverse_url(self):
return reverse(
self.viewname,
kwargs={"organization_slug": self.organization.slug},
)
def do_request(self, query, features=None, **kwargs):
if features is None:
features = {"organizations:discover-basic": True}
features.update(self.features)
self.login_as(user=self.user)
with self.feature(features):
return self.client_get(self.reverse_url(), query, format="json", **kwargs)
def load_data(self, platform="transaction", timestamp=None, duration=None, **kwargs):
if timestamp is None:
timestamp = self.ten_mins_ago
min_age = before_now(minutes=10)
if timestamp > min_age:
# Sentry does some rounding of timestamps to improve cache hits in snuba.
# This can result in events not being returns if the timestamps
# are too recent.
raise Exception(
f"Please define a timestamp older than 10 minutes to avoid flakey tests. Want a timestamp before {min_age}, got: {timestamp} "
)
start_timestamp = None
if duration is not None:
start_timestamp = timestamp - duration
start_timestamp = start_timestamp - timedelta(
microseconds=start_timestamp.microsecond % 1000
)
return load_data(platform, timestamp=timestamp, start_timestamp=start_timestamp, **kwargs)
@region_silo_test
class OrganizationEventsEndpointTest(OrganizationEventsEndpointTestBase, PerformanceIssueTestCase):
def test_no_projects(self):
response = self.do_request({})
assert response.status_code == 200, response.content
assert response.data["data"] == []
assert response.data["meta"] == {
"tips": {"query": "Need at least one valid project to query."}
}
def test_environment_filter(self):
self.create_environment(self.project, name="production")
self.store_event(
data={
"event_id": "a" * 32,
"environment": "staging",
"timestamp": self.ten_mins_ago_iso,
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "b" * 32,
"environment": "production",
"timestamp": self.ten_mins_ago_iso,
},
project_id=self.project.id,
)
query = {
"field": ["id", "project.id"],
"project": [self.project.id],
"environment": ["staging", "production"],
}
response = self.do_request(query)
assert response.status_code == 200
assert len(response.data["data"]) == 2
def test_performance_view_feature(self):
self.store_event(
data={
"event_id": "a" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group1"],
},
project_id=self.project.id,
)
query = {"field": ["id", "project.id"], "project": [self.project.id]}
response = self.do_request(query)
assert response.status_code == 200
assert len(response.data["data"]) == 1
def test_multi_project_feature_gate_rejection(self):
team = self.create_team(organization=self.organization, members=[self.user])
project = self.create_project(organization=self.organization, teams=[team])
project2 = self.create_project(organization=self.organization, teams=[team])
query = {"field": ["id", "project.id"], "project": [project.id, project2.id]}
response = self.do_request(query)
assert response.status_code == 400
assert "events from multiple projects" in response.data["detail"]
def test_multi_project_feature_gate_replays(self):
team = self.create_team(organization=self.organization, members=[self.user])
project = self.create_project(organization=self.organization, teams=[team])
project2 = self.create_project(organization=self.organization, teams=[team])
query = {"field": ["id", "project.id"], "project": [project.id, project2.id]}
response = self.do_request(query, **{"HTTP_X-Sentry-Replay-Request": "1"})
assert response.status_code == 200
def test_invalid_search_terms(self):
self.create_project()
query = {"field": ["id"], "query": "hi \n there"}
response = self.do_request(query)
assert response.status_code == 400, response.content
assert (
response.data["detail"]
== "Parse error at 'hi \n ther' (column 4). This is commonly caused by unmatched parentheses. Enclose any text in double quotes."
)
def test_invalid_trace_span(self):
self.create_project()
query = {"field": ["id"], "query": "trace.span:invalid"}
response = self.do_request(query)
assert response.status_code == 400, response.content
assert (
response.data["detail"]
== "trace.span must be a valid 16 character hex (containing only digits, or a-f characters)"
)
query = {"field": ["id"], "query": "trace.parent_span:invalid"}
response = self.do_request(query)
assert response.status_code == 400, response.content
assert (
response.data["detail"]
== "trace.parent_span must be a valid 16 character hex (containing only digits, or a-f characters)"
)
query = {"field": ["id"], "query": "trace.span:*"}
response = self.do_request(query)
assert response.status_code == 400, response.content
assert (
response.data["detail"] == "Wildcard conditions are not permitted on `trace.span` field"
)
query = {"field": ["id"], "query": "trace.parent_span:*"}
response = self.do_request(query)
assert response.status_code == 400, response.content
assert (
response.data["detail"]
== "Wildcard conditions are not permitted on `trace.parent_span` field"
)
def test_has_trace_context(self):
self.store_event(
data={
"event_id": "a" * 32,
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"contexts": {
"trace": {
"span_id": "a" * 16,
"trace_id": "b" * 32,
},
},
},
project_id=self.project.id,
)
query = {"field": ["id", "trace.parent_span"], "query": "has:trace.span"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["id"] == "a" * 32
query = {"field": ["id"], "query": "has:trace.parent_span"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 0
def test_treat_status_as_tag_discover_transaction(self):
event_1 = self.store_event(
data={
"event_id": "a" * 32,
"environment": "staging",
"timestamp": self.ten_mins_ago_iso,
"tags": {"status": "good"},
},
project_id=self.project.id,
)
event_2 = self.store_event(
data={
"event_id": "b" * 32,
"environment": "staging",
"timestamp": self.ten_mins_ago_iso,
"tags": {"status": "bad"},
},
project_id=self.project.id,
)
query = {
"field": ["event_id"],
"query": "!status:good",
"dataset": "discover",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert response.data["data"] == [
{"event_id": "", "id": event_2.event_id, "project.name": self.project.slug}
]
query = {"field": ["event_id"], "query": ["status:good"], "dataset": "discover"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert response.data["data"] == [
{"event_id": "", "id": event_1.event_id, "project.name": self.project.slug}
]
def test_not_has_trace_context(self):
self.store_event(
data={
"event_id": "a" * 32,
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"contexts": {
"trace": {
"span_id": "a" * 16,
"trace_id": "b" * 32,
},
},
},
project_id=self.project.id,
)
query = {"field": ["id", "trace.parent_span"], "query": "!has:trace.span"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 0
query = {"field": ["id"], "query": "!has:trace.parent_span"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["id"] == "a" * 32
def test_parent_span_id_in_context(self):
self.store_event(
data={
"event_id": "a" * 32,
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"contexts": {
"trace": {
"span_id": "a" * 16,
"trace_id": "b" * 32,
"parent_span_id": "c" * 16,
},
},
},
project_id=self.project.id,
)
query = {"field": ["id"], "query": f"trace.parent_span:{'c' * 16}"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["id"] == "a" * 32
def test_out_of_retention(self):
self.create_project()
with self.options({"system.event-retention-days": 10}):
query = {
"field": ["id", "timestamp"],
"orderby": ["-timestamp", "-id"],
"start": iso_format(before_now(days=20)),
"end": iso_format(before_now(days=15)),
}
response = self.do_request(query)
assert response.status_code == 400, response.content
assert response.data["detail"] == "Invalid date range. Please try a more recent date range."
def test_raw_data(self):
self.store_event(
data={
"event_id": "a" * 32,
"environment": "staging",
"timestamp": self.eleven_mins_ago_iso,
"user": {"ip_address": "127.0.0.1", "email": "foo@example.com"},
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "b" * 32,
"environment": "staging",
"timestamp": self.ten_mins_ago_iso,
"user": {"ip_address": "127.0.0.1", "email": "foo@example.com"},
},
project_id=self.project.id,
)
query = {
"field": ["id", "project.id", "user.email", "user.ip", "timestamp"],
"orderby": "-timestamp",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 2
assert data[0]["id"] == "b" * 32
assert data[0]["project.id"] == self.project.id
assert data[0]["user.email"] == "foo@example.com"
assert "project.name" not in data[0], "project.id does not auto select name"
assert "project" not in data[0]
meta = response.data["meta"]
field_meta = meta["fields"]
assert field_meta["id"] == "string"
assert field_meta["user.email"] == "string"
assert field_meta["user.ip"] == "string"
assert field_meta["timestamp"] == "date"
def test_project_name(self):
self.store_event(
data={
"event_id": "a" * 32,
"environment": "staging",
"timestamp": self.ten_mins_ago_iso,
},
project_id=self.project.id,
)
query = {"field": ["project.name", "environment"]}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["project.name"] == self.project.slug
assert "project.id" not in response.data["data"][0]
assert response.data["data"][0]["environment"] == "staging"
def test_project_without_name(self):
self.store_event(
data={
"event_id": "a" * 32,
"environment": "staging",
"timestamp": self.ten_mins_ago_iso,
},
project_id=self.project.id,
)
query = {"field": ["project", "environment"]}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["project"] == self.project.slug
assert response.data["meta"]["fields"]["project"] == "string"
assert "project.id" not in response.data["data"][0]
assert response.data["data"][0]["environment"] == "staging"
def test_project_in_query(self):
self.store_event(
data={
"event_id": "a" * 32,
"environment": "staging",
"timestamp": self.ten_mins_ago_iso,
},
project_id=self.project.id,
)
query = {
"field": ["project", "count()"],
"query": f'project:"{self.project.slug}"',
"statsPeriod": "14d",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["project"] == self.project.slug
assert "project.id" not in response.data["data"][0]
def test_project_in_query_not_in_header(self):
project = self.create_project()
other_project = self.create_project()
self.store_event(
data={
"event_id": "a" * 32,
"environment": "staging",
"timestamp": self.ten_mins_ago_iso,
},
project_id=project.id,
)
query = {
"field": ["project", "count()"],
"query": 'project:"%s"' % project.slug,
"statsPeriod": "14d",
"project": other_project.id,
}
response = self.do_request(query)
assert response.status_code == 400, response.content
assert (
response.data["detail"]
== f"Invalid query. Project(s) {project.slug} do not exist or are not actively selected."
)
def test_project_in_query_does_not_exist(self):
self.create_project()
query = {"field": ["project", "count()"], "query": "project:morty", "statsPeriod": "14d"}
response = self.do_request(query)
assert response.status_code == 400, response.content
assert (
response.data["detail"]
== "Invalid query. Project(s) morty do not exist or are not actively selected."
)
def test_not_project_in_query_but_in_header(self):
team = self.create_team(organization=self.organization, members=[self.user])
project = self.create_project(organization=self.organization, teams=[team])
project2 = self.create_project(organization=self.organization, teams=[team])
self.store_event(
data={
"event_id": "a" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group1"],
},
project_id=project.id,
)
self.store_event(
data={
"event_id": "b" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group2"],
},
project_id=project2.id,
)
query = {
"field": ["id", "project.id"],
"project": [project.id],
"query": f"!project:{project2.slug}",
}
response = self.do_request(query)
assert response.status_code == 200
assert response.data["data"] == [{"id": "a" * 32, "project.id": project.id}]
def test_not_project_in_query_with_all_projects(self):
team = self.create_team(organization=self.organization, members=[self.user])
project = self.create_project(organization=self.organization, teams=[team])
project2 = self.create_project(organization=self.organization, teams=[team])
self.store_event(
data={
"event_id": "a" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group1"],
},
project_id=project.id,
)
self.store_event(
data={
"event_id": "b" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group2"],
},
project_id=project2.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["id", "project.id"],
"project": [-1],
"query": f"!project:{project2.slug}",
}
response = self.do_request(query, features=features)
assert response.status_code == 200
assert response.data["data"] == [{"id": "a" * 32, "project.id": project.id}]
def test_project_condition_used_for_automatic_filters(self):
self.store_event(
data={
"event_id": "a" * 32,
"environment": "staging",
"timestamp": self.ten_mins_ago_iso,
},
project_id=self.project.id,
)
query = {
"field": ["project", "count()"],
"query": f'project:"{self.project.slug}"',
"statsPeriod": "14d",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["project"] == self.project.slug
assert "project.id" not in response.data["data"][0]
def test_auto_insert_project_name_when_event_id_present(self):
self.store_event(
data={
"event_id": "a" * 32,
"environment": "staging",
"timestamp": self.ten_mins_ago_iso,
},
project_id=self.project.id,
)
query = {"field": ["id"], "statsPeriod": "1h"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert response.data["data"] == [{"project.name": self.project.slug, "id": "a" * 32}]
def test_auto_insert_project_name_when_event_id_present_with_aggregate(self):
self.store_event(
data={
"event_id": "a" * 32,
"environment": "staging",
"timestamp": self.ten_mins_ago_iso,
},
project_id=self.project.id,
)
query = {"field": ["id", "count()"], "statsPeriod": "1h"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert response.data["data"] == [
{"project.name": self.project.slug, "id": "a" * 32, "count()": 1}
]
def test_performance_short_group_id(self):
event = self.create_performance_issue()
query = {
"field": ["count()"],
"statsPeriod": "1h",
"query": f"project:{event.group.project.slug} issue:{event.group.qualified_short_id}",
"dataset": "issuePlatform",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert response.data["data"][0]["count()"] == 1
def test_multiple_performance_short_group_ids_filter(self):
event1 = self.create_performance_issue()
event2 = self.create_performance_issue()
query = {
"field": ["count()"],
"statsPeriod": "1h",
"query": f"project:{event1.group.project.slug} issue:[{event1.group.qualified_short_id},{event2.group.qualified_short_id}]",
"dataset": "issuePlatform",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert response.data["data"][0]["count()"] == 2
def test_event_id_with_in_search(self):
self.store_event(
data={
"event_id": "a" * 32,
"environment": "staging1",
"timestamp": self.ten_mins_ago_iso,
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "b" * 32,
"environment": "staging2",
"timestamp": self.ten_mins_ago_iso,
},
project_id=self.project.id,
)
# Should not show up
self.store_event(
data={
"event_id": "c" * 32,
"environment": "staging3",
"timestamp": self.ten_mins_ago_iso,
},
project_id=self.project.id,
)
query = {
"field": ["id", "environment"],
"statsPeriod": "1h",
"query": f"id:[{'a' * 32}, {'b' * 32}]",
"orderby": "environment",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 2
assert response.data["data"][0]["id"] == "a" * 32
assert response.data["data"][1]["id"] == "b" * 32
def test_user_search(self):
self.transaction_data["user"] = {
"email": "foo@example.com",
"id": "123",
"ip_address": "127.0.0.1",
"username": "foo",
}
self.store_event(self.transaction_data, project_id=self.project.id)
fields = {
"email": "user.email",
"id": "user.id",
"ip_address": "user.ip",
"username": "user.username",
}
features = {"organizations:discover-basic": True, "organizations:global-views": True}
for key, value in self.transaction_data["user"].items():
field = fields[key]
query = {
"field": ["project", "user"],
"query": f"{field}:{value}",
"statsPeriod": "14d",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["project"] == self.project.slug
assert response.data["data"][0]["user"] == "id:123"
def test_has_user(self):
self.store_event(self.transaction_data, project_id=self.project.id)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
for value in self.transaction_data["user"].values():
query = {"field": ["project", "user"], "query": "has:user", "statsPeriod": "14d"}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["user"] == "ip:{}".format(
self.transaction_data["user"]["ip_address"]
)
def test_team_param_no_access(self):
org = self.create_organization(
owner=self.user, # use other user as owner
name="foo",
flags=0, # disable default allow_joinleave
)
project = self.create_project(name="baz", organization=org)
user = self.create_user()
self.login_as(user=user, superuser=False)
team = self.create_team(organization=org, name="Team Bar")
project.add_team(team)
self.store_event(
data={
"event_id": "a" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group1"],
},
project_id=project.id,
)
query = {"field": ["id", "project.id"], "project": [project.id], "team": [team.id]}
response = self.do_request(query)
assert response.status_code == 403, response.content
assert response.data["detail"] == "You do not have permission to perform this action."
def test_team_is_nan(self):
query = {"field": ["id"], "project": [self.project.id], "team": [math.nan]}
response = self.do_request(query)
assert response.status_code == 400, response.content
assert response.data["detail"] == "Invalid Team ID: nan"
def test_comparison_operators_on_numeric_field(self):
event = self.store_event(
{"timestamp": iso_format(before_now(minutes=1))}, project_id=self.project.id
)
query = {"field": ["issue"], "query": f"issue.id:>{event.group.id - 1}"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["issue"] == event.group.qualified_short_id
query = {"field": ["issue"], "query": f"issue.id:>{event.group.id}"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 0
def test_negation_on_numeric_field_excludes_issue(self):
event = self.store_event({"timestamp": self.ten_mins_ago_iso}, project_id=self.project.id)
query = {"field": ["issue"], "query": f"issue.id:{event.group.id}"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["issue"] == event.group.qualified_short_id
query = {"field": ["issue"], "query": f"!issue.id:{event.group.id}"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 0
def test_negation_on_numeric_in_filter_excludes_issue(self):
event = self.store_event({"timestamp": self.ten_mins_ago_iso}, project_id=self.project.id)
query = {"field": ["issue"], "query": f"issue.id:[{event.group.id}]"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["issue"] == event.group.qualified_short_id
query = {"field": ["issue"], "query": f"!issue.id:[{event.group.id}]"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 0
def test_negation_on_duration_filter_excludes_transaction(self):
event = self.store_event(self.transaction_data, project_id=self.project.id)
duration = int(event.data.get("timestamp") - event.data.get("start_timestamp")) * 1000
query = {"field": ["transaction"], "query": f"transaction.duration:{duration}"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["id"] == event.event_id
query = {"field": ["transaction"], "query": f"!transaction.duration:{duration}"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 0
def test_has_issue(self):
event = self.store_event({"timestamp": self.ten_mins_ago_iso}, project_id=self.project.id)
self.store_event(self.transaction_data, project_id=self.project.id)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
# should only show 1 event of type default
query = {"field": ["project", "issue"], "query": "has:issue", "statsPeriod": "14d"}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["issue"] == event.group.qualified_short_id
# should only show 1 event of type default
query = {
"field": ["project", "issue"],
"query": "event.type:default has:issue",
"statsPeriod": "14d",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["issue"] == event.group.qualified_short_id
# should show no results because no the default event has an issue
query = {
"field": ["project", "issue"],
"query": "event.type:default !has:issue",
"statsPeriod": "14d",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 0
# should show no results because no transactions have issues
query = {
"field": ["project", "issue"],
"query": "event.type:transaction has:issue",
"statsPeriod": "14d",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 0
# should only show 1 event of type transaction since they don't have issues
query = {
"field": ["project", "issue"],
"query": "event.type:transaction !has:issue",
"statsPeriod": "14d",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["issue"] == "unknown"
@pytest.mark.skip("Cannot look up group_id of transaction events")
def test_unknown_issue(self):
event = self.store_event({"timestamp": self.ten_mins_ago_iso}, project_id=self.project.id)
self.store_event(self.transaction_data, project_id=self.project.id)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {"field": ["project", "issue"], "query": "issue:unknown", "statsPeriod": "14d"}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["issue"] == "unknown"
query = {"field": ["project", "issue"], "query": "!issue:unknown", "statsPeriod": "14d"}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["issue"] == event.group.qualified_short_id
def test_negative_user_search(self):
user_data = {"email": "foo@example.com", "id": "123", "username": "foo"}
# Load an event with data that shouldn't match
data = self.transaction_data.copy()
data["transaction"] = "/transactions/nomatch"
event_user = user_data.copy()
event_user["id"] = "undefined"
data["user"] = event_user
self.store_event(data, project_id=self.project.id)
# Load a matching event
data = self.transaction_data.copy()
data["transaction"] = "/transactions/matching"
data["user"] = user_data
self.store_event(data, project_id=self.project.id)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["project", "user"],
"query": '!user:"id:undefined"',
"statsPeriod": "14d",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["user"] == "id:{}".format(user_data["id"])
assert "user.email" not in response.data["data"][0]
assert "user.id" not in response.data["data"][0]
def test_not_project_in_query(self):
project1 = self.create_project()
project2 = self.create_project()
self.store_event(
data={
"event_id": "a" * 32,
"environment": "staging",
"timestamp": self.ten_mins_ago_iso,
},
project_id=project1.id,
)
self.store_event(
data={
"event_id": "b" * 32,
"environment": "staging",
"timestamp": self.ten_mins_ago_iso,
},
project_id=project2.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["project", "count()"],
"query": '!project:"%s"' % project1.slug,
"statsPeriod": "14d",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["project"] == project2.slug
assert "project.id" not in response.data["data"][0]
def test_error_handled_condition(self):
prototype = self.load_data(platform="android-ndk")
events = (
("a" * 32, "not handled", False),
("b" * 32, "was handled", True),
("c" * 32, "undefined", None),
)
for event in events:
prototype["event_id"] = event[0]
prototype["message"] = event[1]
prototype["exception"]["values"][0]["value"] = event[1]
prototype["exception"]["values"][0]["mechanism"]["handled"] = event[2]
prototype["timestamp"] = self.ten_mins_ago_iso
self.store_event(data=prototype, project_id=self.project.id)
with self.feature("organizations:discover-basic"):
query = {
"field": ["message", "error.handled"],
"query": "error.handled:0",
"orderby": "message",
}
response = self.do_request(query)
assert response.status_code == 200, response.data
assert 1 == len(response.data["data"])
assert 0 == response.data["data"][0]["error.handled"]
with self.feature("organizations:discover-basic"):
query = {
"field": ["message", "error.handled"],
"query": "error.handled:1",
"orderby": "message",
}
response = self.do_request(query)
assert response.status_code == 200, response.data
assert 2 == len(response.data["data"])
assert 1 == response.data["data"][0]["error.handled"]
assert 1 == response.data["data"][1]["error.handled"]
def test_error_unhandled_condition(self):
prototype = self.load_data(platform="android-ndk")
events = (
("a" * 32, "not handled", False),
("b" * 32, "was handled", True),
("c" * 32, "undefined", None),
)
for event in events:
prototype["event_id"] = event[0]
prototype["message"] = event[1]
prototype["exception"]["values"][0]["value"] = event[1]
prototype["exception"]["values"][0]["mechanism"]["handled"] = event[2]
prototype["timestamp"] = self.ten_mins_ago_iso
self.store_event(data=prototype, project_id=self.project.id)
with self.feature("organizations:discover-basic"):
query = {
"field": ["message", "error.unhandled", "error.handled"],
"query": "error.unhandled:true",
"orderby": "message",
}
response = self.do_request(query)
assert response.status_code == 200, response.data
assert 1 == len(response.data["data"])
assert 0 == response.data["data"][0]["error.handled"]
assert 1 == response.data["data"][0]["error.unhandled"]
with self.feature("organizations:discover-basic"):
query = {
"field": ["message", "error.handled", "error.unhandled"],
"query": "error.unhandled:false",
"orderby": "message",
}
response = self.do_request(query)
assert response.status_code == 200, response.data
assert 2 == len(response.data["data"])
assert 1 == response.data["data"][0]["error.handled"]
assert 0 == response.data["data"][0]["error.unhandled"]
assert 1 == response.data["data"][1]["error.handled"]
assert 0 == response.data["data"][1]["error.unhandled"]
def test_groupby_error_handled_and_unhandled(self):
prototype = self.load_data(platform="android-ndk")
events = (
("a" * 32, "not handled", False),
("b" * 32, "was handled", True),
("c" * 32, "undefined", None),
)
for event in events:
prototype["event_id"] = event[0]
prototype["message"] = event[1]
prototype["exception"]["values"][0]["value"] = event[1]
prototype["exception"]["values"][0]["mechanism"]["handled"] = event[2]
prototype["timestamp"] = self.ten_mins_ago_iso
self.store_event(data=prototype, project_id=self.project.id)
with self.feature("organizations:discover-basic"):
query = {
"field": ["error.handled", "count()"],
"query": "event.type:error",
}
response = self.do_request(query)
assert response.status_code == 200, response.data
assert 2 == len(response.data["data"])
assert 0 == response.data["data"][0]["error.handled"]
assert 1 == response.data["data"][0]["count()"]
assert 1 == response.data["data"][1]["error.handled"]
assert 2 == response.data["data"][1]["count()"]
with self.feature("organizations:discover-basic"):
query = {
"field": ["error.unhandled", "count()"],
"query": "event.type:error",
}
response = self.do_request(query)
assert response.status_code == 200, response.data
assert 2 == len(response.data["data"])
assert 0 == response.data["data"][0]["error.unhandled"]
assert 2 == response.data["data"][0]["count()"]
assert 1 == response.data["data"][1]["error.unhandled"]
assert 1 == response.data["data"][1]["count()"]
def test_error_main_thread_condition(self):
prototype = self.load_data(platform="android-ndk")
prototype["timestamp"] = self.ten_mins_ago_iso
self.store_event(data=prototype, project_id=self.project.id)
with self.feature("organizations:discover-basic"):
query = {
"field": ["id", "project.id"],
"query": "error.main_thread:true",
"project": [self.project.id],
}
response = self.do_request(query)
assert response.status_code == 200, response.data
assert 1 == len(response.data["data"])
with self.feature("organizations:discover-basic"):
query = {
"field": ["id", "project.id"],
"query": "error.main_thread:false",
"project": [self.project.id],
}
response = self.do_request(query)
assert response.status_code == 200, response.data
assert 0 == len(response.data["data"])
def test_implicit_groupby(self):
self.store_event(
data={
"event_id": "a" * 32,
"timestamp": self.eleven_mins_ago_iso,
"fingerprint": ["group_1"],
},
project_id=self.project.id,
)
event1 = self.store_event(
data={
"event_id": "b" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_1"],
},
project_id=self.project.id,
)
event2 = self.store_event(
data={
"event_id": "c" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
},
project_id=self.project.id,
)
query = {"field": ["count(id)", "project.id", "issue.id"], "orderby": "issue.id"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 2
data = response.data["data"]
assert data[0] == {
"project.id": self.project.id,
"issue.id": event1.group_id,
"count(id)": 2,
}
assert data[1] == {
"project.id": self.project.id,
"issue.id": event2.group_id,
"count(id)": 1,
}
meta = response.data["meta"]["fields"]
assert meta["count(id)"] == "integer"
def test_orderby(self):
self.store_event(
data={"event_id": "a" * 32, "timestamp": self.eleven_mins_ago_iso},
project_id=self.project.id,
)
self.store_event(
data={"event_id": "b" * 32, "timestamp": self.ten_mins_ago_iso},
project_id=self.project.id,
)
self.store_event(
data={"event_id": "c" * 32, "timestamp": self.ten_mins_ago_iso},
project_id=self.project.id,
)
query = {"field": ["id", "timestamp"], "orderby": ["-timestamp", "-id"]}
response = self.do_request(query)
assert response.status_code == 200, response.content
data = response.data["data"]
assert data[0]["id"] == "c" * 32
assert data[1]["id"] == "b" * 32
assert data[2]["id"] == "a" * 32
def test_sort_title(self):
self.store_event(
data={"event_id": "a" * 32, "message": "zlast", "timestamp": self.eleven_mins_ago_iso},
project_id=self.project.id,
)
self.store_event(
data={"event_id": "b" * 32, "message": "second", "timestamp": self.ten_mins_ago_iso},
project_id=self.project.id,
)
self.store_event(
data={"event_id": "c" * 32, "message": "first", "timestamp": self.ten_mins_ago_iso},
project_id=self.project.id,
)
query = {"field": ["id", "title"], "sort": "title"}
response = self.do_request(query)
assert response.status_code == 200, response.content
data = response.data["data"]
assert data[0]["id"] == "c" * 32
assert data[1]["id"] == "b" * 32
assert data[2]["id"] == "a" * 32
def test_sort_invalid(self):
self.create_project()
query = {"field": ["id"], "sort": "garbage"}
response = self.do_request(query)
assert response.status_code == 400
assert "sort by" in response.data["detail"]
def test_latest_release_alias(self):
event1 = self.store_event(
data={"event_id": "a" * 32, "timestamp": self.eleven_mins_ago_iso, "release": "0.8"},
project_id=self.project.id,
)
query = {"field": ["issue.id", "release"], "query": "release:latest"}
response = self.do_request(query)
assert response.status_code == 200, response.content
data = response.data["data"]
assert data[0]["issue.id"] == event1.group_id
assert data[0]["release"] == "0.8"
event2 = self.store_event(
data={"event_id": "a" * 32, "timestamp": self.ten_mins_ago_iso, "release": "0.9"},
project_id=self.project.id,
)
query = {"field": ["issue.id", "release"], "query": "release:latest"}
response = self.do_request(query)
assert response.status_code == 200, response.content
data = response.data["data"]
assert data[0]["issue.id"] == event2.group_id
assert data[0]["release"] == "0.9"
def test_semver(self):
release_1 = self.create_release(version="test@1.2.3")
release_2 = self.create_release(version="test@1.2.4")
release_3 = self.create_release(version="test@1.2.5")
release_1_e_1 = self.store_event(
data={"release": release_1.version, "timestamp": self.ten_mins_ago_iso},
project_id=self.project.id,
).event_id
release_1_e_2 = self.store_event(
data={"release": release_1.version, "timestamp": self.ten_mins_ago_iso},
project_id=self.project.id,
).event_id
release_2_e_1 = self.store_event(
data={"release": release_2.version, "timestamp": self.ten_mins_ago_iso},
project_id=self.project.id,
).event_id
release_2_e_2 = self.store_event(
data={"release": release_2.version, "timestamp": self.ten_mins_ago_iso},
project_id=self.project.id,
).event_id
release_3_e_1 = self.store_event(
data={"release": release_3.version, "timestamp": self.ten_mins_ago_iso},
project_id=self.project.id,
).event_id
release_3_e_2 = self.store_event(
data={"release": release_3.version, "timestamp": self.ten_mins_ago_iso},
project_id=self.project.id,
).event_id
query = {"field": ["id"], "query": f"{constants.SEMVER_ALIAS}:>1.2.3"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert {r["id"] for r in response.data["data"]} == {
release_2_e_1,
release_2_e_2,
release_3_e_1,
release_3_e_2,
}
query = {"field": ["id"], "query": f"{constants.SEMVER_ALIAS}:>=1.2.3"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert {r["id"] for r in response.data["data"]} == {
release_1_e_1,
release_1_e_2,
release_2_e_1,
release_2_e_2,
release_3_e_1,
release_3_e_2,
}
query = {"field": ["id"], "query": f"{constants.SEMVER_ALIAS}:<1.2.4"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert {r["id"] for r in response.data["data"]} == {
release_1_e_1,
release_1_e_2,
}
query = {"field": ["id"], "query": f"{constants.SEMVER_ALIAS}:1.2.3"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert {r["id"] for r in response.data["data"]} == {
release_1_e_1,
release_1_e_2,
}
query = {"field": ["id"], "query": f"!{constants.SEMVER_ALIAS}:1.2.3"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert {r["id"] for r in response.data["data"]} == {
release_2_e_1,
release_2_e_2,
release_3_e_1,
release_3_e_2,
}
def test_release_stage(self):
replaced_release = self.create_release(
version="replaced_release",
environments=[self.environment],
adopted=django_timezone.now(),
unadopted=django_timezone.now(),
)
adopted_release = self.create_release(
version="adopted_release",
environments=[self.environment],
adopted=django_timezone.now(),
)
self.create_release(version="not_adopted_release", environments=[self.environment])
adopted_release_e_1 = self.store_event(
data={
"release": adopted_release.version,
"timestamp": self.ten_mins_ago_iso,
"environment": self.environment.name,
},
project_id=self.project.id,
).event_id
adopted_release_e_2 = self.store_event(
data={
"release": adopted_release.version,
"timestamp": self.ten_mins_ago_iso,
"environment": self.environment.name,
},
project_id=self.project.id,
).event_id
replaced_release_e_1 = self.store_event(
data={
"release": replaced_release.version,
"timestamp": self.ten_mins_ago_iso,
"environment": self.environment.name,
},
project_id=self.project.id,
).event_id
replaced_release_e_2 = self.store_event(
data={
"release": replaced_release.version,
"timestamp": self.ten_mins_ago_iso,
"environment": self.environment.name,
},
project_id=self.project.id,
).event_id
query = {
"field": ["id"],
"query": f"{constants.RELEASE_STAGE_ALIAS}:{ReleaseStages.ADOPTED.value}",
"environment": [self.environment.name],
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert {r["id"] for r in response.data["data"]} == {
adopted_release_e_1,
adopted_release_e_2,
}
query = {
"field": ["id"],
"query": f"!{constants.RELEASE_STAGE_ALIAS}:{ReleaseStages.LOW_ADOPTION.value}",
"environment": [self.environment.name],
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert {r["id"] for r in response.data["data"]} == {
adopted_release_e_1,
adopted_release_e_2,
replaced_release_e_1,
replaced_release_e_2,
}
query = {
"field": ["id"],
"query": f"{constants.RELEASE_STAGE_ALIAS}:[{ReleaseStages.ADOPTED.value}, {ReleaseStages.REPLACED.value}]",
"environment": [self.environment.name],
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert {r["id"] for r in response.data["data"]} == {
adopted_release_e_1,
adopted_release_e_2,
replaced_release_e_1,
replaced_release_e_2,
}
def test_semver_package(self):
release_1 = self.create_release(version="test@1.2.3")
release_2 = self.create_release(version="test2@1.2.4")
release_1_e_1 = self.store_event(
data={"release": release_1.version, "timestamp": self.ten_mins_ago_iso},
project_id=self.project.id,
).event_id
release_1_e_2 = self.store_event(
data={"release": release_1.version, "timestamp": self.ten_mins_ago_iso},
project_id=self.project.id,
).event_id
release_2_e_1 = self.store_event(
data={"release": release_2.version, "timestamp": self.ten_mins_ago_iso},
project_id=self.project.id,
).event_id
query = {"field": ["id"], "query": f"{constants.SEMVER_PACKAGE_ALIAS}:test"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert {r["id"] for r in response.data["data"]} == {
release_1_e_1,
release_1_e_2,
}
query = {"field": ["id"], "query": f"{constants.SEMVER_PACKAGE_ALIAS}:test2"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert {r["id"] for r in response.data["data"]} == {
release_2_e_1,
}
def test_semver_build(self):
release_1 = self.create_release(version="test@1.2.3+123")
release_2 = self.create_release(version="test2@1.2.4+124")
release_1_e_1 = self.store_event(
data={"release": release_1.version, "timestamp": self.ten_mins_ago_iso},
project_id=self.project.id,
).event_id
release_1_e_2 = self.store_event(
data={"release": release_1.version, "timestamp": self.ten_mins_ago_iso},
project_id=self.project.id,
).event_id
release_2_e_1 = self.store_event(
data={"release": release_2.version, "timestamp": self.ten_mins_ago_iso},
project_id=self.project.id,
).event_id
query = {"field": ["id"], "query": f"{constants.SEMVER_BUILD_ALIAS}:123"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert {r["id"] for r in response.data["data"]} == {
release_1_e_1,
release_1_e_2,
}
query = {"field": ["id"], "query": f"{constants.SEMVER_BUILD_ALIAS}:124"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert {r["id"] for r in response.data["data"]} == {
release_2_e_1,
}
query = {"field": ["id"], "query": f"!{constants.SEMVER_BUILD_ALIAS}:124"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert {r["id"] for r in response.data["data"]} == {
release_1_e_1,
release_1_e_2,
}
def test_aliased_fields(self):
event1 = self.store_event(
data={
"event_id": "a" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_1"],
"user": {"email": "foo@example.com"},
},
project_id=self.project.id,
)
event2 = self.store_event(
data={
"event_id": "b" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
"user": {"email": "foo@example.com"},
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "c" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
"user": {"email": "bar@example.com"},
},
project_id=self.project.id,
)
query = {"field": ["issue.id", "count(id)", "count_unique(user)"], "orderby": "issue.id"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 2
data = response.data["data"]
assert data[0]["issue.id"] == event1.group_id
assert data[0]["count(id)"] == 1
assert data[0]["count_unique(user)"] == 1
assert "projectid" not in data[0]
assert "project.id" not in data[0]
assert data[1]["issue.id"] == event2.group_id
assert data[1]["count(id)"] == 2
assert data[1]["count_unique(user)"] == 2
def test_aggregate_field_with_dotted_param(self):
event1 = self.store_event(
data={
"event_id": "a" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_1"],
"user": {"id": "123", "email": "foo@example.com"},
},
project_id=self.project.id,
)
event2 = self.store_event(
data={
"event_id": "b" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
"user": {"id": "123", "email": "foo@example.com"},
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "c" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
"user": {"id": "456", "email": "bar@example.com"},
},
project_id=self.project.id,
)
query = {
"field": ["issue.id", "issue_title", "count(id)", "count_unique(user.email)"],
"orderby": "issue.id",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 2
data = response.data["data"]
assert data[0]["issue.id"] == event1.group_id
assert data[0]["count(id)"] == 1
assert data[0]["count_unique(user.email)"] == 1
assert "projectid" not in data[0]
assert "project.id" not in data[0]
assert data[1]["issue.id"] == event2.group_id
assert data[1]["count(id)"] == 2
assert data[1]["count_unique(user.email)"] == 2
def test_failure_rate_alias_field(self):
data = self.transaction_data.copy()
data["transaction"] = "/failure_rate/success"
self.store_event(data, project_id=self.project.id)
data = self.transaction_data.copy()
data["transaction"] = "/failure_rate/unknown"
data["contexts"]["trace"]["status"] = "unknown_error"
self.store_event(data, project_id=self.project.id)
for i in range(6):
data = self.transaction_data.copy()
data["transaction"] = f"/failure_rate/{i}"
data["contexts"]["trace"]["status"] = "unauthenticated"
self.store_event(data, project_id=self.project.id)
query = {"field": ["failure_rate()"], "query": "event.type:transaction"}
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]["failure_rate()"] == 0.75
def test_count_miserable_alias_field(self):
events = [
("one", 300),
("one", 300),
("two", 3000),
("two", 3000),
("three", 300),
("three", 3000),
]
for idx, event in enumerate(events):
data = self.load_data(
timestamp=before_now(minutes=(10 + idx)),
duration=timedelta(milliseconds=event[1]),
)
data["event_id"] = f"{idx}" * 32
data["transaction"] = f"/count_miserable/horribilis/{idx}"
data["user"] = {"email": f"{event[0]}@example.com"}
self.store_event(data, project_id=self.project.id)
query = {"field": ["count_miserable(user, 300)"], "query": "event.type:transaction"}
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]["count_miserable(user, 300)"] == 2
@mock.patch(
"sentry.search.events.fields.MAX_QUERYABLE_TRANSACTION_THRESHOLDS",
MAX_QUERYABLE_TRANSACTION_THRESHOLDS,
)
@mock.patch(
"sentry.search.events.datasets.discover.MAX_QUERYABLE_TRANSACTION_THRESHOLDS",
MAX_QUERYABLE_TRANSACTION_THRESHOLDS,
)
def test_too_many_transaction_thresholds(self):
project_transaction_thresholds = []
project_ids = []
for i in range(MAX_QUERYABLE_TRANSACTION_THRESHOLDS + 1):
project = self.create_project(name=f"bulk_txn_{i}")
project_ids.append(project.id)
project_transaction_thresholds.append(
ProjectTransactionThreshold(
organization=self.organization,
project=project,
threshold=400,
metric=TransactionMetric.LCP.value,
)
)
ProjectTransactionThreshold.objects.bulk_create(project_transaction_thresholds)
query = {
"field": [
"transaction",
"count_miserable(user)",
],
"query": "event.type:transaction",
"project": project_ids,
}
response = self.do_request(
query,
features={
"organizations:discover-basic": True,
"organizations:global-views": True,
},
)
assert response.status_code == 400
assert (
response.data["detail"]
== "Exceeded 1 configured transaction thresholds limit, try with fewer Projects."
)
def test_count_miserable_new_alias_field(self):
ProjectTransactionThreshold.objects.create(
project=self.project,
organization=self.project.organization,
threshold=400,
metric=TransactionMetric.DURATION.value,
)
events = [
("one", 400),
("one", 400),
("two", 3000),
("two", 3000),
("three", 300),
("three", 3000),
]
for idx, event in enumerate(events):
data = self.load_data(
timestamp=before_now(minutes=(10 + idx)),
duration=timedelta(milliseconds=event[1]),
)
data["event_id"] = f"{idx}" * 32
data["transaction"] = f"/count_miserable/horribilis/{event[0]}"
data["user"] = {"email": f"{idx}@example.com"}
self.store_event(data, project_id=self.project.id)
query = {
"field": [
"transaction",
"count_miserable(user)",
],
"query": "event.type:transaction",
"project": [self.project.id],
"sort": "count_miserable_user",
}
response = self.do_request(
query,
)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 3
data = response.data["data"]
assert data[0]["count_miserable(user)"] == 0
assert data[1]["count_miserable(user)"] == 1
assert data[2]["count_miserable(user)"] == 2
query["query"] = "event.type:transaction count_miserable(user):>0"
response = self.do_request(
query,
)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 2
data = response.data["data"]
assert abs(data[0]["count_miserable(user)"]) == 1
assert abs(data[1]["count_miserable(user)"]) == 2
def test_user_misery_denominator(self):
"""This is to test against a bug where the denominator of misery(total unique users) was wrong
This is because the total unique users for a LCP misery should only count users that have had a txn with lcp,
and not count all transactions (ie. uniq_if(transaction has lcp) not just uniq())
"""
ProjectTransactionThreshold.objects.create(
project=self.project,
organization=self.project.organization,
threshold=600,
metric=TransactionMetric.LCP.value,
)
lcps = [
400,
400,
300,
3000,
3000,
3000,
]
for idx, lcp in enumerate(lcps):
data = self.load_data(
timestamp=before_now(minutes=(10 + idx)),
)
data["event_id"] = f"{idx}" * 32
data["transaction"] = "/misery/new/"
data["user"] = {"email": f"{idx}@example.com"}
data["measurements"] = {
"lcp": {"value": lcp},
}
self.store_event(data, project_id=self.project.id)
# Shouldn't count towards misery
data = self.load_data(timestamp=self.ten_mins_ago, duration=timedelta(milliseconds=0))
data["transaction"] = "/misery/new/"
data["user"] = {"email": "7@example.com"}
data["measurements"] = {}
self.store_event(data, project_id=self.project.id)
query = {
"field": [
"transaction",
"user_misery()",
],
"query": "event.type:transaction",
"project": [self.project.id],
"sort": "-user_misery",
}
response = self.do_request(
query,
)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
data = response.data["data"]
# (3 frustrated + 5.8875) / (6 + 117.75)
assert abs(data[0]["user_misery()"] - 0.071818) < 0.0001
def test_user_misery_alias_field(self):
events = [
("one", 300),
("one", 300),
("two", 3000),
("two", 3000),
("three", 300),
("three", 3000),
]
for idx, event in enumerate(events):
data = self.load_data(
timestamp=before_now(minutes=(10 + idx)),
duration=timedelta(milliseconds=event[1]),
)
data["event_id"] = f"{idx}" * 32
data["transaction"] = f"/user_misery/{idx}"
data["user"] = {"email": f"{event[0]}@example.com"}
self.store_event(data, project_id=self.project.id)
query = {"field": ["user_misery(300)"], "query": "event.type:transaction"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
data = response.data["data"]
assert abs(data[0]["user_misery(300)"] - 0.0653) < 0.0001
def test_apdex_denominator_correct(self):
"""This is to test against a bug where the denominator of apdex(total count) was wrong
This is because the total_count for a LCP apdex should only count transactions that have lcp, and not count
all transactions (ie. count_if(transaction has lcp) not just count())
"""
ProjectTransactionThreshold.objects.create(
project=self.project,
organization=self.project.organization,
threshold=600,
metric=TransactionMetric.LCP.value,
)
lcps = [
400,
400,
300,
800,
3000,
3000,
3000,
]
for idx, lcp in enumerate(lcps):
data = self.load_data(
timestamp=before_now(minutes=(10 + idx)),
)
data["event_id"] = f"{idx}" * 32
data["transaction"] = "/apdex/new/"
data["user"] = {"email": f"{idx}@example.com"}
data["measurements"] = {
"lcp": {"value": lcp},
}
self.store_event(data, project_id=self.project.id)
# Shouldn't count towards apdex
data = self.load_data(
timestamp=self.ten_mins_ago,
duration=timedelta(milliseconds=0),
)
data["transaction"] = "/apdex/new/"
data["user"] = {"email": "7@example.com"}
data["measurements"] = {}
self.store_event(data, project_id=self.project.id)
query = {
"field": [
"transaction",
"apdex()",
],
"query": "event.type:transaction",
"project": [self.project.id],
"sort": "-apdex",
}
response = self.do_request(
query,
)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
data = response.data["data"]
# 3 satisfied + 1 tolerated => 3.5/7
assert data[0]["apdex()"] == 0.5
def test_apdex_new_alias_field(self):
ProjectTransactionThreshold.objects.create(
project=self.project,
organization=self.project.organization,
threshold=400,
metric=TransactionMetric.DURATION.value,
)
events = [
("one", 400),
("one", 400),
("two", 3000),
("two", 3000),
("three", 300),
("three", 3000),
]
for idx, event in enumerate(events):
data = self.load_data(
timestamp=before_now(minutes=(10 + idx)),
duration=timedelta(milliseconds=event[1]),
)
data["event_id"] = f"{idx}" * 32
data["transaction"] = f"/apdex/new/{event[0]}"
data["user"] = {"email": f"{idx}@example.com"}
self.store_event(data, project_id=self.project.id)
query = {
"field": [
"transaction",
"apdex()",
],
"query": "event.type:transaction",
"project": [self.project.id],
"sort": "-apdex",
}
response = self.do_request(
query,
)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 3
data = response.data["data"]
assert data[0]["apdex()"] == 1.0
assert data[1]["apdex()"] == 0.5
assert data[2]["apdex()"] == 0.0
query["query"] = "event.type:transaction apdex():>0.50"
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]["apdex()"] == 1.0
def test_user_misery_alias_field_with_project_threshold(self):
ProjectTransactionThreshold.objects.create(
project=self.project,
organization=self.project.organization,
threshold=400,
metric=TransactionMetric.DURATION.value,
)
events = [
("one", 400),
("one", 400),
("two", 3000),
("two", 3000),
("three", 300),
("three", 3000),
]
for idx, event in enumerate(events):
data = self.load_data(
timestamp=before_now(minutes=(10 + idx)),
duration=timedelta(milliseconds=event[1]),
)
data["event_id"] = f"{idx}" * 32
data["transaction"] = f"/count_miserable/horribilis/{event[0]}"
data["user"] = {"email": f"{idx}@example.com"}
self.store_event(data, project_id=self.project.id)
query = {
"field": [
"transaction",
"user_misery()",
],
"orderby": "user_misery()",
"query": "event.type:transaction",
"project": [self.project.id],
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 3
data = response.data["data"]
assert data[0]["user_misery()"] == pytest.approx(0.04916, rel=1e-3)
assert data[1]["user_misery()"] == pytest.approx(0.05751, rel=1e-3)
assert data[2]["user_misery()"] == pytest.approx(0.06586, rel=1e-3)
query["query"] = "event.type:transaction user_misery():>0.050"
response = self.do_request(
query,
)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 2
data = response.data["data"]
assert data[0]["user_misery()"] == pytest.approx(0.05751, rel=1e-3)
assert data[1]["user_misery()"] == pytest.approx(0.06586, rel=1e-3)
def test_user_misery_alias_field_with_transaction_threshold(self):
events = [
("one", 300),
("two", 300),
("one", 3000),
("two", 3000),
("three", 400),
("four", 4000),
]
for idx, event in enumerate(events):
data = self.load_data(
timestamp=before_now(minutes=(10 + idx)),
duration=timedelta(milliseconds=event[1]),
)
data["event_id"] = f"{idx}" * 32
data["transaction"] = f"/count_miserable/horribilis/{idx}"
data["user"] = {"email": f"{event[0]}@example.com"}
self.store_event(data, project_id=self.project.id)
if idx % 2:
ProjectTransactionThresholdOverride.objects.create(
transaction=f"/count_miserable/horribilis/{idx}",
project=self.project,
organization=self.project.organization,
threshold=100 * idx,
metric=TransactionMetric.DURATION.value,
)
query = {
"field": [
"transaction",
"user_misery()",
],
"query": "event.type:transaction",
"orderby": "transaction",
"project": [self.project.id],
}
response = self.do_request(
query,
)
assert response.status_code == 200, response.content
expected = [
("/count_miserable/horribilis/0", ["duration", 300], 0.049578),
("/count_miserable/horribilis/1", ["duration", 100], 0.049578),
("/count_miserable/horribilis/2", ["duration", 300], 0.058),
("/count_miserable/horribilis/3", ["duration", 300], 0.058),
("/count_miserable/horribilis/4", ["duration", 300], 0.049578),
("/count_miserable/horribilis/5", ["duration", 500], 0.058),
]
assert len(response.data["data"]) == 6
data = response.data["data"]
for i, record in enumerate(expected):
name, threshold_config, misery = record
assert data[i]["transaction"] == name
assert data[i]["project_threshold_config"] == threshold_config
assert data[i]["user_misery()"] == pytest.approx(misery, rel=1e-3)
query["query"] = "event.type:transaction user_misery():>0.050"
response = self.do_request(
query,
)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 3
data = response.data["data"]
assert data[0]["user_misery()"] == pytest.approx(0.058, rel=1e-3)
assert data[1]["user_misery()"] == pytest.approx(0.058, rel=1e-3)
assert data[2]["user_misery()"] == pytest.approx(0.058, rel=1e-3)
def test_user_misery_alias_field_with_transaction_threshold_and_project_threshold(self):
project = self.create_project()
ProjectTransactionThreshold.objects.create(
project=project,
organization=project.organization,
threshold=100,
metric=TransactionMetric.DURATION.value,
)
events = [
("one", 300),
("two", 300),
("one", 3000),
("two", 3000),
("three", 400),
("four", 4000),
]
for idx, event in enumerate(events):
data = self.load_data(
timestamp=before_now(minutes=(10 + idx)),
duration=timedelta(milliseconds=event[1]),
)
data["event_id"] = f"{idx}" * 32
data["transaction"] = f"/count_miserable/horribilis/{idx}"
data["user"] = {"email": f"{event[0]}@example.com"}
self.store_event(data, project_id=project.id)
if idx % 2:
ProjectTransactionThresholdOverride.objects.create(
transaction=f"/count_miserable/horribilis/{idx}",
project=project,
organization=project.organization,
threshold=100 * idx,
metric=TransactionMetric.DURATION.value,
)
project2 = self.create_project()
data = self.load_data()
data["transaction"] = "/count_miserable/horribilis/project2"
data["user"] = {"email": "project2@example.com"}
self.store_event(data, project_id=project2.id)
query = {
"field": [
"transaction",
"user_misery()",
],
"query": "event.type:transaction",
"orderby": "transaction",
"project": [project.id, project2.id],
}
response = self.do_request(
query,
features={
"organizations:discover-basic": True,
"organizations:global-views": True,
},
)
assert response.status_code == 200, response.content
expected = [
(
"/count_miserable/horribilis/0",
["duration", 100],
0.049578,
), # Uses project threshold
("/count_miserable/horribilis/1", ["duration", 100], 0.049578), # Uses txn threshold
("/count_miserable/horribilis/2", ["duration", 100], 0.058), # Uses project threshold
("/count_miserable/horribilis/3", ["duration", 300], 0.058), # Uses txn threshold
(
"/count_miserable/horribilis/4",
["duration", 100],
0.049578,
), # Uses project threshold
("/count_miserable/horribilis/5", ["duration", 500], 0.058), # Uses txn threshold
("/count_miserable/horribilis/project2", ["duration", 300], 0.058), # Uses fallback
]
assert len(response.data["data"]) == 7
data = response.data["data"]
for i, record in enumerate(expected):
name, threshold_config, misery = record
assert data[i]["transaction"] == name
assert data[i]["project_threshold_config"] == threshold_config
assert data[i]["user_misery()"] == pytest.approx(misery, rel=1e-3)
query["query"] = "event.type:transaction user_misery():>0.050"
response = self.do_request(
query,
features={
"organizations:discover-basic": True,
"organizations:global-views": True,
},
)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 4
def test_aggregation(self):
self.store_event(
data={
"event_id": "a" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_1"],
"user": {"email": "foo@example.com"},
"environment": "prod",
"tags": {"sub_customer.is-Enterprise-42": "1"},
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "b" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
"user": {"email": "foo@example.com"},
"environment": "staging",
"tags": {"sub_customer.is-Enterprise-42": "1"},
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "c" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
"user": {"email": "foo@example.com"},
"environment": "prod",
"tags": {"sub_customer.is-Enterprise-42": "0"},
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "d" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
"user": {"email": "foo@example.com"},
"environment": "prod",
"tags": {"sub_customer.is-Enterprise-42": "1"},
},
project_id=self.project.id,
)
query = {
"field": ["sub_customer.is-Enterprise-42", "count(sub_customer.is-Enterprise-42)"],
"orderby": "sub_customer.is-Enterprise-42",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 2
data = response.data["data"]
assert data[0]["count(sub_customer.is-Enterprise-42)"] == 1
assert data[1]["count(sub_customer.is-Enterprise-42)"] == 3
def test_aggregation_comparison(self):
self.store_event(
data={
"event_id": "a" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_1"],
"user": {"email": "foo@example.com"},
},
project_id=self.project.id,
)
event = self.store_event(
data={
"event_id": "b" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
"user": {"email": "foo@example.com"},
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "c" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
"user": {"email": "bar@example.com"},
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "d" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_3"],
"user": {"email": "bar@example.com"},
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "e" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_3"],
"user": {"email": "bar@example.com"},
},
project_id=self.project.id,
)
query = {
"field": ["issue.id", "count(id)", "count_unique(user)"],
"query": "count(id):>1 count_unique(user):>1",
"orderby": "issue.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]["issue.id"] == event.group_id
assert data[0]["count(id)"] == 2
assert data[0]["count_unique(user)"] == 2
def test_aggregation_alias_comparison(self):
data = self.load_data(
timestamp=self.ten_mins_ago,
duration=timedelta(seconds=5),
)
data["transaction"] = "/aggregates/1"
self.store_event(data, project_id=self.project.id)
data = self.load_data(
timestamp=self.ten_mins_ago,
duration=timedelta(seconds=3),
)
data["transaction"] = "/aggregates/2"
event = self.store_event(data, project_id=self.project.id)
query = {
"field": ["transaction", "p95()"],
"query": "event.type:transaction p95():<4000",
"orderby": ["transaction"],
}
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"] == event.transaction
assert data[0]["p95()"] == 3000
def test_auto_aggregations(self):
data = self.load_data(
timestamp=self.ten_mins_ago,
duration=timedelta(seconds=5),
)
data["transaction"] = "/aggregates/1"
self.store_event(data, project_id=self.project.id)
data = self.load_data(
timestamp=self.ten_mins_ago,
duration=timedelta(seconds=3),
)
data["transaction"] = "/aggregates/2"
event = self.store_event(data, project_id=self.project.id)
query = {
"field": ["transaction", "p75()"],
"query": "event.type:transaction p95():<4000",
"orderby": ["transaction"],
}
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"] == event.transaction
query = {
"field": ["transaction"],
"query": "event.type:transaction p95():<4000",
"orderby": ["transaction"],
}
response = self.do_request(query)
assert response.status_code == 400, response.content
def test_aggregation_comparison_with_conditions(self):
self.store_event(
data={
"event_id": "a" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_1"],
"user": {"email": "foo@example.com"},
"environment": "prod",
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "b" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
"user": {"email": "foo@example.com"},
"environment": "staging",
},
project_id=self.project.id,
)
event = self.store_event(
data={
"event_id": "c" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
"user": {"email": "foo@example.com"},
"environment": "prod",
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "d" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
"user": {"email": "foo@example.com"},
"environment": "prod",
},
project_id=self.project.id,
)
query = {
"field": ["issue.id", "count(id)"],
"query": "count(id):>1 user.email:foo@example.com environment:prod",
"orderby": "issue.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]["issue.id"] == event.group_id
assert data[0]["count(id)"] == 2
def test_aggregation_date_comparison_with_conditions(self):
event = self.store_event(
data={
"event_id": "a" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_1"],
"user": {"email": "foo@example.com"},
"environment": "prod",
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "b" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
"user": {"email": "foo@example.com"},
"environment": "staging",
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "c" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
"user": {"email": "foo@example.com"},
"environment": "prod",
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "d" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
"user": {"email": "foo@example.com"},
"environment": "prod",
},
project_id=self.project.id,
)
query = {
"field": ["issue.id", "max(timestamp)"],
"query": "max(timestamp):>1 user.email:foo@example.com environment:prod",
"orderby": "issue.id",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 2
assert response.data["meta"]["fields"]["max(timestamp)"] == "date"
data = response.data["data"]
assert data[0]["issue.id"] == event.group_id
def test_percentile_function(self):
data = self.load_data(
timestamp=self.ten_mins_ago,
duration=timedelta(seconds=5),
)
data["transaction"] = "/aggregates/1"
event1 = self.store_event(data, project_id=self.project.id)
data = self.load_data(
timestamp=self.ten_mins_ago,
duration=timedelta(seconds=3),
)
data["transaction"] = "/aggregates/2"
event2 = self.store_event(data, project_id=self.project.id)
query = {
"field": ["transaction", "percentile(transaction.duration, 0.95)"],
"query": "event.type:transaction",
"orderby": ["transaction"],
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 2
data = response.data["data"]
assert data[0]["transaction"] == event1.transaction
assert data[0]["percentile(transaction.duration, 0.95)"] == 5000
assert data[1]["transaction"] == event2.transaction
assert data[1]["percentile(transaction.duration, 0.95)"] == 3000
def test_percentile_function_as_condition(self):
data = self.load_data(
timestamp=self.ten_mins_ago,
duration=timedelta(seconds=5),
)
data["transaction"] = "/aggregates/1"
event1 = self.store_event(data, project_id=self.project.id)
data = self.load_data(
timestamp=self.ten_mins_ago,
duration=timedelta(seconds=3),
)
data["transaction"] = "/aggregates/2"
self.store_event(data, project_id=self.project.id)
query = {
"field": ["transaction", "percentile(transaction.duration, 0.95)"],
"query": "event.type:transaction percentile(transaction.duration, 0.95):>4000",
"orderby": ["transaction"],
}
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"] == event1.transaction
assert data[0]["percentile(transaction.duration, 0.95)"] == 5000
def test_epm_function(self):
data = self.load_data(
timestamp=self.ten_mins_ago,
duration=timedelta(seconds=5),
)
data["transaction"] = "/aggregates/1"
event1 = self.store_event(data, project_id=self.project.id)
data = self.load_data(
timestamp=self.ten_mins_ago,
duration=timedelta(seconds=3),
)
data["transaction"] = "/aggregates/2"
event2 = self.store_event(data, project_id=self.project.id)
query = {
"field": ["transaction", "epm()"],
"query": "event.type:transaction",
"orderby": ["transaction"],
"start": self.eleven_mins_ago_iso,
"end": iso_format(self.nine_mins_ago),
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 2
data = response.data["data"]
assert data[0]["transaction"] == event1.transaction
assert data[0]["epm()"] == 0.5
assert data[1]["transaction"] == event2.transaction
assert data[1]["epm()"] == 0.5
meta = response.data["meta"]
assert meta["fields"]["epm()"] == "rate"
assert meta["units"]["epm()"] == "1/minute"
def test_nonexistent_fields(self):
self.store_event(
data={
"event_id": "a" * 32,
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
},
project_id=self.project.id,
)
query = {"field": ["issue_world.id"]}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert response.data["data"][0]["issue_world.id"] == ""
def test_no_requested_fields_or_grouping(self):
self.store_event(
data={
"event_id": "a" * 32,
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
},
project_id=self.project.id,
)
query = {"query": "test"}
response = self.do_request(query)
assert response.status_code == 400, response.content
assert response.data["detail"] == "No columns selected"
def test_condition_on_aggregate_misses(self):
self.store_event(
data={
"event_id": "c" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
"user": {"email": "bar@example.com"},
},
project_id=self.project.id,
)
query = {"field": ["issue.id"], "query": "event_count:>0", "orderby": "issue.id"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 0
def test_next_prev_link_headers(self):
events = [("a", "group_1"), ("b", "group_2"), ("c", "group_2"), ("d", "group_2")]
for e in events:
self.store_event(
data={
"event_id": e[0] * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": [e[1]],
"user": {"email": "foo@example.com"},
"tags": {"language": "C++"},
},
project_id=self.project.id,
)
query = {
"field": ["count(id)", "issue.id", "context.key"],
"sort": "-count_id",
"query": "language:C++",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
links = parse_link_header(response["Link"])
for link in links:
assert "field=issue.id" in link
assert "field=count%28id%29" in link
assert "field=context.key" in link
assert "sort=-count_id" in link
assert "query=language%3AC%2B%2B" in link
assert len(response.data["data"]) == 2
data = response.data["data"]
assert data[0]["count(id)"] == 3
assert data[1]["count(id)"] == 1
def test_empty_count_query(self):
event = self.store_event(
data={
"event_id": "a" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["1123581321"],
"user": {"email": "foo@example.com"},
"tags": {"language": "C++"},
},
project_id=self.project.id,
)
query = {
"field": ["count()"],
"query": f"issue.id:{event.group_id} timestamp:>{self.ten_mins_ago_iso}",
"statsPeriod": "14d",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["count()"] == 0
def test_stack_wildcard_condition(self):
data = self.load_data(platform="javascript")
data["timestamp"] = self.ten_mins_ago_iso
self.store_event(data=data, project_id=self.project.id)
query = {"field": ["stack.filename", "message"], "query": "stack.filename:*.js"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["meta"]["fields"]["message"] == "string"
def test_email_wildcard_condition(self):
data = self.load_data(platform="javascript")
data["timestamp"] = self.ten_mins_ago_iso
self.store_event(data=data, project_id=self.project.id)
query = {"field": ["stack.filename", "message"], "query": "user.email:*@example.org"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["meta"]["fields"]["message"] == "string"
def test_release_wildcard_condition(self):
release = self.create_release(version="test@1.2.3+123")
self.store_event(
data={"release": release.version, "timestamp": self.ten_mins_ago_iso},
project_id=self.project.id,
)
query = {"field": ["stack.filename", "release"], "query": "release:test*"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["release"] == release.version
def test_transaction_event_type(self):
self.store_event(data=self.transaction_data, project_id=self.project.id)
query = {
"field": ["transaction", "transaction.duration", "transaction.status"],
"query": "event.type:transaction",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["meta"]["fields"]["transaction.duration"] == "duration"
assert response.data["meta"]["fields"]["transaction.status"] == "string"
assert response.data["meta"]["units"]["transaction.duration"] == "millisecond"
assert response.data["data"][0]["transaction.status"] == "ok"
def test_trace_columns(self):
self.store_event(data=self.transaction_data, project_id=self.project.id)
query = {"field": ["trace"], "query": "event.type:transaction"}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["meta"]["fields"]["trace"] == "string"
assert (
response.data["data"][0]["trace"]
== self.transaction_data["contexts"]["trace"]["trace_id"]
)
def test_issue_in_columns(self):
project1 = self.create_project()
project2 = self.create_project()
event1 = self.store_event(
data={
"event_id": "a" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_1"],
},
project_id=project1.id,
)
event2 = self.store_event(
data={
"event_id": "b" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_1"],
},
project_id=project2.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {"field": ["id", "issue"], "orderby": ["id"]}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 2
assert data[0]["id"] == event1.event_id
assert data[0]["issue.id"] == event1.group_id
assert data[0]["issue"] == event1.group.qualified_short_id
assert data[1]["id"] == event2.event_id
assert data[1]["issue.id"] == event2.group_id
assert data[1]["issue"] == event2.group.qualified_short_id
def test_issue_in_search_and_columns(self):
project1 = self.create_project()
project2 = self.create_project()
event1 = self.store_event(
data={
"event_id": "a" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_1"],
},
project_id=project1.id,
)
self.store_event(
data={
"event_id": "b" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_1"],
},
project_id=project2.id,
)
tests = [
("issue", "issue:%s" % event1.group.qualified_short_id),
("issue.id", "issue:%s" % event1.group.qualified_short_id),
("issue", "issue.id:%s" % event1.group_id),
("issue.id", "issue.id:%s" % event1.group_id),
]
features = {"organizations:discover-basic": True, "organizations:global-views": True}
for testdata in tests:
query = {"field": [testdata[0]], "query": testdata[1]}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["id"] == event1.event_id
assert data[0]["issue.id"] == event1.group_id
if testdata[0] == "issue":
assert data[0]["issue"] == event1.group.qualified_short_id
else:
assert data[0].get("issue", None) is None
def test_issue_negation(self):
project1 = self.create_project()
project2 = self.create_project()
event1 = self.store_event(
data={
"event_id": "a" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_1"],
},
project_id=project1.id,
)
event2 = self.store_event(
data={
"event_id": "b" * 32,
"transaction": "/example",
"message": "go really fast plz",
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
},
project_id=project2.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["title", "issue.id"],
"query": f"!issue:{event1.group.qualified_short_id}",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["title"] == event2.title
assert data[0]["issue.id"] == event2.group_id
def test_search_for_nonexistent_issue(self):
self.store_event(
data={
"event_id": "a" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_1"],
},
project_id=self.project.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {"field": ["count()"], "query": "issue.id:112358"}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["count()"] == 0
def test_issue_alias_inside_aggregate(self):
self.store_event(
data={
"event_id": "a" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_1"],
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "b" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
},
project_id=self.project.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["project", "count(id)", "count_unique(issue.id)", "count_unique(issue)"],
"sort": "-count(id)",
"statsPeriod": "24h",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["count(id)"] == 2
assert data[0]["count_unique(issue.id)"] == 2
assert data[0]["count_unique(issue)"] == 2
def test_project_alias_inside_aggregate(self):
project1 = self.create_project()
project2 = self.create_project()
self.store_event(
data={
"event_id": "a" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_1"],
},
project_id=project1.id,
)
self.store_event(
data={
"event_id": "b" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
},
project_id=project2.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": [
"event.type",
"count(id)",
"count_unique(project.id)",
"count_unique(project)",
],
"sort": "-count(id)",
"statsPeriod": "24h",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["count(id)"] == 2
assert data[0]["count_unique(project.id)"] == 2
assert data[0]["count_unique(project)"] == 2
def test_user_display(self):
project1 = self.create_project()
project2 = self.create_project()
self.store_event(
data={
"event_id": "a" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"user": {"email": "cathy@example.com"},
},
project_id=project1.id,
)
self.store_event(
data={
"event_id": "b" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"user": {"username": "catherine"},
},
project_id=project2.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["event.type", "user.display"],
"query": "user.display:cath*",
"statsPeriod": "24h",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 2
result = {r["user.display"] for r in data}
assert result == {"catherine", "cathy@example.com"}
def test_user_display_with_aggregates(self):
self.store_event(
data={
"event_id": "a" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"user": {"email": "cathy@example.com"},
},
project_id=self.project.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["event.type", "user.display", "count_unique(title)"],
"statsPeriod": "24h",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
result = {r["user.display"] for r in data}
assert result == {"cathy@example.com"}
query = {"field": ["event.type", "count_unique(user.display)"], "statsPeriod": "24h"}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["count_unique(user.display)"] == 1
def test_orderby_user_display(self):
project1 = self.create_project()
project2 = self.create_project()
self.store_event(
data={
"event_id": "a" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"user": {"email": "cathy@example.com"},
},
project_id=project1.id,
)
self.store_event(
data={
"event_id": "b" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"user": {"username": "catherine"},
},
project_id=project2.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["event.type", "user.display"],
"query": "user.display:cath*",
"statsPeriod": "24h",
"orderby": "-user.display",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 2
result = [r["user.display"] for r in data]
# because we're ordering by `-user.display`, we expect the results in reverse sorted order
assert result == ["cathy@example.com", "catherine"]
def test_orderby_user_display_with_aggregates(self):
project1 = self.create_project()
project2 = self.create_project()
self.store_event(
data={
"event_id": "a" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"user": {"email": "cathy@example.com"},
},
project_id=project1.id,
)
self.store_event(
data={
"event_id": "b" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"user": {"username": "catherine"},
},
project_id=project2.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["event.type", "user.display", "count_unique(title)"],
"query": "user.display:cath*",
"statsPeriod": "24h",
"orderby": "user.display",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 2
result = [r["user.display"] for r in data]
# because we're ordering by `user.display`, we expect the results in sorted order
assert result == ["catherine", "cathy@example.com"]
def test_any_field_alias(self):
day_ago = before_now(days=1).replace(hour=10, minute=11, second=12, microsecond=13)
self.store_event(
data={
"event_id": "a" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": iso_format(day_ago),
"user": {"email": "cathy@example.com"},
},
project_id=self.project.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": [
"event.type",
"any(user.display)",
"any(timestamp.to_day)",
"any(timestamp.to_hour)",
],
"statsPeriod": "7d",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
result = {r["any(user.display)"] for r in data}
assert result == {"cathy@example.com"}
result = {r["any(timestamp.to_day)"][:19] for r in data}
assert result == {iso_format(day_ago.replace(hour=0, minute=0, second=0, microsecond=0))}
result = {r["any(timestamp.to_hour)"][:19] for r in data}
assert result == {iso_format(day_ago.replace(minute=0, second=0, microsecond=0))}
def test_field_aliases_in_conflicting_functions(self):
self.store_event(
data={
"event_id": "a" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": iso_format(
before_now(days=1).replace(hour=10, minute=11, second=12, microsecond=13)
),
"user": {"email": "cathy@example.com"},
},
project_id=self.project.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
field_aliases = ["user.display", "timestamp.to_day", "timestamp.to_hour"]
for alias in field_aliases:
query = {
"field": [alias, f"any({alias})"],
"statsPeriod": "7d",
}
response = self.do_request(query, features=features)
assert response.status_code == 400, response.content
assert (
response.data["detail"]
== f"A single field cannot be used both inside and outside a function in the same query. To use {alias} you must first remove the function(s): any({alias})"
)
@pytest.mark.skip(
"""
For some reason ClickHouse errors when there are two of the same string literals
(in this case the empty string "") in a query and one is in the prewhere clause.
Does not affect production or ClickHouse versions > 20.4.
"""
)
def test_has_message(self):
event = self.store_event(
{"timestamp": self.ten_mins_ago_iso, "message": "a"}, project_id=self.project.id
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {"field": ["project", "message"], "query": "has:message", "statsPeriod": "14d"}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["message"] == event.message
query = {"field": ["project", "message"], "query": "!has:message", "statsPeriod": "14d"}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 0
def test_has_transaction_status(self):
self.store_event(self.transaction_data, project_id=self.project.id)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["event.type", "count(id)"],
"query": "event.type:transaction has:transaction.status",
"sort": "-count(id)",
"statsPeriod": "24h",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["count(id)"] == 1
@pytest.mark.xfail(reason="Started failing on ClickHouse 21.8")
def test_not_has_transaction_status(self):
self.store_event(self.transaction_data, project_id=self.project.id)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["event.type", "count(id)"],
"query": "event.type:transaction !has:transaction.status",
"sort": "-count(id)",
"statsPeriod": "24h",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["count(id)"] == 0
def test_tag_that_looks_like_aggregation(self):
data = {
"message": "Failure state",
"timestamp": self.ten_mins_ago_iso,
"tags": {"count_diff": 99},
}
self.store_event(data, project_id=self.project.id)
query = {
"field": ["message", "count_diff", "count()"],
"query": "",
"project": [self.project.id],
"statsPeriod": "24h",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
meta = response.data["meta"]["fields"]
assert "string" == meta["count_diff"], "tags should not be counted as integers"
assert "string" == meta["message"]
assert "integer" == meta["count()"]
assert 1 == len(response.data["data"])
data = response.data["data"][0]
assert "99" == data["count_diff"]
assert "Failure state" == data["message"]
assert 1 == data["count()"]
def test_aggregate_negation(self):
data = self.load_data(
timestamp=self.ten_mins_ago,
duration=timedelta(seconds=5),
)
self.store_event(data, project_id=self.project.id)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["event.type", "count()"],
"query": "event.type:transaction count():1",
"statsPeriod": "24h",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
query = {
"field": ["event.type", "count()"],
"query": "event.type:transaction !count():1",
"statsPeriod": "24h",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 0
def test_all_aggregates_in_columns(self):
data = self.load_data(
timestamp=self.eleven_mins_ago,
duration=timedelta(seconds=5),
)
data["transaction"] = "/failure_rate/1"
self.store_event(data, project_id=self.project.id)
data = self.load_data(
timestamp=self.ten_mins_ago,
duration=timedelta(seconds=5),
)
data["transaction"] = "/failure_rate/1"
data["contexts"]["trace"]["status"] = "unauthenticated"
event = self.store_event(data, project_id=self.project.id)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": [
"event.type",
"p50()",
"p75()",
"p95()",
"p99()",
"p100()",
"percentile(transaction.duration, 0.99)",
"apdex(300)",
"count_miserable(user, 300)",
"user_misery(300)",
"failure_rate()",
],
"query": "event.type:transaction",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
meta = response.data["meta"]["fields"]
units = response.data["meta"]["units"]
assert meta["p50()"] == "duration"
assert meta["p75()"] == "duration"
assert meta["p95()"] == "duration"
assert meta["p99()"] == "duration"
assert meta["p100()"] == "duration"
assert meta["percentile(transaction.duration, 0.99)"] == "duration"
assert meta["apdex(300)"] == "number"
assert meta["failure_rate()"] == "percentage"
assert meta["user_misery(300)"] == "number"
assert meta["count_miserable(user, 300)"] == "integer"
assert units["p50()"] == "millisecond"
assert units["p75()"] == "millisecond"
assert units["p95()"] == "millisecond"
assert units["p99()"] == "millisecond"
assert units["p100()"] == "millisecond"
assert units["percentile(transaction.duration, 0.99)"] == "millisecond"
data = response.data["data"]
assert len(data) == 1
assert data[0]["p50()"] == 5000
assert data[0]["p75()"] == 5000
assert data[0]["p95()"] == 5000
assert data[0]["p99()"] == 5000
assert data[0]["p100()"] == 5000
assert data[0]["percentile(transaction.duration, 0.99)"] == 5000
assert data[0]["apdex(300)"] == 0.0
assert data[0]["count_miserable(user, 300)"] == 1
assert data[0]["user_misery(300)"] == 0.058
assert data[0]["failure_rate()"] == 0.5
features = {
"organizations:discover-basic": True,
"organizations:global-views": True,
}
query = {
"field": [
"event.type",
"p50()",
"p75()",
"p95()",
"p99()",
"p100()",
"percentile(transaction.duration, 0.99)",
"apdex(300)",
"apdex()",
"count_miserable(user, 300)",
"user_misery(300)",
"failure_rate()",
"count_miserable(user)",
"user_misery()",
],
"query": "event.type:transaction",
"project": [self.project.id],
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
meta = response.data["meta"]["fields"]
units = response.data["meta"]["units"]
assert meta["p50()"] == "duration"
assert meta["p75()"] == "duration"
assert meta["p95()"] == "duration"
assert meta["p99()"] == "duration"
assert meta["p100()"] == "duration"
assert meta["percentile(transaction.duration, 0.99)"] == "duration"
assert meta["apdex(300)"] == "number"
assert meta["apdex()"] == "number"
assert meta["failure_rate()"] == "percentage"
assert meta["user_misery(300)"] == "number"
assert meta["count_miserable(user, 300)"] == "integer"
assert meta["project_threshold_config"] == "string"
assert meta["user_misery()"] == "number"
assert meta["count_miserable(user)"] == "integer"
assert units["p50()"] == "millisecond"
assert units["p75()"] == "millisecond"
assert units["p95()"] == "millisecond"
assert units["p99()"] == "millisecond"
assert units["p100()"] == "millisecond"
assert units["percentile(transaction.duration, 0.99)"] == "millisecond"
data = response.data["data"]
assert len(data) == 1
assert data[0]["p50()"] == 5000
assert data[0]["p75()"] == 5000
assert data[0]["p95()"] == 5000
assert data[0]["p99()"] == 5000
assert data[0]["p100()"] == 5000
assert data[0]["percentile(transaction.duration, 0.99)"] == 5000
assert data[0]["apdex(300)"] == 0.0
assert data[0]["apdex()"] == 0.0
assert data[0]["count_miserable(user, 300)"] == 1
assert data[0]["user_misery(300)"] == 0.058
assert data[0]["failure_rate()"] == 0.5
assert data[0]["project_threshold_config"] == ["duration", 300]
assert data[0]["user_misery()"] == 0.058
assert data[0]["count_miserable(user)"] == 1
query = {
"field": ["event.type", "last_seen()", "latest_event()"],
"query": "event.type:transaction",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert self.ten_mins_ago_iso[:-5] in data[0]["last_seen()"]
assert data[0]["latest_event()"] == event.event_id
query = {
"field": [
"event.type",
"count()",
"count(id)",
"count_unique(project)",
"min(transaction.duration)",
"max(transaction.duration)",
"avg(transaction.duration)",
"stddev(transaction.duration)",
"var(transaction.duration)",
"cov(transaction.duration, transaction.duration)",
"corr(transaction.duration, transaction.duration)",
"linear_regression(transaction.duration, transaction.duration)",
"sum(transaction.duration)",
],
"query": "event.type:transaction",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["count()"] == 2
assert data[0]["count(id)"] == 2
assert data[0]["count_unique(project)"] == 1
assert data[0]["min(transaction.duration)"] == 5000
assert data[0]["max(transaction.duration)"] == 5000
assert data[0]["avg(transaction.duration)"] == 5000
assert data[0]["stddev(transaction.duration)"] == 0.0
assert data[0]["var(transaction.duration)"] == 0.0
assert data[0]["cov(transaction.duration, transaction.duration)"] == 0.0
assert data[0]["corr(transaction.duration, transaction.duration)"] == 0.0
assert data[0]["linear_regression(transaction.duration, transaction.duration)"] == [0, 0]
assert data[0]["sum(transaction.duration)"] == 10000
@requires_not_arm64
def test_null_user_misery_returns_zero(self):
self.transaction_data["user"] = None
self.transaction_data["transaction"] = "/no_users/1"
self.store_event(self.transaction_data, project_id=self.project.id)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["user_misery(300)"],
"query": "event.type:transaction",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
meta = response.data["meta"]["fields"]
assert meta["user_misery(300)"] == "number"
data = response.data["data"]
assert data[0]["user_misery(300)"] == 0
@requires_not_arm64
def test_null_user_misery_new_returns_zero(self):
self.transaction_data["user"] = None
self.transaction_data["transaction"] = "/no_users/1"
self.store_event(self.transaction_data, project_id=self.project.id)
features = {
"organizations:discover-basic": True,
}
query = {
"field": ["user_misery()"],
"query": "event.type:transaction",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
meta = response.data["meta"]["fields"]
assert meta["user_misery()"] == "number"
data = response.data["data"]
assert data[0]["user_misery()"] == 0
def test_all_aggregates_in_query(self):
data = self.load_data(
timestamp=self.eleven_mins_ago,
duration=timedelta(seconds=5),
)
data["transaction"] = "/failure_rate/1"
self.store_event(data, project_id=self.project.id)
data = self.load_data(
timestamp=self.ten_mins_ago,
duration=timedelta(seconds=5),
)
data["transaction"] = "/failure_rate/2"
data["contexts"]["trace"]["status"] = "unauthenticated"
self.store_event(data, project_id=self.project.id)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": [
"event.type",
"p50()",
"p75()",
"p95()",
"percentile(transaction.duration, 0.99)",
"p100()",
],
"query": "event.type:transaction p50():>100 p75():>1000 p95():>1000 p100():>1000 percentile(transaction.duration, 0.99):>1000",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["p50()"] == 5000
assert data[0]["p75()"] == 5000
assert data[0]["p95()"] == 5000
assert data[0]["p100()"] == 5000
assert data[0]["percentile(transaction.duration, 0.99)"] == 5000
query = {
"field": [
"event.type",
"apdex(300)",
"count_miserable(user, 300)",
"user_misery(300)",
"failure_rate()",
],
"query": "event.type:transaction apdex(300):>-1.0 failure_rate():>0.25",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["apdex(300)"] == 0.0
assert data[0]["count_miserable(user, 300)"] == 1
assert data[0]["user_misery(300)"] == 0.058
assert data[0]["failure_rate()"] == 0.5
query = {
"field": ["event.type", "last_seen()", "latest_event()"],
"query": "event.type:transaction last_seen():>1990-12-01T00:00:00",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
query = {
"field": ["event.type", "count()", "count(id)", "count_unique(transaction)"],
"query": "event.type:transaction count():>1 count(id):>1 count_unique(transaction):>1",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["count()"] == 2
assert data[0]["count(id)"] == 2
assert data[0]["count_unique(transaction)"] == 2
query = {
"field": [
"event.type",
"min(transaction.duration)",
"max(transaction.duration)",
"avg(transaction.duration)",
"sum(transaction.duration)",
"stddev(transaction.duration)",
"var(transaction.duration)",
"cov(transaction.duration, transaction.duration)",
"corr(transaction.duration, transaction.duration)",
],
"query": " ".join(
[
"event.type:transaction",
"min(transaction.duration):>1000",
"max(transaction.duration):>1000",
"avg(transaction.duration):>1000",
"sum(transaction.duration):>1000",
"stddev(transaction.duration):>=0.0",
"var(transaction.duration):>=0.0",
"cov(transaction.duration, transaction.duration):>=0.0",
# correlation is nan because variance is 0
# "corr(transaction.duration, transaction.duration):>=0.0",
]
),
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["min(transaction.duration)"] == 5000
assert data[0]["max(transaction.duration)"] == 5000
assert data[0]["avg(transaction.duration)"] == 5000
assert data[0]["sum(transaction.duration)"] == 10000
assert data[0]["stddev(transaction.duration)"] == 0.0
assert data[0]["var(transaction.duration)"] == 0.0
assert data[0]["cov(transaction.duration, transaction.duration)"] == 0.0
assert data[0]["corr(transaction.duration, transaction.duration)"] == 0.0
query = {
"field": ["event.type", "apdex(400)"],
"query": "event.type:transaction apdex(400):0",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["apdex(400)"] == 0
def test_functions_in_orderby(self):
data = self.load_data(
timestamp=self.eleven_mins_ago,
duration=timedelta(seconds=5),
)
data["transaction"] = "/failure_rate/1"
self.store_event(data, project_id=self.project.id)
data = self.load_data(
timestamp=self.ten_mins_ago,
duration=timedelta(seconds=5),
)
data["transaction"] = "/failure_rate/2"
data["contexts"]["trace"]["status"] = "unauthenticated"
event = self.store_event(data, project_id=self.project.id)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["event.type", "p75()"],
"sort": "-p75",
"query": "event.type:transaction",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["p75()"] == 5000
query = {
"field": ["event.type", "percentile(transaction.duration, 0.99)"],
"sort": "-percentile_transaction_duration_0_99",
"query": "event.type:transaction",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["percentile(transaction.duration, 0.99)"] == 5000
query = {
"field": ["event.type", "apdex(300)"],
"sort": "-apdex(300)",
"query": "event.type:transaction",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["apdex(300)"] == 0.0
query = {
"field": ["event.type", "latest_event()"],
"query": "event.type:transaction",
"sort": "latest_event",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["latest_event()"] == event.event_id
query = {
"field": ["event.type", "count_unique(transaction)"],
"query": "event.type:transaction",
"sort": "-count_unique_transaction",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["count_unique(transaction)"] == 2
query = {
"field": ["event.type", "min(transaction.duration)"],
"query": "event.type:transaction",
"sort": "-min_transaction_duration",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["min(transaction.duration)"] == 5000
def test_issue_alias_in_aggregate(self):
self.store_event(
data={
"event_id": "a" * 32,
"timestamp": self.eleven_mins_ago_iso,
"fingerprint": ["group_1"],
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "b" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
},
project_id=self.project.id,
)
query = {"field": ["event.type", "count_unique(issue)"], "query": "count_unique(issue):>1"}
features = {"organizations:discover-basic": True, "organizations:global-views": True}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["count_unique(issue)"] == 2
def test_deleted_issue_in_results(self):
event1 = self.store_event(
data={
"event_id": "a" * 32,
"timestamp": self.eleven_mins_ago_iso,
"fingerprint": ["group_1"],
},
project_id=self.project.id,
)
event2 = self.store_event(
data={
"event_id": "b" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
},
project_id=self.project.id,
)
event2.group.delete()
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {"field": ["issue", "count()"], "sort": "issue.id"}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 2
assert data[0]["issue"] == event1.group.qualified_short_id
assert data[1]["issue"] == "unknown"
def test_last_seen_negative_duration(self):
self.store_event(
data={
"event_id": "f" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_1"],
},
project_id=self.project.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {"field": ["id", "last_seen()"], "query": "last_seen():-30d"}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["id"] == "f" * 32
def test_last_seen_aggregate_condition(self):
self.store_event(
data={
"event_id": "f" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_1"],
},
project_id=self.project.id,
)
query = {
"field": ["id", "last_seen()"],
"query": f"last_seen():>{iso_format(before_now(days=30))}",
}
features = {"organizations:discover-basic": True, "organizations:global-views": True}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["id"] == "f" * 32
def test_conditional_filter(self):
for v in ["a", "b"]:
self.store_event(
data={
"event_id": v * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_1"],
},
project_id=self.project.id,
)
query = {
"field": ["id"],
"query": "id:{} OR id:{}".format("a" * 32, "b" * 32),
"orderby": "id",
}
features = {"organizations:discover-basic": True, "organizations:global-views": True}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 2
assert data[0]["id"] == "a" * 32
assert data[1]["id"] == "b" * 32
def test_aggregation_comparison_with_conditional_filter(self):
self.store_event(
data={
"event_id": "a" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_1"],
"user": {"email": "foo@example.com"},
"environment": "prod",
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "b" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
"user": {"email": "foo@example.com"},
"environment": "staging",
},
project_id=self.project.id,
)
event = self.store_event(
data={
"event_id": "c" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
"user": {"email": "foo@example.com"},
"environment": "prod",
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "d" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
"user": {"email": "foo@example.com"},
"environment": "canary",
},
project_id=self.project.id,
)
query = {
"field": ["issue.id", "count(id)"],
"query": "count(id):>1 user.email:foo@example.com AND (environment:prod OR environment:staging)",
"orderby": "issue.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]["issue.id"] == event.group_id
assert data[0]["count(id)"] == 2
def run_test_in_query(self, query, expected_events, expected_negative_events=None):
params = {
"field": ["id"],
"query": query,
"orderby": "id",
}
response = self.do_request(
params, {"organizations:discover-basic": True, "organizations:global-views": True}
)
assert response.status_code == 200, response.content
assert [row["id"] for row in response.data["data"]] == [e.event_id for e in expected_events]
if expected_negative_events is not None:
params["query"] = f"!{query}"
response = self.do_request(
params,
{"organizations:discover-basic": True, "organizations:global-views": True},
)
assert response.status_code == 200, response.content
assert [row["id"] for row in response.data["data"]] == [
e.event_id for e in expected_negative_events
]
def test_in_query_events(self):
project_1 = self.create_project()
event_1 = self.store_event(
data={
"event_id": "a" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_1"],
"message": "group1",
"user": {"email": "hello@example.com"},
"environment": "prod",
"tags": {"random": "123"},
"release": "1.0",
},
project_id=project_1.id,
)
project_2 = self.create_project()
event_2 = self.store_event(
data={
"event_id": "b" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_2"],
"message": "group2",
"user": {"email": "bar@example.com"},
"environment": "staging",
"tags": {"random": "456"},
"stacktrace": {"frames": [{"filename": "src/app/group2.py"}]},
"release": "1.2",
},
project_id=project_2.id,
)
project_3 = self.create_project()
event_3 = self.store_event(
data={
"event_id": "c" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_3"],
"message": "group3",
"user": {"email": "foo@example.com"},
"environment": "canary",
"tags": {"random": "789"},
},
project_id=project_3.id,
)
self.run_test_in_query("environment:[prod, staging]", [event_1, event_2], [event_3])
self.run_test_in_query("environment:[staging]", [event_2], [event_1, event_3])
self.run_test_in_query(
"user.email:[foo@example.com, hello@example.com]", [event_1, event_3], [event_2]
)
self.run_test_in_query("user.email:[foo@example.com]", [event_3], [event_1, event_2])
self.run_test_in_query(
"user.display:[foo@example.com, hello@example.com]", [event_1, event_3], [event_2]
)
self.run_test_in_query(
'message:["group2 src/app/group2.py in ?", group1]', [event_1, event_2], [event_3]
)
self.run_test_in_query(
f"issue.id:[{event_1.group_id},{event_2.group_id}]", [event_1, event_2]
)
self.run_test_in_query(
f"issue:[{event_1.group.qualified_short_id},{event_2.group.qualified_short_id}]",
[event_1, event_2],
)
self.run_test_in_query(
f"issue:[{event_1.group.qualified_short_id},{event_2.group.qualified_short_id}, unknown]",
[event_1, event_2],
)
self.run_test_in_query(f"project_id:[{project_3.id},{project_2.id}]", [event_2, event_3])
self.run_test_in_query(
f"project.name:[{project_3.slug},{project_2.slug}]", [event_2, event_3]
)
self.run_test_in_query("random:[789,456]", [event_2, event_3], [event_1])
self.run_test_in_query("tags[random]:[789,456]", [event_2, event_3], [event_1])
self.run_test_in_query("release:[1.0,1.2]", [event_1, event_2], [event_3])
def test_in_query_events_stack(self):
test_js = self.store_event(
self.load_data(
platform="javascript",
timestamp=self.ten_mins_ago,
duration=timedelta(seconds=5),
),
project_id=self.project.id,
)
test_java = self.store_event(
self.load_data(
platform="java",
timestamp=self.ten_mins_ago,
duration=timedelta(seconds=5),
),
project_id=self.project.id,
)
self.run_test_in_query(
"stack.filename:[../../sentry/scripts/views.js]", [test_js], [test_java]
)
def test_in_query_transactions(self):
data = self.transaction_data.copy()
data["event_id"] = "a" * 32
data["contexts"]["trace"]["status"] = "ok"
transaction_1 = self.store_event(data, project_id=self.project.id)
data = self.transaction_data.copy()
data["event_id"] = "b" * 32
data["contexts"]["trace"]["status"] = "aborted"
transaction_2 = self.store_event(data, project_id=self.project.id)
data = self.transaction_data.copy()
data["event_id"] = "c" * 32
data["contexts"]["trace"]["status"] = "already_exists"
transaction_3 = self.store_event(data, project_id=self.project.id)
self.run_test_in_query(
"transaction.status:[aborted, already_exists]",
[transaction_2, transaction_3],
[transaction_1],
)
def test_messed_up_function_values(self):
# TODO (evanh): It would be nice if this surfaced an error to the user.
# The problem: The && causes the parser to treat that term not as a bad
# function call but a valid raw search with parens in it. It's not trivial
# to change the parser to recognize "bad function values" and surface them.
for v in ["a", "b"]:
self.store_event(
data={
"event_id": v * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group_1"],
},
project_id=self.project.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": [
"transaction",
"project",
"epm()",
"p50()",
"p95()",
"failure_rate()",
"apdex(300)",
"count_unique(user)",
"user_misery(300)",
"count_miserable(user, 300)",
],
"query": "failure_rate():>0.003&& users:>10 event.type:transaction",
"sort": "-failure_rate",
"statsPeriod": "24h",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 0
def test_context_fields_between_datasets(self):
event_data = self.load_data(platform="android")
transaction_data = self.load_data()
event_data["spans"] = transaction_data["spans"]
event_data["contexts"]["trace"] = transaction_data["contexts"]["trace"]
event_data["type"] = "transaction"
event_data["transaction"] = "/failure_rate/1"
event_data["timestamp"] = iso_format(self.ten_mins_ago)
event_data["start_timestamp"] = iso_format(before_now(minutes=10, seconds=5))
event_data["user"]["geo"] = {"country_code": "US", "region": "CA", "city": "San Francisco"}
self.store_event(event_data, project_id=self.project.id)
event_data["type"] = "error"
self.store_event(event_data, project_id=self.project.id)
fields = [
"os.build",
"os.kernel_version",
"device.arch",
# TODO: battery level is not consistent across both datasets
# "device.battery_level",
"device.brand",
"device.charging",
"device.locale",
"device.model_id",
"device.name",
"device.online",
"device.orientation",
"device.simulator",
"device.uuid",
]
data = [
{"field": fields + ["location", "count()"], "query": "event.type:error"},
{"field": fields + ["duration", "count()"], "query": "event.type:transaction"},
]
for datum in data:
response = self.do_request(datum)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1, datum
results = response.data["data"]
assert results[0]["count()"] == 1, datum
for field in fields:
key, value = field.split(".", 1)
expected = str(event_data["contexts"][key][value])
assert results[0][field] == expected, field + str(datum)
def test_http_fields_between_datasets(self):
event_data = self.load_data(platform="android")
transaction_data = self.load_data()
event_data["spans"] = transaction_data["spans"]
event_data["contexts"]["trace"] = transaction_data["contexts"]["trace"]
event_data["type"] = "transaction"
event_data["transaction"] = "/failure_rate/1"
event_data["timestamp"] = iso_format(self.ten_mins_ago)
event_data["start_timestamp"] = iso_format(before_now(minutes=10, seconds=5))
event_data["user"]["geo"] = {"country_code": "US", "region": "CA", "city": "San Francisco"}
event_data["request"] = transaction_data["request"]
self.store_event(event_data, project_id=self.project.id)
event_data["type"] = "error"
self.store_event(event_data, project_id=self.project.id)
fields = ["http.method", "http.referer", "http.url"]
expected = ["GET", "fixtures.transaction", "http://countries:8010/country_by_code/"]
data = [
{"field": fields + ["location", "count()"], "query": "event.type:error"},
{"field": fields + ["duration", "count()"], "query": "event.type:transaction"},
]
for datum in data:
response = self.do_request(datum)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1, datum
results = response.data["data"]
assert results[0]["count()"] == 1, datum
for field, exp in zip(fields, expected):
assert results[0][field] == exp, field + str(datum)
def test_failure_count_alias_field(self):
data = self.transaction_data.copy()
data["transaction"] = "/failure_count/success"
self.store_event(data, project_id=self.project.id)
data = self.transaction_data.copy()
data["transaction"] = "/failure_count/unknown"
data["contexts"]["trace"]["status"] = "unknown_error"
self.store_event(data, project_id=self.project.id)
for i in range(6):
data = self.transaction_data.copy()
data["transaction"] = f"/failure_count/{i}"
data["contexts"]["trace"]["status"] = "unauthenticated"
self.store_event(data, project_id=self.project.id)
query = {"field": ["count()", "failure_count()"], "query": "event.type:transaction"}
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]["count()"] == 8
assert data[0]["failure_count()"] == 6
@mock.patch("sentry.utils.snuba.quantize_time")
def test_quantize_dates(self, mock_quantize):
self.create_project()
mock_quantize.return_value = before_now(days=1).replace(tzinfo=timezone.utc)
# Don't quantize short time periods
query = {"statsPeriod": "1h", "query": "", "field": ["id", "timestamp"]}
self.do_request(query)
# Don't quantize absolute date periods
self.do_request(query)
query = {
"start": iso_format(before_now(days=20)),
"end": iso_format(before_now(days=15)),
"query": "",
"field": ["id", "timestamp"],
}
self.do_request(query)
assert len(mock_quantize.mock_calls) == 0
# Quantize long date periods
query = {"field": ["id", "timestamp"], "statsPeriod": "90d", "query": ""}
self.do_request(query)
assert len(mock_quantize.mock_calls) == 2
def test_limit_number_of_fields(self):
self.create_project()
for i in range(1, 25):
response = self.do_request({"field": ["id"] * i})
if i <= 20:
assert response.status_code == 200
else:
assert response.status_code == 400
assert (
response.data["detail"]
== "You can view up to 20 fields at a time. Please delete some and try again."
)
def test_percentile_function_meta_types(self):
self.store_event(self.transaction_data, project_id=self.project.id)
query = {
"field": [
"transaction",
"percentile(transaction.duration, 0.95)",
"percentile(measurements.fp, 0.95)",
"percentile(measurements.fcp, 0.95)",
"percentile(measurements.lcp, 0.95)",
"percentile(measurements.fid, 0.95)",
"percentile(measurements.ttfb, 0.95)",
"percentile(measurements.ttfb.requesttime, 0.95)",
"percentile(measurements.cls, 0.95)",
"percentile(measurements.foo, 0.95)",
"percentile(measurements.bar, 0.95)",
],
"query": "",
"orderby": ["transaction"],
}
response = self.do_request(query)
assert response.status_code == 200, response.content
meta = response.data["meta"]["fields"]
assert meta["percentile(transaction.duration, 0.95)"] == "duration"
assert meta["percentile(measurements.fp, 0.95)"] == "duration"
assert meta["percentile(measurements.fcp, 0.95)"] == "duration"
assert meta["percentile(measurements.lcp, 0.95)"] == "duration"
assert meta["percentile(measurements.fid, 0.95)"] == "duration"
assert meta["percentile(measurements.ttfb, 0.95)"] == "duration"
assert meta["percentile(measurements.ttfb.requesttime, 0.95)"] == "duration"
assert meta["percentile(measurements.cls, 0.95)"] == "number"
assert meta["percentile(measurements.foo, 0.95)"] == "number"
assert meta["percentile(measurements.bar, 0.95)"] == "number"
units = response.data["meta"]["units"]
assert units["percentile(transaction.duration, 0.95)"] == "millisecond"
assert units["percentile(measurements.fp, 0.95)"] == "millisecond"
assert units["percentile(measurements.fcp, 0.95)"] == "millisecond"
assert units["percentile(measurements.lcp, 0.95)"] == "millisecond"
assert units["percentile(measurements.fid, 0.95)"] == "millisecond"
assert units["percentile(measurements.ttfb, 0.95)"] == "millisecond"
assert units["percentile(measurements.ttfb.requesttime, 0.95)"] == "millisecond"
def test_count_at_least_query(self):
self.store_event(self.transaction_data, self.project.id)
response = self.do_request({"field": "count_at_least(measurements.fcp, 0)"})
assert response.status_code == 200
assert len(response.data["data"]) == 1
assert response.data["data"][0]["count_at_least(measurements.fcp, 0)"] == 1
# a value that's a little bigger than the stored fcp
fcp = int(self.transaction_data["measurements"]["fcp"]["value"] + 1)
response = self.do_request({"field": f"count_at_least(measurements.fcp, {fcp})"})
assert response.status_code == 200
assert len(response.data["data"]) == 1
assert response.data["data"][0][f"count_at_least(measurements.fcp, {fcp})"] == 0
def test_measurements_query(self):
self.store_event(self.transaction_data, self.project.id)
query = {
"field": [
"measurements.fp",
"measurements.fcp",
"measurements.lcp",
"measurements.fid",
]
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
for field in query["field"]:
measure = field.split(".", 1)[1]
assert (
response.data["data"][0][field]
== self.transaction_data["measurements"][measure]["value"]
)
query = {
"field": [
"measurements.fP",
"measurements.Fcp",
"measurements.LcP",
"measurements.FID",
]
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
for field in query["field"]:
measure = field.split(".", 1)[1].lower()
assert (
response.data["data"][0][field]
== self.transaction_data["measurements"][measure]["value"]
)
def test_measurements_aggregations(self):
self.store_event(self.transaction_data, self.project.id)
# should try all the potential aggregates
# Skipped tests for stddev and var since sampling one data point
# results in nan.
query = {
"field": [
"percentile(measurements.fcp, 0.5)",
"count_unique(measurements.fcp)",
"min(measurements.fcp)",
"max(measurements.fcp)",
"avg(measurements.fcp)",
"sum(measurements.fcp)",
],
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert (
response.data["data"][0]["percentile(measurements.fcp, 0.5)"]
== self.transaction_data["measurements"]["fcp"]["value"]
)
assert response.data["data"][0]["count_unique(measurements.fcp)"] == 1
assert (
response.data["data"][0]["min(measurements.fcp)"]
== self.transaction_data["measurements"]["fcp"]["value"]
)
assert (
response.data["data"][0]["max(measurements.fcp)"]
== self.transaction_data["measurements"]["fcp"]["value"]
)
assert (
response.data["data"][0]["avg(measurements.fcp)"]
== self.transaction_data["measurements"]["fcp"]["value"]
)
assert (
response.data["data"][0]["sum(measurements.fcp)"]
== self.transaction_data["measurements"]["fcp"]["value"]
)
def get_measurement_condition_response(self, query_str, field):
query = {
"field": ["transaction", "count()"] + (field if field else []),
"query": query_str,
}
response = self.do_request(query)
assert response.status_code == 200, response.content
return response
def assert_measurement_condition_without_results(self, query_str, field=None):
response = self.get_measurement_condition_response(query_str, field)
assert len(response.data["data"]) == 0
def assert_measurement_condition_with_results(self, query_str, field=None):
response = self.get_measurement_condition_response(query_str, field)
assert len(response.data["data"]) == 1
assert response.data["data"][0]["transaction"] == self.transaction_data["metadata"]["title"]
assert response.data["data"][0]["count()"] == 1
def test_measurements_conditions(self):
self.store_event(self.transaction_data, self.project.id)
fcp = self.transaction_data["measurements"]["fcp"]["value"]
# equality condition
# We use json dumps here to ensure precision when converting from float to str
# This is necessary because equality on floating point values need to be precise
self.assert_measurement_condition_with_results(f"measurements.fcp:{json.dumps(fcp)}")
# greater than condition
self.assert_measurement_condition_with_results(f"measurements.fcp:>{fcp - 1}")
self.assert_measurement_condition_without_results(f"measurements.fcp:>{fcp + 1}")
# less than condition
self.assert_measurement_condition_with_results(f"measurements.fcp:<{fcp + 1}")
self.assert_measurement_condition_without_results(f"measurements.fcp:<{fcp - 1}")
# has condition
self.assert_measurement_condition_with_results("has:measurements.fcp")
self.assert_measurement_condition_without_results("!has:measurements.fcp")
def test_measurements_aggregation_conditions(self):
self.store_event(self.transaction_data, self.project.id)
fcp = self.transaction_data["measurements"]["fcp"]["value"]
functions = [
"percentile(measurements.fcp, 0.5)",
"min(measurements.fcp)",
"max(measurements.fcp)",
"avg(measurements.fcp)",
"sum(measurements.fcp)",
]
for function in functions:
self.assert_measurement_condition_with_results(
f"{function}:>{fcp - 1}", field=[function]
)
self.assert_measurement_condition_without_results(
f"{function}:>{fcp + 1}", field=[function]
)
self.assert_measurement_condition_with_results(
f"{function}:<{fcp + 1}", field=[function]
)
self.assert_measurement_condition_without_results(
f"{function}:<{fcp - 1}", field=[function]
)
count_unique = "count_unique(measurements.fcp)"
self.assert_measurement_condition_with_results(f"{count_unique}:1", field=[count_unique])
self.assert_measurement_condition_without_results(f"{count_unique}:0", field=[count_unique])
def test_compare_numeric_aggregate(self):
self.store_event(self.transaction_data, self.project.id)
query = {
"field": [
"p75(measurements.fcp)",
"compare_numeric_aggregate(p75_measurements_fcp,greater,0)",
],
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert (
response.data["data"][0]["compare_numeric_aggregate(p75_measurements_fcp,greater,0)"]
== 1
)
query = {
"field": ["p75()", "compare_numeric_aggregate(p75,equals,0)"],
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["compare_numeric_aggregate(p75,equals,0)"] == 0
def test_no_team_key_transactions(self):
transactions = [
"/blah_transaction/",
"/foo_transaction/",
"/zoo_transaction/",
]
for transaction in transactions:
self.transaction_data["transaction"] = transaction
self.store_event(self.transaction_data, self.project.id)
query = {
"team": "myteams",
"project": [self.project.id],
# use the order by to ensure the result order
"orderby": "transaction",
"field": [
"team_key_transaction",
"transaction",
"transaction.status",
"project",
"epm()",
"failure_rate()",
"percentile(transaction.duration, 0.95)",
],
}
response = self.do_request(query)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 3
assert data[0]["team_key_transaction"] == 0
assert data[0]["transaction"] == "/blah_transaction/"
assert data[1]["team_key_transaction"] == 0
assert data[1]["transaction"] == "/foo_transaction/"
assert data[2]["team_key_transaction"] == 0
assert data[2]["transaction"] == "/zoo_transaction/"
def test_team_key_transactions_my_teams(self):
team1 = self.create_team(organization=self.organization, name="Team A")
self.create_team_membership(team1, user=self.user)
self.project.add_team(team1)
team2 = self.create_team(organization=self.organization, name="Team B")
self.project.add_team(team2)
transactions = ["/blah_transaction/"]
key_transactions = [
(team1, "/foo_transaction/"),
(team2, "/zoo_transaction/"),
]
for transaction in transactions:
self.transaction_data["transaction"] = transaction
self.store_event(self.transaction_data, self.project.id)
for team, transaction in key_transactions:
self.transaction_data["transaction"] = transaction
self.store_event(self.transaction_data, self.project.id)
TeamKeyTransaction.objects.create(
organization=self.organization,
transaction=transaction,
project_team=ProjectTeam.objects.get(project=self.project, team=team),
)
query = {
"team": "myteams",
"project": [self.project.id],
"field": [
"team_key_transaction",
"transaction",
"transaction.status",
"project",
"epm()",
"failure_rate()",
"percentile(transaction.duration, 0.95)",
],
}
query["orderby"] = ["team_key_transaction", "transaction"]
response = self.do_request(query)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 3
assert data[0]["team_key_transaction"] == 0
assert data[0]["transaction"] == "/blah_transaction/"
assert data[1]["team_key_transaction"] == 0
assert data[1]["transaction"] == "/zoo_transaction/"
assert data[2]["team_key_transaction"] == 1
assert data[2]["transaction"] == "/foo_transaction/"
# not specifying any teams should use my teams
query = {
"project": [self.project.id],
"field": [
"team_key_transaction",
"transaction",
"transaction.status",
"project",
"epm()",
"failure_rate()",
"percentile(transaction.duration, 0.95)",
],
}
query["orderby"] = ["team_key_transaction", "transaction"]
response = self.do_request(query)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 3
assert data[0]["team_key_transaction"] == 0
assert data[0]["transaction"] == "/blah_transaction/"
assert data[1]["team_key_transaction"] == 0
assert data[1]["transaction"] == "/zoo_transaction/"
assert data[2]["team_key_transaction"] == 1
assert data[2]["transaction"] == "/foo_transaction/"
def test_team_key_transactions_orderby(self):
team1 = self.create_team(organization=self.organization, name="Team A")
team2 = self.create_team(organization=self.organization, name="Team B")
transactions = ["/blah_transaction/"]
key_transactions = [
(team1, "/foo_transaction/"),
(team2, "/zoo_transaction/"),
]
for transaction in transactions:
self.transaction_data["transaction"] = transaction
self.store_event(self.transaction_data, self.project.id)
for team, transaction in key_transactions:
self.create_team_membership(team, user=self.user)
self.project.add_team(team)
self.transaction_data["transaction"] = transaction
self.store_event(self.transaction_data, self.project.id)
TeamKeyTransaction.objects.create(
organization=self.organization,
transaction=transaction,
project_team=ProjectTeam.objects.get(project=self.project, team=team),
)
query = {
"team": "myteams",
"project": [self.project.id],
"field": [
"team_key_transaction",
"transaction",
"transaction.status",
"project",
"epm()",
"failure_rate()",
"percentile(transaction.duration, 0.95)",
],
}
# test ascending order
query["orderby"] = ["team_key_transaction", "transaction"]
response = self.do_request(query)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 3
assert data[0]["team_key_transaction"] == 0
assert data[0]["transaction"] == "/blah_transaction/"
assert data[1]["team_key_transaction"] == 1
assert data[1]["transaction"] == "/foo_transaction/"
assert data[2]["team_key_transaction"] == 1
assert data[2]["transaction"] == "/zoo_transaction/"
# test descending order
query["orderby"] = ["-team_key_transaction", "-transaction"]
response = self.do_request(query)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 3
assert data[0]["team_key_transaction"] == 1
assert data[0]["transaction"] == "/zoo_transaction/"
assert data[1]["team_key_transaction"] == 1
assert data[1]["transaction"] == "/foo_transaction/"
assert data[2]["team_key_transaction"] == 0
assert data[2]["transaction"] == "/blah_transaction/"
def test_team_key_transactions_query(self):
team1 = self.create_team(organization=self.organization, name="Team A")
team2 = self.create_team(organization=self.organization, name="Team B")
transactions = ["/blah_transaction/"]
key_transactions = [
(team1, "/foo_transaction/"),
(team2, "/zoo_transaction/"),
]
for transaction in transactions:
self.transaction_data["transaction"] = transaction
self.store_event(self.transaction_data, self.project.id)
for team, transaction in key_transactions:
self.create_team_membership(team, user=self.user)
self.project.add_team(team)
self.transaction_data["transaction"] = transaction
self.store_event(self.transaction_data, self.project.id)
TeamKeyTransaction.objects.create(
organization=self.organization,
project_team=ProjectTeam.objects.get(
project=self.project,
team=team,
),
transaction=transaction,
)
query = {
"team": "myteams",
"project": [self.project.id],
# use the order by to ensure the result order
"orderby": "transaction",
"field": [
"team_key_transaction",
"transaction",
"transaction.status",
"project",
"epm()",
"failure_rate()",
"percentile(transaction.duration, 0.95)",
],
}
# key transactions
query["query"] = "has:team_key_transaction"
response = self.do_request(query)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 2
assert data[0]["team_key_transaction"] == 1
assert data[0]["transaction"] == "/foo_transaction/"
assert data[1]["team_key_transaction"] == 1
assert data[1]["transaction"] == "/zoo_transaction/"
# key transactions
query["query"] = "team_key_transaction:true"
response = self.do_request(query)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 2
assert data[0]["team_key_transaction"] == 1
assert data[0]["transaction"] == "/foo_transaction/"
assert data[1]["team_key_transaction"] == 1
assert data[1]["transaction"] == "/zoo_transaction/"
# not key transactions
query["query"] = "!has:team_key_transaction"
response = self.do_request(query)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["team_key_transaction"] == 0
assert data[0]["transaction"] == "/blah_transaction/"
# not key transactions
query["query"] = "team_key_transaction:false"
response = self.do_request(query)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["team_key_transaction"] == 0
assert data[0]["transaction"] == "/blah_transaction/"
def test_too_many_team_key_transactions(self):
MAX_QUERYABLE_TEAM_KEY_TRANSACTIONS = 1
with mock.patch(
"sentry.search.events.fields.MAX_QUERYABLE_TEAM_KEY_TRANSACTIONS",
MAX_QUERYABLE_TEAM_KEY_TRANSACTIONS,
):
team = self.create_team(organization=self.organization, name="Team A")
self.create_team_membership(team, user=self.user)
self.project.add_team(team)
project_team = ProjectTeam.objects.get(project=self.project, team=team)
for i in range(MAX_QUERYABLE_TEAM_KEY_TRANSACTIONS + 1):
transaction = f"transaction-{team.id}-{i}"
self.transaction_data["transaction"] = transaction
self.store_event(self.transaction_data, self.project.id)
TeamKeyTransaction.objects.bulk_create(
[
TeamKeyTransaction(
organization=self.organization,
project_team=project_team,
transaction=f"transaction-{team.id}-{i}",
)
for i in range(MAX_QUERYABLE_TEAM_KEY_TRANSACTIONS + 1)
]
)
query = {
"team": "myteams",
"project": [self.project.id],
"orderby": "transaction",
"field": [
"team_key_transaction",
"transaction",
"transaction.status",
"project",
"epm()",
"failure_rate()",
"percentile(transaction.duration, 0.95)",
],
}
response = self.do_request(query)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 2
assert (
sum(row["team_key_transaction"] for row in data)
== MAX_QUERYABLE_TEAM_KEY_TRANSACTIONS
)
def test_no_pagination_param(self):
self.store_event(
data={
"event_id": "a" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group1"],
},
project_id=self.project.id,
)
query = {"field": ["id", "project.id"], "project": [self.project.id], "noPagination": True}
response = self.do_request(query)
assert response.status_code == 200
assert len(response.data["data"]) == 1
assert "Link" not in response
def test_nan_result(self):
query = {"field": ["apdex(300)"], "project": [self.project.id], "query": f"id:{'0' * 32}"}
response = self.do_request(query)
assert response.status_code == 200
assert len(response.data["data"]) == 1
assert response.data["data"][0]["apdex(300)"] == 0
def test_equation_simple(self):
event_data = self.load_data(
timestamp=self.ten_mins_ago,
)
event_data["breakdowns"]["span_ops"]["ops.http"]["value"] = 1500
self.store_event(data=event_data, project_id=self.project.id)
query = {
"field": ["spans.http", "equation|spans.http / 3"],
"project": [self.project.id],
"query": "event.type:transaction",
}
response = self.do_request(
query,
{
"organizations:discover-basic": True,
},
)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert (
response.data["data"][0]["equation|spans.http / 3"]
== event_data["breakdowns"]["span_ops"]["ops.http"]["value"] / 3
)
assert response.data["meta"]["fields"]["equation|spans.http / 3"] == "number"
def test_equation_sort(self):
event_data = self.transaction_data.copy()
event_data["breakdowns"] = {"span_ops": {"ops.http": {"value": 1500}}}
self.store_event(data=event_data, project_id=self.project.id)
event_data2 = self.transaction_data.copy()
event_data2["breakdowns"] = {"span_ops": {"ops.http": {"value": 2000}}}
self.store_event(data=event_data2, project_id=self.project.id)
query = {
"field": ["spans.http", "equation|spans.http / 3"],
"project": [self.project.id],
"orderby": "equation|spans.http / 3",
"query": "event.type:transaction",
}
response = self.do_request(
query,
{
"organizations:discover-basic": True,
},
)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 2
assert (
response.data["data"][0]["equation|spans.http / 3"]
== event_data["breakdowns"]["span_ops"]["ops.http"]["value"] / 3
)
assert (
response.data["data"][1]["equation|spans.http / 3"]
== event_data2["breakdowns"]["span_ops"]["ops.http"]["value"] / 3
)
def test_equation_operation_limit(self):
query = {
"field": ["spans.http", f"equation|spans.http{' * 2' * 11}"],
"project": [self.project.id],
"query": "event.type:transaction",
}
response = self.do_request(
query,
{
"organizations:discover-basic": True,
},
)
assert response.status_code == 400
@mock.patch("sentry.api.bases.organization_events.MAX_FIELDS", 2)
def test_equation_field_limit(self):
query = {
"field": ["spans.http", "transaction.duration", "equation|5 * 2"],
"project": [self.project.id],
"query": "event.type:transaction",
}
response = self.do_request(
query,
{
"organizations:discover-basic": True,
},
)
assert response.status_code == 400
def test_count_if(self):
unicode_phrase1 = "\u716e\u6211\u66f4\u591a\u7684\u98df\u7269\uff0c\u6211\u9913\u4e86"
for i in range(5):
data = self.load_data(
timestamp=before_now(minutes=(10 + i)),
duration=timedelta(milliseconds=100 if i < 3 else 200),
)
data["tags"] = {
"sub_customer.is-Enterprise-42": "yes" if i == 0 else "no",
"unicode-phrase": unicode_phrase1 if i == 0 else "no",
}
self.store_event(data, project_id=self.project.id)
query = {
"field": [
"count_if(transaction.duration, less, 150)",
"count_if(transaction.duration, greater, 150)",
"count_if(sub_customer.is-Enterprise-42, equals, yes)",
"count_if(sub_customer.is-Enterprise-42, notEquals, yes)",
f"count_if(unicode-phrase, equals, {unicode_phrase1})",
],
"project": [self.project.id],
}
response = self.do_request(query)
assert response.status_code == 200
assert len(response.data["data"]) == 1
assert response.data["data"][0]["count_if(transaction.duration, less, 150)"] == 3
assert response.data["data"][0]["count_if(transaction.duration, greater, 150)"] == 2
assert response.data["data"][0]["count_if(sub_customer.is-Enterprise-42, equals, yes)"] == 1
assert (
response.data["data"][0]["count_if(sub_customer.is-Enterprise-42, notEquals, yes)"] == 4
)
assert response.data["data"][0][f"count_if(unicode-phrase, equals, {unicode_phrase1})"] == 1
def test_count_if_array_field(self):
data = self.load_data(platform="javascript")
data["timestamp"] = self.ten_mins_ago_iso
self.store_event(data=data, project_id=self.project.id)
query = {
"field": [
"count_if(stack.filename, equals, raven.js)",
],
"project": [self.project.id],
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["count_if(stack.filename, equals, raven.js)"] == 1
def test_count_if_measurements_cls(self):
data = self.transaction_data.copy()
data["measurements"] = {"cls": {"value": 0.5}}
self.store_event(data, project_id=self.project.id)
data["measurements"] = {"cls": {"value": 0.1}}
self.store_event(data, project_id=self.project.id)
query = {
"field": [
"count_if(measurements.cls, greater, 0.05)",
"count_if(measurements.cls, less, 0.3)",
],
"project": [self.project.id],
}
response = self.do_request(query)
assert response.status_code == 200
assert len(response.data["data"]) == 1
assert response.data["data"][0]["count_if(measurements.cls, greater, 0.05)"] == 2
assert response.data["data"][0]["count_if(measurements.cls, less, 0.3)"] == 1
def test_count_if_filter(self):
for i in range(5):
data = self.load_data(
timestamp=before_now(minutes=(10 + i)),
duration=timedelta(milliseconds=100 if i < 3 else 200),
)
data["tags"] = {"sub_customer.is-Enterprise-42": "yes" if i == 0 else "no"}
self.store_event(data, project_id=self.project.id)
query = {
"field": [
"count_if(transaction.duration, less, 150)",
],
"query": "count_if(transaction.duration, less, 150):>2",
"project": [self.project.id],
}
response = self.do_request(query)
assert response.status_code == 200
assert len(response.data["data"]) == 1
assert response.data["data"][0]["count_if(transaction.duration, less, 150)"] == 3
query = {
"field": [
"count_if(transaction.duration, less, 150)",
],
"query": "count_if(transaction.duration, less, 150):<2",
"project": [self.project.id],
}
response = self.do_request(query)
assert response.status_code == 200
assert len(response.data["data"]) == 0
def test_filters_with_escaped_asterisk(self):
self.transaction_data["transaction"] = r"/:a*/:b-:c(\d\.\e+)"
self.store_event(self.transaction_data, project_id=self.project.id)
query = {
"field": ["transaction", "transaction.duration"],
# make sure to escape the asterisk so it's not treated as a wildcard
"query": r'transaction:"/:a\*/:b-:c(\d\.\e+)"',
"project": [self.project.id],
}
response = self.do_request(query)
assert response.status_code == 200
assert len(response.data["data"]) == 1
def test_filters_with_back_slashes(self):
self.transaction_data["transaction"] = r"a\b\c@d"
self.store_event(self.transaction_data, project_id=self.project.id)
query = {
"field": ["transaction", "transaction.duration"],
"query": r'transaction:"a\b\c@d"',
"project": [self.project.id],
}
response = self.do_request(query)
assert response.status_code == 200
assert len(response.data["data"]) == 1
def test_mobile_measurements(self):
self.transaction_data["measurements"]["frames_total"] = {"value": 100}
self.transaction_data["measurements"]["frames_slow"] = {"value": 10}
self.transaction_data["measurements"]["frames_frozen"] = {"value": 5}
self.transaction_data["measurements"]["stall_count"] = {"value": 2}
self.transaction_data["measurements"]["stall_total_time"] = {"value": 12}
self.transaction_data["measurements"]["stall_longest_time"] = {"value": 7}
self.store_event(self.transaction_data, project_id=self.project.id)
query = {
"field": [
"measurements.frames_total",
"measurements.frames_slow",
"measurements.frames_frozen",
"measurements.frames_slow_rate",
"measurements.frames_frozen_rate",
"measurements.stall_count",
"measurements.stall_total_time",
"measurements.stall_longest_time",
"measurements.stall_percentage",
],
"query": "",
"project": [self.project.id],
}
response = self.do_request(query)
assert response.status_code == 200
data = response.data["data"]
assert len(data) == 1
assert data[0]["measurements.frames_total"] == 100
assert data[0]["measurements.frames_slow"] == 10
assert data[0]["measurements.frames_frozen"] == 5
assert data[0]["measurements.frames_slow_rate"] == 0.1
assert data[0]["measurements.frames_frozen_rate"] == 0.05
assert data[0]["measurements.stall_count"] == 2
assert data[0]["measurements.stall_total_time"] == 12
assert data[0]["measurements.stall_longest_time"] == 7
assert data[0]["measurements.stall_percentage"] == 0.004
meta = response.data["meta"]["fields"]
assert meta["measurements.frames_total"] == "number"
assert meta["measurements.frames_slow"] == "number"
assert meta["measurements.frames_frozen"] == "number"
assert meta["measurements.frames_slow_rate"] == "percentage"
assert meta["measurements.frames_frozen_rate"] == "percentage"
assert meta["measurements.stall_count"] == "number"
assert meta["measurements.stall_total_time"] == "number"
assert meta["measurements.stall_longest_time"] == "number"
assert meta["measurements.stall_percentage"] == "percentage"
query = {
"field": [
"p75(measurements.frames_slow_rate)",
"p75(measurements.frames_frozen_rate)",
"percentile(measurements.frames_slow_rate,0.5)",
"percentile(measurements.frames_frozen_rate,0.5)",
"p75(measurements.stall_percentage)",
"percentile(measurements.stall_percentage,0.5)",
],
"query": "",
"project": [self.project.id],
}
response = self.do_request(query)
assert response.status_code == 200
data = response.data["data"]
assert len(data) == 1
assert data[0]["p75(measurements.frames_slow_rate)"] == 0.1
assert data[0]["p75(measurements.frames_frozen_rate)"] == 0.05
assert data[0]["p75(measurements.stall_percentage)"] == 0.004
assert data[0]["percentile(measurements.frames_slow_rate,0.5)"] == 0.1
assert data[0]["percentile(measurements.frames_frozen_rate,0.5)"] == 0.05
assert data[0]["percentile(measurements.stall_percentage,0.5)"] == 0.004
meta = response.data["meta"]["fields"]
assert meta["p75(measurements.frames_slow_rate)"] == "percentage"
assert meta["p75(measurements.frames_frozen_rate)"] == "percentage"
assert meta["p75(measurements.stall_percentage)"] == "percentage"
assert meta["percentile(measurements.frames_slow_rate,0.5)"] == "percentage"
assert meta["percentile(measurements.stall_percentage,0.5)"] == "percentage"
def test_project_auto_fields(self):
self.store_event(
data={
"event_id": "a" * 32,
"environment": "staging",
"timestamp": self.ten_mins_ago_iso,
},
project_id=self.project.id,
)
query = {"field": ["environment"]}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["environment"] == "staging"
assert response.data["data"][0]["project.name"] == self.project.slug
def test_timestamp_different_from_params(self):
fifteen_days_ago = iso_format(before_now(days=15))
fifteen_days_later = iso_format(before_now(days=-15))
for query_text in [
f"timestamp:<{fifteen_days_ago}",
f"timestamp:<={fifteen_days_ago}",
f"timestamp:>{fifteen_days_later}",
f"timestamp:>={fifteen_days_later}",
]:
query = {
"field": ["count()"],
"query": query_text,
"statsPeriod": "14d",
"project": self.project.id,
}
response = self.do_request(query)
assert response.status_code == 400, query_text
@mock.patch("sentry.search.events.builder.discover.raw_snql_query")
def test_removes_unnecessary_default_project_and_transaction_thresholds(self, mock_snql_query):
mock_snql_query.side_effect = [{"meta": {}, "data": []}]
ProjectTransactionThreshold.objects.create(
project=self.project,
organization=self.organization,
# these are the default values that we use
threshold=constants.DEFAULT_PROJECT_THRESHOLD,
metric=TransactionMetric.DURATION.value,
)
ProjectTransactionThresholdOverride.objects.create(
transaction="transaction",
project=self.project,
organization=self.organization,
# these are the default values that we use
threshold=constants.DEFAULT_PROJECT_THRESHOLD,
metric=TransactionMetric.DURATION.value,
)
query = {
"field": ["apdex()", "user_misery()"],
"query": "event.type:transaction",
"project": [self.project.id],
}
response = self.do_request(
query,
features={
"organizations:discover-basic": True,
"organizations:global-views": True,
},
)
assert response.status_code == 200, response.content
assert mock_snql_query.call_count == 1
assert (
Function("tuple", ["duration", 300], "project_threshold_config")
in mock_snql_query.call_args_list[0][0][0].query.select
)
@mock.patch("sentry.search.events.builder.discover.raw_snql_query")
def test_removes_unnecessary_default_project_and_transaction_thresholds_keeps_others(
self, mock_snql_query
):
mock_snql_query.side_effect = [{"meta": {}, "data": []}]
ProjectTransactionThreshold.objects.create(
project=self.project,
organization=self.organization,
# these are the default values that we use
threshold=constants.DEFAULT_PROJECT_THRESHOLD,
metric=TransactionMetric.DURATION.value,
)
ProjectTransactionThresholdOverride.objects.create(
transaction="transaction",
project=self.project,
organization=self.organization,
# these are the default values that we use
threshold=constants.DEFAULT_PROJECT_THRESHOLD,
metric=TransactionMetric.DURATION.value,
)
project = self.create_project()
ProjectTransactionThreshold.objects.create(
project=project,
organization=self.organization,
threshold=100,
metric=TransactionMetric.LCP.value,
)
ProjectTransactionThresholdOverride.objects.create(
transaction="transaction",
project=project,
organization=self.organization,
threshold=200,
metric=TransactionMetric.LCP.value,
)
query = {
"field": ["apdex()", "user_misery()"],
"query": "event.type:transaction",
"project": [self.project.id, project.id],
}
response = self.do_request(
query,
features={
"organizations:discover-basic": True,
"organizations:global-views": True,
},
)
assert response.status_code == 200, response.content
assert mock_snql_query.call_count == 1
project_threshold_override_config_index = Function(
"indexOf",
[
# only 1 transaction override is present here
# because the other use to the default values
[(Function("toUInt64", [project.id]), "transaction")],
(Column("project_id"), Column("transaction")),
],
"project_threshold_override_config_index",
)
project_threshold_config_index = Function(
"indexOf",
[
# only 1 project override is present here
# because the other use to the default values
[Function("toUInt64", [project.id])],
Column("project_id"),
],
"project_threshold_config_index",
)
assert (
Function(
"if",
[
Function("equals", [project_threshold_override_config_index, 0]),
Function(
"if",
[
Function("equals", [project_threshold_config_index, 0]),
("duration", 300),
Function(
"arrayElement", [[("lcp", 100)], project_threshold_config_index]
),
],
),
Function(
"arrayElement",
[[("lcp", 200)], project_threshold_override_config_index],
),
],
"project_threshold_config",
)
in mock_snql_query.call_args_list[0][0][0].query.select
)
def test_count_web_vitals(self):
# Good
self.transaction_data["measurements"] = {
"lcp": {"value": constants.VITAL_THRESHOLDS["lcp"]["meh"] - 100},
}
self.store_event(self.transaction_data, self.project.id)
# Meh
self.transaction_data["measurements"] = {
"lcp": {"value": constants.VITAL_THRESHOLDS["lcp"]["meh"] + 100},
}
self.store_event(self.transaction_data, self.project.id)
self.store_event(self.transaction_data, self.project.id)
query = {
"field": [
"count_web_vitals(measurements.lcp, poor)",
"count_web_vitals(measurements.lcp, meh)",
"count_web_vitals(measurements.lcp, good)",
]
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0] == {
"count_web_vitals(measurements.lcp, poor)": 0,
"count_web_vitals(measurements.lcp, meh)": 2,
"count_web_vitals(measurements.lcp, good)": 1,
}
def test_count_web_vitals_invalid_vital(self):
query = {
"field": [
"count_web_vitals(measurements.foo, poor)",
],
"project": [self.project.id],
}
response = self.do_request(query)
assert response.status_code == 400, response.content
query = {
"field": [
"count_web_vitals(tags[lcp], poor)",
],
"project": [self.project.id],
}
response = self.do_request(query)
assert response.status_code == 400, response.content
query = {
"field": [
"count_web_vitals(transaction.duration, poor)",
],
"project": [self.project.id],
}
response = self.do_request(query)
assert response.status_code == 400, response.content
query = {
"field": [
"count_web_vitals(measurements.lcp, bad)",
],
"project": [self.project.id],
}
response = self.do_request(query)
assert response.status_code == 400, response.content
def test_tag_that_looks_like_aggregate(self):
data = self.load_data()
data["tags"] = {"p95": "<5k"}
self.store_event(data, project_id=self.project.id)
query = {
"field": ["p95"],
"query": "p95:<5k",
"project": [self.project.id],
}
response = self.do_request(query)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["p95"] == "<5k"
def test_chained_or_query_meta_tip(self):
query = {
"field": ["transaction"],
"query": "transaction:a OR transaction:b",
"project": [self.project.id],
}
response = self.do_request(query)
assert response.status_code == 200, response.content
meta = response.data["meta"]
assert meta["tips"] == {
"query": "Did you know you can replace chained or conditions like `field:a OR field:b OR field:c` with `field:[a,b,c]`",
"columns": None,
}
@override_settings(SENTRY_SELF_HOSTED=False)
def test_no_ratelimit(self):
query = {
"field": ["transaction"],
"project": [self.project.id],
}
with freeze_time("2000-01-01"):
for _ in range(15):
self.do_request(query)
response = self.do_request(query)
assert response.status_code == 200, response.content
def test_transaction_source(self):
query = {
"field": ["transaction"],
"query": "transaction.source:task",
"project": [self.project.id],
}
response = self.do_request(query)
assert response.status_code == 200, response.content
def test_readable_device_name(self):
data = self.load_data()
data["tags"] = {"device": "iPhone14,3"}
self.store_event(data, project_id=self.project.id)
query = {
"field": ["device"],
"query": "",
"project": [self.project.id],
"readable": True,
}
response = self.do_request(query)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["device"] == "iPhone14,3"
assert data[0]["readable"] == "iPhone 13 Pro Max"
def test_http_status_code(self):
project1 = self.create_project()
project2 = self.create_project()
self.store_event(
data={
"event_id": "a" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"tags": {"http.status_code": "200"},
},
project_id=project1.id,
)
self.store_event(
data={
"event_id": "b" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"contexts": {"response": {"status_code": 400}},
},
project_id=project2.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["event.type", "http.status_code"],
"query": "",
"statsPeriod": "24h",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 2
result = {r["http.status_code"] for r in data}
assert result == {"200", "400"}
def test_http_status_code_context_priority(self):
project1 = self.create_project()
self.store_event(
data={
"event_id": "a" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"tags": {"http.status_code": "200"},
"contexts": {"response": {"status_code": 400}},
},
project_id=project1.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["event.type", "http.status_code"],
"query": "",
"statsPeriod": "24h",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["http.status_code"] == "400"
def test_total_count(self):
project1 = self.create_project()
for i in range(3):
self.store_event(data=self.load_data(platform="javascript"), project_id=project1.id)
self.store_event(
data={
"event_id": "a" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
},
project_id=project1.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["transaction", "total.count", "count()"],
"query": "!transaction:/example",
"statsPeriod": "24h",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["total.count"] == 3
def test_total_count_by_itself(self):
project1 = self.create_project()
for i in range(3):
self.store_event(data=self.load_data(platform="javascript"), project_id=project1.id)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["total.count"],
"statsPeriod": "24h",
}
response = self.do_request(query, features=features)
assert response.status_code == 400, response.content
def test_total_count_equation(self):
project1 = self.create_project()
for i in range(3):
self.store_event(data=self.load_data(platform="javascript"), project_id=project1.id)
self.store_event(
data={
"event_id": "a" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
},
project_id=project1.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["transaction", "count()", "total.count", "equation|count()/total.count"],
"query": "",
"orderby": "equation|count()/total.count",
"statsPeriod": "24h",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 2
assert data[0]["equation|count()/total.count"] == 0.25
assert data[1]["equation|count()/total.count"] == 0.75
def test_total_count_filter(self):
project1 = self.create_project()
for i in range(3):
self.store_event(data=self.load_data(platform="javascript"), project_id=project1.id)
self.store_event(
data={
"event_id": "a" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"tags": {"total.count": ">45"},
},
project_id=project1.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["transaction", "count()", "total.count"],
"query": "total.count:>45",
"orderby": "count()",
"statsPeriod": "24h",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["total.count"] == 1
def test_total_sum_transaction_duration_equation(self):
for i in range(3):
data = self.load_data(
timestamp=self.eleven_mins_ago,
duration=timedelta(seconds=5),
)
data["transaction"] = "/endpoint/1"
self.store_event(data, project_id=self.project.id)
data = self.load_data(
timestamp=self.ten_mins_ago,
duration=timedelta(seconds=5),
)
data["transaction"] = "/endpoint/2"
self.store_event(data, project_id=self.project.id)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": [
"transaction",
"sum(transaction.duration)",
"total.transaction_duration",
"equation|sum(transaction.duration)/total.transaction_duration",
],
"query": "",
"orderby": "-equation|sum(transaction.duration)/total.transaction_duration",
"statsPeriod": "24h",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 2
assert data[0]["equation|sum(transaction.duration)/total.transaction_duration"] == 0.75
assert data[1]["equation|sum(transaction.duration)/total.transaction_duration"] == 0.25
def test_device_class(self):
project1 = self.create_project()
for i in range(3):
self.store_event(
data={
"event_id": "a" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"tags": {"device.class": f"{i + 1}"},
},
project_id=project1.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["device.class"],
"statsPeriod": "24h",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 3
result = (*map(lambda columns: columns["device.class"], data),)
assert "low" in result
assert "medium" in result
assert "high" in result
def test_device_class_filter_low(self):
project1 = self.create_project()
for i in range(3):
self.store_event(data=self.load_data(platform="javascript"), project_id=project1.id)
self.store_event(
data={
"event_id": "a" * 32,
"transaction": "/example",
"message": "how to make fast",
"timestamp": self.ten_mins_ago_iso,
"tags": {"device.class": "1"},
},
project_id=project1.id,
)
features = {"organizations:discover-basic": True, "organizations:global-views": True}
query = {
"field": ["device.class", "count()"],
"query": "device.class:low",
"orderby": "count()",
"statsPeriod": "24h",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
assert data[0]["count()"] == 1
def test_group_id_as_custom_tag(self):
project1 = self.create_project()
self.store_event(
data={
"event_id": "a" * 32,
"message": "poof",
"timestamp": self.ten_mins_ago_iso,
"user": {"email": self.user.email},
"tags": {"group_id": "this should just get returned"},
},
project_id=project1.id,
)
query = {
"field": ["group_id"],
"query": "",
"orderby": "group_id",
"statsPeriod": "24h",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert response.data["data"][0]["group_id"] == "this should just get returned"
def test_floored_epm(self):
for _ in range(5):
data = self.load_data(
timestamp=self.ten_mins_ago,
duration=timedelta(seconds=5),
)
data["transaction"] = "/aggregates/1"
event1 = self.store_event(data, project_id=self.project.id)
query = {
"field": ["transaction", "floored_epm()", "epm()"],
"query": "event.type:transaction",
"orderby": ["transaction"],
"start": self.eleven_mins_ago_iso,
"end": iso_format(self.nine_mins_ago),
}
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"] == event1.transaction
assert data[0]["floored_epm()"] == 1
assert data[0]["epm()"] == 2.5
def test_floored_epm_more_events(self):
for _ in range(25):
data = self.load_data(
timestamp=self.ten_mins_ago,
duration=timedelta(seconds=5),
)
data["transaction"] = "/aggregates/1"
event1 = self.store_event(data, project_id=self.project.id)
query = {
"field": ["transaction", "floored_epm()", "epm()"],
"query": "event.type:transaction",
"orderby": ["transaction"],
"start": self.eleven_mins_ago_iso,
"end": iso_format(self.nine_mins_ago),
}
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"] == event1.transaction
assert data[0]["epm()"] == 12.5
assert data[0]["floored_epm()"] == 10
@region_silo_test
class OrganizationEventsProfilesDatasetEndpointTest(OrganizationEventsEndpointTestBase):
@mock.patch("sentry.search.events.builder.discover.raw_snql_query")
def test_profiles_dataset_simple(self, mock_snql_query):
mock_snql_query.side_effect = [
{
"data": [
{
"project": self.project.id,
"transaction": "foo",
"last_seen": "2022-10-20T16:41:22+00:00",
"latest_event": "a" * 32,
"count": 1,
"count_unique_transaction": 1,
"percentile_profile_duration_0_25": 1,
"p50_profile_duration": 1,
"p75_profile_duration": 1,
"p95_profile_duration": 1,
"p99_profile_duration": 1,
"p100_profile_duration": 1,
"min_profile_duration": 1,
"max_profile_duration": 1,
"avg_profile_duration": 1,
"sum_profile_duration": 1,
},
],
"meta": [
{
"name": "project",
"type": "UInt64",
},
{
"name": "transaction",
"type": "LowCardinality(String)",
},
{
"name": "last_seen",
"type": "DateTime",
},
{
"name": "latest_event",
"type": "String",
},
{
"name": "count",
"type": "UInt64",
},
{
"name": "count_unique_transaction",
"type": "UInt64",
},
{
"name": "percentile_profile_duration_0_25",
"type": "Float64",
},
*[
{
"name": f"{fn}_profile_duration",
"type": "Float64",
}
for fn in ["p50", "p75", "p95", "p99", "p100", "min", "max", "avg", "sum"]
],
],
},
]
fields = [
"project",
"transaction",
"last_seen()",
"latest_event()",
"count()",
"count_unique(transaction)",
"percentile(profile.duration, 0.25)",
"p50(profile.duration)",
"p75(profile.duration)",
"p95(profile.duration)",
"p99(profile.duration)",
"p100(profile.duration)",
"min(profile.duration)",
"max(profile.duration)",
"avg(profile.duration)",
"sum(profile.duration)",
]
query = {
"field": fields,
"project": [self.project.id],
"dataset": "profiles",
}
response = self.do_request(query, features={"organizations:profiling": True})
assert response.status_code == 200, response.content
# making sure the response keys are in the form we expect and not aliased
data_keys = {key for row in response.data["data"] for key in row}
field_keys = {key for key in response.data["meta"]["fields"]}
unit_keys = {key for key in response.data["meta"]["units"]}
assert set(fields) == data_keys
assert set(fields) == field_keys
assert set(fields) == unit_keys
@region_silo_test
class OrganizationEventsProfileFunctionsDatasetEndpointTest(
OrganizationEventsEndpointTestBase, ProfilesSnubaTestCase
):
def test_functions_dataset_simple(self):
self.store_functions(
[
{
"self_times_ns": [100 for _ in range(100)],
"package": "foo",
"function": "bar",
"in_app": True,
},
],
project=self.project,
timestamp=before_now(hours=3),
)
self.store_functions(
[
{
"self_times_ns": [150 for _ in range(100)],
"package": "foo",
"function": "bar",
"in_app": True,
},
],
project=self.project,
timestamp=before_now(hours=1),
)
mid = before_now(hours=2)
fields = [
"transaction",
"project",
"function",
"package",
"is_application",
"platform.name",
"environment",
"release",
"count()",
"examples()",
"p50()",
"p75()",
"p95()",
"p99()",
"avg()",
"sum()",
f"regression_score(function.duration, 0.95, {int(mid.timestamp())})",
]
response = self.do_request(
{
"field": fields,
"statsPeriod": "4h",
"project": [self.project.id],
"dataset": "profileFunctions",
},
features={"organizations:profiling": True},
)
assert response.status_code == 200, response.content
# making sure the response keys are in the form we expect and not aliased
data_keys = {key for row in response.data["data"] for key in row}
field_keys = {key for key in response.data["meta"]["fields"]}
unit_keys = {key for key in response.data["meta"]["units"]}
assert set(fields) == data_keys
assert set(fields) == field_keys
assert set(fields) == unit_keys
assert response.data["meta"]["units"] == {
"transaction": None,
"project": None,
"function": None,
"package": None,
"is_application": None,
"platform.name": None,
"environment": None,
"release": None,
"count()": None,
"examples()": None,
"p50()": "nanosecond",
"p75()": "nanosecond",
"p95()": "nanosecond",
"p99()": "nanosecond",
"avg()": "nanosecond",
"sum()": "nanosecond",
f"regression_score(function.duration, 0.95, {int(mid.timestamp())})": None,
}
@region_silo_test
class OrganizationEventsIssuePlatformDatasetEndpointTest(
OrganizationEventsEndpointTestBase, SearchIssueTestMixin, PerformanceIssueTestCase
):
def test_performance_issue_id_filter(self):
event = self.create_performance_issue()
query = {
"field": ["count()"],
"statsPeriod": "2h",
"query": f"issue.id:{event.group.id}",
"dataset": "issuePlatform",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert response.data["data"][0]["count()"] == 1
def test_generic_issue_ids_filter(self):
user_data = {
"id": self.user.id,
"username": "user",
"email": "hellboy@bar.com",
"ip_address": "127.0.0.1",
}
event, _, group_info = self.store_search_issue(
self.project.id,
self.user.id,
[f"{ProfileFileIOGroupType.type_id}-group1"],
"prod",
before_now(hours=1).replace(tzinfo=timezone.utc),
user=user_data,
)
event, _, group_info = self.store_search_issue(
self.project.id,
self.user.id,
[f"{ProfileFileIOGroupType.type_id}-group2"],
"prod",
before_now(hours=1).replace(tzinfo=timezone.utc),
user=user_data,
)
assert group_info is not None
query = {
"field": ["title", "release", "environment", "user.display", "timestamp"],
"statsPeriod": "90d",
"query": f"issue.id:{group_info.group.id}",
"dataset": "issuePlatform",
}
with self.feature(["organizations:profiling"]):
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["title"] == group_info.group.title
assert response.data["data"][0]["environment"] == "prod"
assert response.data["data"][0]["user.display"] == user_data["email"]
assert response.data["data"][0]["timestamp"] == event.timestamp
query = {
"field": ["title", "release", "environment", "user.display", "timestamp"],
"statsPeriod": "90d",
"query": f"issue:{group_info.group.qualified_short_id}",
"dataset": "issuePlatform",
}
with self.feature(["organizations:profiling"]):
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0]["title"] == group_info.group.title
assert response.data["data"][0]["environment"] == "prod"
assert response.data["data"][0]["user.display"] == user_data["email"]
assert response.data["data"][0]["timestamp"] == event.timestamp
def test_performance_short_group_id(self):
event = self.create_performance_issue()
query = {
"field": ["count()"],
"statsPeriod": "1h",
"query": f"project:{event.group.project.slug} issue:{event.group.qualified_short_id}",
"dataset": "issuePlatform",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert response.data["data"][0]["count()"] == 1
def test_multiple_performance_short_group_ids_filter(self):
event1 = self.create_performance_issue()
event2 = self.create_performance_issue()
query = {
"field": ["count()"],
"statsPeriod": "1h",
"query": f"project:{event1.group.project.slug} issue:[{event1.group.qualified_short_id},{event2.group.qualified_short_id}]",
"dataset": "issuePlatform",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert response.data["data"][0]["count()"] == 2
def test_user_display_issue_platform(self):
project1 = self.create_project()
user_data = {
"id": self.user.id,
"username": "user",
"email": "hellboy@bar.com",
"ip_address": "127.0.0.1",
}
_, _, group_info = self.store_search_issue(
project1.id,
1,
["group1-fingerprint"],
None,
before_now(hours=1).replace(tzinfo=timezone.utc),
user=user_data,
)
assert group_info is not None
features = {
"organizations:discover-basic": True,
"organizations:global-views": True,
"organizations:profiling": True,
}
query = {
"field": ["user.display"],
"query": f"user.display:hell* issue.id:{group_info.group.id}",
"statsPeriod": "24h",
"dataset": "issuePlatform",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
result = {r["user.display"] for r in data}
assert result == {user_data["email"]}
def test_all_events_fields(self):
user_data = {
"id": self.user.id,
"username": "user",
"email": "hellboy@bar.com",
"ip_address": "127.0.0.1",
}
replay_id = str(uuid.uuid4())
profile_id = str(uuid.uuid4())
event = self.create_performance_issue(
contexts={
"trace": {
"trace_id": str(uuid.uuid4().hex),
"span_id": "933e5c9a8e464da9",
"type": "trace",
},
"replay": {"replay_id": replay_id},
"profile": {"profile_id": profile_id},
},
user_data=user_data,
)
query = {
"field": [
"id",
"transaction",
"title",
"release",
"environment",
"user.display",
"device",
"os",
"url",
"runtime",
"replayId",
"profile.id",
"transaction.duration",
"timestamp",
],
"statsPeriod": "1h",
"query": f"project:{event.group.project.slug} issue:{event.group.qualified_short_id}",
"dataset": "issuePlatform",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
data = response.data["data"][0]
assert data == {
"id": event.event_id,
"transaction": event.transaction,
"project.name": event.project.name.lower(),
"title": event.group.title,
"release": event.release,
"environment": event.get_environment().name,
"user.display": user_data["email"],
"device": "Mac",
"os": "",
"url": event.interfaces.data["request"].full_url,
"runtime": dict(event.get_raw_data()["tags"])["runtime"],
"replayId": replay_id.replace("-", ""),
"profile.id": profile_id.replace("-", ""),
"transaction.duration": 3000,
"timestamp": event.datetime.replace(microsecond=0).isoformat(),
}
class OrganizationEventsErrorsDatasetEndpointTest(OrganizationEventsEndpointTestBase):
def test_status(self):
with self.options({"issues.group_attributes.send_kafka": True}):
self.store_event(
data={
"event_id": "a" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group1"],
},
project_id=self.project.id,
).group
group_2 = self.store_event(
data={
"event_id": "b" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group2"],
},
project_id=self.project.id,
).group
group_3 = self.store_event(
data={
"event_id": "c" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group3"],
},
project_id=self.project.id,
).group
query = {
"field": ["count()"],
"statsPeriod": "2h",
"query": "status:unresolved",
"dataset": "errors",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert response.data["data"][0]["count()"] == 3
group_2.status = GroupStatus.IGNORED
group_2.substatus = GroupSubStatus.FOREVER
group_2.save(update_fields=["status", "substatus"])
group_3.status = GroupStatus.IGNORED
group_3.substatus = GroupSubStatus.FOREVER
group_3.save(update_fields=["status", "substatus"])
# XXX: Snuba caches query results, so change the time period so that the query
# changes enough to bust the cache.
query["statsPeriod"] = "3h"
response = self.do_request(query)
assert response.status_code == 200, response.content
assert response.data["data"][0]["count()"] == 1
def test_is_status(self):
with self.options({"issues.group_attributes.send_kafka": True}):
self.store_event(
data={
"event_id": "a" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group1"],
},
project_id=self.project.id,
).group
group_2 = self.store_event(
data={
"event_id": "b" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group2"],
},
project_id=self.project.id,
).group
group_3 = self.store_event(
data={
"event_id": "c" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group3"],
},
project_id=self.project.id,
).group
query = {
"field": ["count()"],
"statsPeriod": "2h",
"query": "is:unresolved",
"dataset": "errors",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert response.data["data"][0]["count()"] == 3
group_2.status = GroupStatus.IGNORED
group_2.substatus = GroupSubStatus.FOREVER
group_2.save(update_fields=["status", "substatus"])
group_3.status = GroupStatus.IGNORED
group_3.substatus = GroupSubStatus.FOREVER
group_3.save(update_fields=["status", "substatus"])
# XXX: Snuba caches query results, so change the time period so that the query
# changes enough to bust the cache.
query["statsPeriod"] = "3h"
response = self.do_request(query)
assert response.status_code == 200, response.content
assert response.data["data"][0]["count()"] == 1
def test_short_group_id(self):
group_1 = self.store_event(
data={
"event_id": "a" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group1"],
},
project_id=self.project.id,
).group
query = {
"field": ["count()"],
"statsPeriod": "1h",
"query": f"project:{group_1.project.slug} issue:{group_1.qualified_short_id}",
"dataset": "errors",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert response.data["data"][0]["count()"] == 1
def test_user_display(self):
with self.options({"issues.group_attributes.send_kafka": True}):
group_1 = self.store_event(
data={
"event_id": "a" * 32,
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group1"],
"user": {
"email": "hellboy@bar.com",
},
},
project_id=self.project.id,
).group
features = {
"organizations:discover-basic": True,
"organizations:global-views": True,
}
query = {
"field": ["user.display"],
"query": f"user.display:hell* issue.id:{group_1.id}",
"statsPeriod": "24h",
"dataset": "errors",
}
response = self.do_request(query, features=features)
assert response.status_code == 200, response.content
data = response.data["data"]
assert len(data) == 1
result = {r["user.display"] for r in data}
assert result == {"hellboy@bar.com"}
def test_performance_score(self):
self.transaction_data["measurements"] = {
"score.lcp": {"value": 0.03},
"score.weight.lcp": {"value": 0.3},
}
self.store_event(self.transaction_data, self.project.id)
self.transaction_data["measurements"] = {
"score.lcp": {"value": 1.0},
"score.weight.lcp": {"value": 1.0},
}
self.store_event(self.transaction_data, self.project.id)
query = {
"field": [
"performance_score(measurements.score.lcp)",
]
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0] == {
"performance_score(measurements.score.lcp)": 0.7923076923076923,
}
def test_weighted_performance_score(self):
self.transaction_data["measurements"] = {
"score.lcp": {"value": 0.03},
"score.weight.lcp": {"value": 0.3},
"score.total": {"value": 0.03},
}
self.store_event(self.transaction_data, self.project.id)
self.transaction_data["measurements"] = {
"score.lcp": {"value": 1.0},
"score.weight.lcp": {"value": 1.0},
"score.total": {"value": 1.0},
}
self.store_event(self.transaction_data, self.project.id)
self.transaction_data["measurements"] = {
"score.total": {"value": 0.0},
}
self.store_event(self.transaction_data, self.project.id)
query = {
"field": [
"weighted_performance_score(measurements.score.lcp)",
]
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0] == {
"weighted_performance_score(measurements.score.lcp)": 0.3433333333333333,
}
def test_invalid_performance_score_column(self):
self.transaction_data["measurements"] = {
"score.total": {"value": 0.0},
}
self.store_event(self.transaction_data, self.project.id)
query = {
"field": [
"performance_score(measurements.score.fp)",
]
}
response = self.do_request(query)
assert response.status_code == 400, response.content
def test_invalid_weighted_performance_score_column(self):
self.transaction_data["measurements"] = {
"score.total": {"value": 0.0},
}
self.store_event(self.transaction_data, self.project.id)
query = {
"field": [
"weighted_performance_score(measurements.score.fp)",
]
}
response = self.do_request(query)
assert response.status_code == 400, response.content
def test_all_events_fields(self):
user_data = {
"id": self.user.id,
"username": "user",
"email": "hellboy@bar.com",
"ip_address": "127.0.0.1",
}
replay_id = str(uuid.uuid4())
with self.options({"issues.group_attributes.send_kafka": True}):
event = self.store_event(
data={
"timestamp": self.ten_mins_ago_iso,
"fingerprint": ["group1"],
"contexts": {
"trace": {
"trace_id": str(uuid.uuid4().hex),
"span_id": "933e5c9a8e464da9",
"type": "trace",
},
"replay": {"replay_id": replay_id},
},
"tags": {"device": "Mac"},
"user": user_data,
},
project_id=self.project.id,
)
query = {
"field": [
"id",
"transaction",
"title",
"release",
"environment",
"user.display",
"device",
"os",
"replayId",
"timestamp",
],
"statsPeriod": "2d",
"query": "is:unresolved",
"dataset": "errors",
"sort": "-title",
}
response = self.do_request(query)
assert response.status_code == 200, response.content
data = response.data["data"][0]
assert data == {
"id": event.event_id,
"events.transaction": "",
"project.name": event.project.name.lower(),
"events.title": event.group.title,
"release": event.release,
"events.environment": None,
"user.display": user_data["email"],
"device": "Mac",
"os": "",
"replayId": replay_id,
"events.timestamp": event.datetime.replace(microsecond=0).isoformat(),
}
def test_opportunity_score(self):
self.transaction_data["measurements"] = {
"score.lcp": {"value": 0.03},
"score.weight.lcp": {"value": 0.3},
"score.fcp": {"value": 0.4},
"score.weight.fcp": {"value": 0.7},
"score.total": {"value": 0.43},
}
self.store_event(self.transaction_data, self.project.id)
self.transaction_data["measurements"] = {
"score.lcp": {"value": 1.0},
"score.weight.lcp": {"value": 1.0},
"score.total": {"value": 1.0},
}
self.store_event(self.transaction_data, self.project.id)
self.transaction_data["measurements"] = {
"score.total": {"value": 0.0},
}
self.store_event(self.transaction_data, self.project.id)
query = {
"field": [
"opportunity_score(measurements.score.lcp)",
"opportunity_score(measurements.score.total)",
]
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0] == {
"opportunity_score(measurements.score.lcp)": 0.27,
"opportunity_score(measurements.score.total)": 1.57,
}
def test_count_scores(self):
self.transaction_data["measurements"] = {
"score.lcp": {"value": 0.03},
"score.total": {"value": 0.43},
}
self.store_event(self.transaction_data, self.project.id)
self.transaction_data["measurements"] = {
"score.total": {"value": 1.0},
}
self.store_event(self.transaction_data, self.project.id)
self.transaction_data["measurements"] = {
"score.total": {"value": 0.0},
}
self.store_event(self.transaction_data, self.project.id)
query = {
"field": [
"count_scores(measurements.score.lcp)",
"count_scores(measurements.score.total)",
]
}
response = self.do_request(query)
assert response.status_code == 200, response.content
assert len(response.data["data"]) == 1
assert response.data["data"][0] == {
"count_scores(measurements.score.lcp)": 1,
"count_scores(measurements.score.total)": 3,
}