def test_reference_event(self):
two_minutes = before_now(minutes=2)
five_minutes = before_now(minutes=5)
self.store_event(
data={
"event_id": "a" * 32,
"message": "oh no",
"timestamp": iso_format(two_minutes)
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "b" * 32,
"message": "no match",
"timestamp": iso_format(two_minutes),
},
project_id=self.project.id,
)
ref = discover.ReferenceEvent(
self.organization,
"{}:{}".format(self.project.slug, "a" * 32),
["message", "count()"],
two_minutes,
two_minutes,
)
result = discover.query(
selected_columns=["id", "message"],
query="",
reference_event=ref,
params={"project_id": [self.project.id]},
)
assert len(result["data"]) == 2
for row in result["data"]:
assert row["message"] == "oh no"
# make an invalid reference with old dates
ref = discover.ReferenceEvent(
self.organization,
"{}:{}".format(self.project.slug, "a" * 32),
["message", "count()"],
five_minutes,
five_minutes,
)
with pytest.raises(InvalidSearchQuery):
discover.query(
selected_columns=["id", "message"],
query="",
reference_event=ref,
params={"project_id": [self.project.id]},
)
def test_reference_event_matching(self):
# Create an event that won't match the reference
self.store_event(
data={
"event_id": "d" * 32,
"message": "completely bad",
"type": "default",
"platform": "python",
"timestamp": iso_format(before_now(minutes=2)),
"tags": {
"foo": "1"
},
},
project_id=self.project.id,
)
reference = discover.ReferenceEvent(
self.organization, "{}:{}".format(self.project.slug,
self.event.id), ["message"])
result = discover.get_pagination_ids(
self.event,
"foo:1",
{
"project_id": [self.project.id],
"end": self.min_ago,
"start": self.day_ago
},
reference_event=reference,
)
assert result.previous == "a" * 32
assert result.next == "c" * 32
assert result.oldest == "a" * 32
assert result.latest == "c" * 32
def test_geo_field(self):
event = self.store_event(
data={
"message": "oh no!",
"transaction": "/issues/{issue_id}",
"user": {
"id": 1,
"geo": {
"country_code": "US",
"region": "CA",
"city": "San Francisco"
},
},
"timestamp": iso_format(before_now(seconds=1)),
},
project_id=self.project.id,
)
slug = "{}:{}".format(self.project.slug, event.event_id)
ref = discover.ReferenceEvent(
self.organization, slug,
["geo.city", "geo.region", "geo.country_code"])
result = discover.create_reference_event_conditions(ref)
assert result == [
["geo.city", "=", "San Francisco"],
["geo.region", "=", "CA"],
["geo.country_code", "=", "US"],
]
def test_reference_event(self):
self.store_event(
data={
"event_id": "a" * 32,
"message": "oh no",
"timestamp": iso_format(before_now(minutes=2)),
},
project_id=self.project.id,
)
self.store_event(
data={
"event_id": "b" * 32,
"message": "no match",
"timestamp": iso_format(before_now(minutes=2)),
},
project_id=self.project.id,
)
ref = discover.ReferenceEvent(
self.organization, "{}:{}".format(self.project.slug, "a" * 32),
["message", "count()"])
result = discover.query(
selected_columns=["id", "message"],
query="",
reference_event=ref,
params={"project_id": [self.project.id]},
)
assert len(result["data"]) == 2
for row in result["data"]:
assert row["message"] == "oh no"
def test_issue_field(self):
event = self.store_event(
data={
"message": "oh no!",
"timestamp": iso_format(before_now(seconds=1)),
"contexts": {
"os": {
"version": "10.14.6",
"type": "os",
"name": "Mac OS X"
},
"browser": {
"type": "browser",
"name": "Firefox",
"version": "69"
},
"gpu": {
"type": "gpu",
"name": "nvidia 8600",
"vendor": "nvidia"
},
},
},
project_id=self.project.id,
)
slug = "{}:{}".format(self.project.slug, event.event_id)
ref = discover.ReferenceEvent(self.organization, slug, ["issue.id"])
result = discover.create_reference_event_conditions(ref)
assert result == [["issue.id", "=", event.group_id]]
def get(self, request, organization, project_slug, event_id):
if not features.has("organizations:discover-basic",
organization,
actor=request.user):
return Response(status=404)
try:
params = self.get_filter_params(request, organization)
except NoProjects:
return Response(status=404)
try:
project = Project.objects.get(slug=project_slug,
organization_id=organization.id,
status=ProjectStatus.VISIBLE)
except Project.DoesNotExist:
return Response(status=404)
# Check access to the project as this endpoint doesn't use membership checks done
# get_filter_params().
if not request.access.has_project_access(project):
return Response(status=404)
# We return the requested event if we find a match regardless of whether
# it occurred within the range specified
event = eventstore.get_event_by_id(project.id, event_id)
if event is None:
return Response({"detail": "Event not found"}, status=404)
reference = None
fields = [
field for field in request.query_params.getlist("field")
if not field.strip() == ""
]
if fields:
event_slug = u"{}:{}".format(project.slug, event_id)
reference = discover.ReferenceEvent(organization, event_slug,
fields, event.datetime,
event.datetime)
try:
pagination = discover.get_pagination_ids(
event=event,
query=request.query_params.get("query"),
params=params,
organization=organization,
reference_event=reference,
referrer="api.organization-event-details",
)
except discover.InvalidSearchQuery as err:
raise ParseError(detail=six.text_type(err))
data = serialize(event)
data["nextEventID"] = pagination.next
data["previousEventID"] = pagination.previous
data["oldestEventID"] = pagination.oldest
data["latestEventID"] = pagination.latest
data["projectSlug"] = project_slug
return Response(data)
def test_unknown_project(self):
event = self.store_event(
data={
"message": "oh no!",
"timestamp": iso_format(before_now(seconds=1))
},
project_id=self.project.id,
)
ref = discover.ReferenceEvent(self.organization,
"nope:{}".format(event.event_id), [])
with pytest.raises(InvalidSearchQuery):
discover.create_reference_event_conditions(ref)
def test_no_fields(self):
event = self.store_event(
data={
"message": "oh no!",
"transaction": "/issues/{issue_id}",
"timestamp": iso_format(before_now(seconds=1)),
},
project_id=self.project.id,
)
slug = "{}:{}".format(self.project.slug, event.event_id)
ref = discover.ReferenceEvent(self.organization, slug, [])
result = discover.create_reference_event_conditions(ref)
assert len(result) == 0
def test_stack_field(self):
data = load_data("php")
data["timestamp"] = iso_format(before_now(seconds=1))
event = self.store_event(data=data, project_id=self.project.id)
slug = "{}:{}".format(self.project.slug, event.event_id)
ref = discover.ReferenceEvent(self.organization, slug,
["stack.filename", "stack.function"])
result = discover.create_reference_event_conditions(ref)
assert result == [
[
"stack.filename", "=",
"/Users/example/Development/raven-php/bin/raven"
],
["stack.function", "=", "raven_cli_test"],
]
def test_tag_value(self):
event = self.store_event(
data={
"message": "oh no!",
"timestamp": iso_format(before_now(seconds=1)),
"tags": {
"customer_id": 1,
"color": "red"
},
},
project_id=self.project.id,
)
slug = "{}:{}".format(self.project.slug, event.event_id)
ref = discover.ReferenceEvent(self.organization, slug,
["nope", "color", "customer_id"])
result = discover.create_reference_event_conditions(ref)
assert result == [["color", "=", "red"], ["customer_id", "=", "1"]]
def test_error_field(self):
data = load_data("php")
data["timestamp"] = iso_format(before_now(seconds=1))
event = self.store_event(data=data, project_id=self.project.id)
slug = "{}:{}".format(self.project.slug, event.event_id)
ref = discover.ReferenceEvent(
self.organization, slug,
["error.value", "error.type", "error.handled"])
result = discover.create_reference_event_conditions(ref)
assert result == [
[
"error.value", "=",
"This is a test exception sent from the Raven CLI."
],
["error.type", "=", "Exception"],
]
def test_sdk_field(self):
event = self.store_event(
data={
"message": "oh no!",
"transaction": "/issues/{issue_id}",
"sdk": {
"name": "sentry-python",
"version": "5.0.12"
},
"timestamp": iso_format(before_now(seconds=1)),
},
project_id=self.project.id,
)
slug = "{}:{}".format(self.project.slug, event.event_id)
ref = discover.ReferenceEvent(self.organization, slug,
["sdk.version", "sdk.name"])
result = discover.create_reference_event_conditions(ref)
assert result == [["sdk.version", "=", "5.0.12"],
["sdk.name", "=", "sentry-python"]]
def test_reference_event(self):
ref = discover.ReferenceEvent(
self.organization,
"{}:{}".format(self.project.slug, "a" * 32),
["message", "count()", "last_seen"],
)
result = discover.timeseries_query(
selected_columns=["count()"],
query="",
params={
"start": self.day_ago,
"end": self.day_ago + timedelta(hours=3),
"project_id": [self.project.id],
},
reference_event=ref,
rollup=3600,
)
assert len(result.data) == 4
assert [1,
1] == [val["count"] for val in result.data if "count" in val]
def reference_event(self, request, organization, start, end):
fields = request.GET.getlist("field")[:]
reference_event_id = request.GET.get("referenceEvent")
if reference_event_id:
return discover.ReferenceEvent(organization, reference_event_id,
fields, start, end)
def test_unknown_event_and_no_fields(self):
slug = "{}:deadbeef".format(self.project.slug)
ref = discover.ReferenceEvent(self.organization, slug, [])
result = discover.create_reference_event_conditions(ref)
assert len(result) == 0
def test_bad_slug_format(self):
ref = discover.ReferenceEvent(self.organization, "lol", ["title"])
with pytest.raises(InvalidSearchQuery):
discover.create_reference_event_conditions(ref)
def test_unknown_event(self):
with pytest.raises(InvalidSearchQuery):
slug = "{}:deadbeef".format(self.project.slug)
ref = discover.ReferenceEvent(self.organization, slug, ["message"])
discover.create_reference_event_conditions(ref)
