class TagStorageTest(TestCase, SnubaTestCase): def setUp(self): super(TagStorageTest, self).setUp() self.ts = SnubaTagStorage() self.proj1 = self.create_project() self.proj1env1 = self.create_environment(project=self.proj1, name="test") self.proj1env2 = self.create_environment(project=self.proj1, name="test2") self.proj1group1 = self.create_group(self.proj1) self.proj1group2 = self.create_group(self.proj1) hash1 = "1" * 32 hash2 = "2" * 32 GroupHash.objects.create(project=self.proj1, group=self.proj1group1, hash=hash1) GroupHash.objects.create(project=self.proj1, group=self.proj1group2, hash=hash2) self.now = timezone.now().replace(microsecond=0) data = json.dumps([{ "event_id": six.text_type(r) * 32, "primary_hash": hash1, "group_id": self.proj1group1.id, "project_id": self.proj1.id, "message": "message 1", "platform": "python", "datetime": (self.now - timedelta(seconds=r) ).strftime("%Y-%m-%dT%H:%M:%S.%fZ"), "data": { "received": calendar.timegm(self.now.timetuple()) - r, "tags": { "foo": "bar", "baz": "quux", "environment": self.proj1env1.name, "sentry:release": 100 * r, "sentry:user": u"id:user{}".format(r), }, "user": { "id": u"user{}".format(r), "email": u"user{}@sentry.io".format(r) }, }, } for r in [1, 2]] + [{ "event_id": "3" * 32, "primary_hash": hash2, "group_id": self.proj1group2.id, "project_id": self.proj1.id, "message": "message 2", "platform": "python", "datetime": (self.now - timedelta(seconds=2) ).strftime("%Y-%m-%dT%H:%M:%S.%fZ"), "data": { "received": calendar.timegm(self.now.timetuple()) - 2, "tags": { "browser": "chrome", "environment": self.proj1env1.name, "sentry:user": "******", }, "user": { "id": "user1" }, }, }] + [{ "event_id": "4" * 32, "primary_hash": hash2, "group_id": self.proj1group1.id, "project_id": self.proj1.id, "message": "message 2", "platform": "python", "datetime": (self.now - timedelta(seconds=2) ).strftime("%Y-%m-%dT%H:%M:%S.%fZ"), "data": { "received": calendar.timegm(self.now.timetuple()) - 2, "tags": { "foo": "bar", "environment": self.proj1env2.name }, "user": { "id": "user1" }, }, }]) assert (requests.post(settings.SENTRY_SNUBA + "/tests/events/insert", data=data).status_code == 200) def test_get_group_tag_keys_and_top_values(self): result = list( self.ts.get_group_tag_keys_and_top_values(self.proj1.id, self.proj1group1.id, [self.proj1env1.id])) tags = [r.key for r in result] assert set(tags) == set( ["foo", "baz", "environment", "sentry:release", "sentry:user"]) result.sort(key=lambda r: r.key) assert result[0].key == "baz" assert result[0].top_values[0].value == "quux" assert result[0].count == 2 assert result[3].key == "sentry:release" assert result[3].count == 2 top_release_values = result[3].top_values assert len(top_release_values) == 2 assert set(v.value for v in top_release_values) == set(["100", "200"]) assert all(v.times_seen == 1 for v in top_release_values) # Now with only a specific set of keys, result = list( self.ts.get_group_tag_keys_and_top_values( self.proj1.id, self.proj1group1.id, [self.proj1env1.id], keys=["environment", "sentry:release"], )) tags = [r.key for r in result] assert set(tags) == set(["environment", "sentry:release"]) result.sort(key=lambda r: r.key) assert result[0].key == "environment" assert result[0].top_values[0].value == "test" assert result[1].key == "sentry:release" top_release_values = result[1].top_values assert len(top_release_values) == 2 assert set(v.value for v in top_release_values) == set(["100", "200"]) assert all(v.times_seen == 1 for v in top_release_values) def test_get_top_group_tag_values(self): resp = self.ts.get_top_group_tag_values(self.proj1.id, self.proj1group1.id, self.proj1env1.id, "foo", 1) assert len(resp) == 1 assert resp[0].times_seen == 2 assert resp[0].key == "foo" assert resp[0].value == "bar" assert resp[0].group_id == self.proj1group1.id def test_get_group_tag_value_count(self): assert (self.ts.get_group_tag_value_count(self.proj1.id, self.proj1group1.id, self.proj1env1.id, "foo") == 2) def test_get_tag_keys(self): expected_keys = set([ "baz", "browser", "environment", "foo", "sentry:release", "sentry:user" ]) keys = { k.key: k for k in self.ts.get_tag_keys(project_id=self.proj1.id, environment_id=self.proj1env1.id) } assert set(keys) == expected_keys keys = { k.key: k for k in self.ts.get_tag_keys(project_id=self.proj1.id, environment_id=self.proj1env1.id, include_values_seen=True) } assert set(keys) == expected_keys def test_get_group_tag_key(self): with pytest.raises(GroupTagKeyNotFound): self.ts.get_group_tag_key( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key="notreal", ) assert (self.ts.get_group_tag_key( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key="foo", ).key == "foo") keys = { k.key: k for k in self.ts.get_group_tag_keys( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_ids=[self.proj1env1.id], ) } assert set(keys) == set( ["baz", "environment", "foo", "sentry:release", "sentry:user"]) def test_get_group_tag_value(self): with pytest.raises(GroupTagValueNotFound): self.ts.get_group_tag_value( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key="foo", value="notreal", ) assert self.ts.get_group_tag_values( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key="notreal", ) == set([]) assert (list( self.ts.get_group_tag_values( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key="foo", ))[0].value == "bar") assert (self.ts.get_group_tag_value( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key="foo", value="bar", ).value == "bar") def test_get_tag_key(self): with pytest.raises(TagKeyNotFound): self.ts.get_tag_key(project_id=self.proj1.id, environment_id=self.proj1env1.id, key="notreal") def test_get_tag_value(self): with pytest.raises(TagValueNotFound): self.ts.get_tag_value( project_id=self.proj1.id, environment_id=self.proj1env1.id, key="foo", value="notreal", ) def test_get_groups_user_counts(self): assert self.ts.get_groups_user_counts( project_ids=[self.proj1.id], group_ids=[self.proj1group1.id, self.proj1group2.id], environment_ids=[self.proj1env1.id], ) == { self.proj1group1.id: 2, self.proj1group2.id: 1 } # test filtering by date range where there shouldn't be results assert (self.ts.get_groups_user_counts( project_ids=[self.proj1.id], group_ids=[self.proj1group1.id, self.proj1group2.id], environment_ids=[self.proj1env1.id], start=self.now - timedelta(days=5), end=self.now - timedelta(days=4), ) == {}) def test_get_releases(self): assert (self.ts.get_first_release( project_id=self.proj1.id, group_id=self.proj1group1.id) == "200") assert (self.ts.get_first_release( project_id=self.proj1.id, group_id=self.proj1group2.id) is None) assert (self.ts.get_last_release( project_id=self.proj1.id, group_id=self.proj1group1.id) == "100") assert (self.ts.get_last_release(project_id=self.proj1.id, group_id=self.proj1group2.id) is None) def test_get_group_ids_for_users(self): assert self.ts.get_group_ids_for_users( [self.proj1.id], [EventUser(project_id=self.proj1.id, ident="user1")]) == set( [self.proj1group1.id, self.proj1group2.id]) assert self.ts.get_group_ids_for_users( [self.proj1.id], [EventUser(project_id=self.proj1.id, ident="user2")]) == set( [self.proj1group1.id]) def test_get_group_tag_values_for_users(self): result = self.ts.get_group_tag_values_for_users( [EventUser(project_id=self.proj1.id, ident="user1")]) assert len(result) == 2 assert set(v.group_id for v in result) == set( [self.proj1group1.id, self.proj1group2.id]) assert set(v.last_seen for v in result) == set( [self.now - timedelta(seconds=1), self.now - timedelta(seconds=2)]) result.sort(key=lambda x: x.last_seen) assert result[0].last_seen == self.now - timedelta(seconds=2) assert result[1].last_seen == self.now - timedelta(seconds=1) for v in result: assert v.value == "user1" result = self.ts.get_group_tag_values_for_users( [EventUser(project_id=self.proj1.id, ident="user2")]) assert len(result) == 1 assert result[0].value == "user2" assert result[0].last_seen == self.now - timedelta(seconds=2) def test_get_release_tags(self): tags = list(self.ts.get_release_tags([self.proj1.id], None, ["100"])) assert len(tags) == 1 one_second_ago = self.now - timedelta(seconds=1) assert tags[0].last_seen == one_second_ago assert tags[0].first_seen == one_second_ago assert tags[0].times_seen == 1 assert tags[0].key == "sentry:release" def test_get_group_event_filter(self): assert self.ts.get_group_event_filter(self.proj1.id, self.proj1group1.id, [self.proj1env1.id], {"foo": "bar"}, None, None) == { "event_id__in": set(["1" * 32, "2" * 32]) } assert self.ts.get_group_event_filter( self.proj1.id, self.proj1group1.id, [self.proj1env1.id], {"foo": "bar"}, (self.now - timedelta(seconds=1)), None, ) == { "event_id__in": set(["1" * 32]) } assert self.ts.get_group_event_filter( self.proj1.id, self.proj1group1.id, [self.proj1env1.id], {"foo": "bar"}, None, (self.now - timedelta(seconds=1)), ) == { "event_id__in": set(["2" * 32]) } assert self.ts.get_group_event_filter( self.proj1.id, self.proj1group1.id, [self.proj1env1.id, self.proj1env2.id], {"foo": "bar"}, None, None, ) == { "event_id__in": set(["1" * 32, "2" * 32, "4" * 32]) } assert self.ts.get_group_event_filter( self.proj1.id, self.proj1group1.id, [self.proj1env1.id], { "foo": "bar", "sentry:release": "200" }, # AND None, None, ) == { "event_id__in": set(["2" * 32]) } assert self.ts.get_group_event_filter( self.proj1.id, self.proj1group2.id, [self.proj1env1.id], {"browser": "chrome"}, None, None, ) == { "event_id__in": set(["3" * 32]) } assert (self.ts.get_group_event_filter( self.proj1.id, self.proj1group2.id, [self.proj1env1.id], {"browser": "ie"}, None, None, ) is None) def test_get_tag_value_paginator(self): from sentry.tagstore.types import TagValue assert list( self.ts.get_tag_value_paginator( self.proj1.id, self.proj1env1.id, "sentry:user").get_result(10)) == [ TagValue( key="sentry:user", value="id:user1", times_seen=2, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=1), ), TagValue( key="sentry:user", value="id:user2", times_seen=1, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=2), ), ] assert list( self.ts.get_tag_value_paginator( self.proj1.id, self.proj1env1.id, "sentry:user", query="user1").get_result(10)) == [ TagValue( key="sentry:user", value="id:user1", times_seen=2, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=1), ) ] def test_get_group_tag_value_iter(self): from sentry.tagstore.types import GroupTagValue assert list( self.ts.get_group_tag_value_iter( self.proj1.id, self.proj1group1.id, self.proj1env1.id, "sentry:user")) == [ GroupTagValue( group_id=self.proj1group1.id, key="sentry:user", value="id:user1", times_seen=1, first_seen=self.now - timedelta(seconds=1), last_seen=self.now - timedelta(seconds=1), ), GroupTagValue( group_id=self.proj1group1.id, key="sentry:user", value="id:user2", times_seen=1, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=2), ), ] def test_get_group_tag_value_paginator(self): from sentry.tagstore.types import GroupTagValue assert list( self.ts.get_group_tag_value_paginator( self.proj1.id, self.proj1group1.id, self.proj1env1.id, "sentry:user").get_result(10)) == [ GroupTagValue( group_id=self.proj1group1.id, key="sentry:user", value="id:user1", times_seen=1, first_seen=self.now - timedelta(seconds=1), last_seen=self.now - timedelta(seconds=1), ), GroupTagValue( group_id=self.proj1group1.id, key="sentry:user", value="id:user2", times_seen=1, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=2), ), ] def test_get_group_seen_values_for_environments(self): assert self.ts.get_group_seen_values_for_environments( [self.proj1.id], [self.proj1group1.id], [self.proj1env1.id]) == { self.proj1group1.id: { "first_seen": self.now - timedelta(seconds=2), "last_seen": self.now - timedelta(seconds=1), "times_seen": 2, } } # test where there should be no results because of time filters assert (self.ts.get_group_seen_values_for_environments( [self.proj1.id], [self.proj1group1.id], [self.proj1env1.id], start=self.now - timedelta(hours=5), end=self.now - timedelta(hours=4), ) == {})
class TagStorageTest(TestCase, SnubaTestCase): def setUp(self): super(TagStorageTest, self).setUp() self.ts = SnubaTagStorage() self.proj1 = self.create_project() self.proj1env1 = self.create_environment(project=self.proj1, name="test") self.proj1env2 = self.create_environment(project=self.proj1, name="test2") self.proj1group1 = self.create_group(self.proj1) self.proj1group2 = self.create_group(self.proj1) hash1 = "1" * 32 hash2 = "2" * 32 GroupHash.objects.create(project=self.proj1, group=self.proj1group1, hash=hash1) GroupHash.objects.create(project=self.proj1, group=self.proj1group2, hash=hash2) self.now = timezone.now().replace(microsecond=0) data = json.dumps( [ { "event_id": six.text_type(r) * 32, "primary_hash": hash1, "group_id": self.proj1group1.id, "project_id": self.proj1.id, "message": "message 1", "platform": "python", "datetime": (self.now - timedelta(seconds=r)).strftime("%Y-%m-%dT%H:%M:%S.%fZ"), "data": { "received": calendar.timegm(self.now.timetuple()) - r, "tags": { "foo": "bar", "baz": "quux", "environment": self.proj1env1.name, "sentry:release": 100 * r, "sentry:user": u"id:user{}".format(r), }, "user": {"id": u"user{}".format(r), "email": u"user{}@sentry.io".format(r)}, "exception": {"values": [{"stacktrace": {"frames": [{"lineno": 29}]}}]}, }, } for r in [1, 2] ] + [ { "event_id": "3" * 32, "primary_hash": hash2, "group_id": self.proj1group2.id, "project_id": self.proj1.id, "message": "message 2", "platform": "python", "datetime": (self.now - timedelta(seconds=2)).strftime("%Y-%m-%dT%H:%M:%S.%fZ"), "data": { "received": calendar.timegm(self.now.timetuple()) - 2, "tags": { "browser": "chrome", "environment": self.proj1env1.name, "sentry:user": "******", }, "user": {"id": "user1"}, }, } ] + [ { "event_id": "4" * 32, "primary_hash": hash2, "group_id": self.proj1group1.id, "project_id": self.proj1.id, "message": "message 2", "platform": "python", "datetime": (self.now - timedelta(seconds=2)).strftime("%Y-%m-%dT%H:%M:%S.%fZ"), "data": { "received": calendar.timegm(self.now.timetuple()) - 2, "tags": {"foo": "bar", "environment": self.proj1env2.name}, "user": {"id": "user1"}, }, } ] ) assert ( requests.post(settings.SENTRY_SNUBA + "/tests/events/insert", data=data).status_code == 200 ) def test_get_group_tag_keys_and_top_values(self): result = list( self.ts.get_group_tag_keys_and_top_values( self.proj1.id, self.proj1group1.id, [self.proj1env1.id] ) ) tags = [r.key for r in result] assert set(tags) == set(["foo", "baz", "environment", "sentry:release", "sentry:user"]) result.sort(key=lambda r: r.key) assert result[0].key == "baz" assert result[0].top_values[0].value == "quux" assert result[0].count == 2 assert result[3].key == "sentry:release" assert result[3].count == 2 top_release_values = result[3].top_values assert len(top_release_values) == 2 assert set(v.value for v in top_release_values) == set(["100", "200"]) assert all(v.times_seen == 1 for v in top_release_values) # Now with only a specific set of keys, result = list( self.ts.get_group_tag_keys_and_top_values( self.proj1.id, self.proj1group1.id, [self.proj1env1.id], keys=["environment", "sentry:release"], ) ) tags = [r.key for r in result] assert set(tags) == set(["environment", "sentry:release"]) result.sort(key=lambda r: r.key) assert result[0].key == "environment" assert result[0].top_values[0].value == "test" assert result[1].key == "sentry:release" top_release_values = result[1].top_values assert len(top_release_values) == 2 assert set(v.value for v in top_release_values) == set(["100", "200"]) assert all(v.times_seen == 1 for v in top_release_values) def test_get_top_group_tag_values(self): resp = self.ts.get_top_group_tag_values( self.proj1.id, self.proj1group1.id, self.proj1env1.id, "foo", 1 ) assert len(resp) == 1 assert resp[0].times_seen == 2 assert resp[0].key == "foo" assert resp[0].value == "bar" assert resp[0].group_id == self.proj1group1.id def test_get_group_tag_value_count(self): assert ( self.ts.get_group_tag_value_count( self.proj1.id, self.proj1group1.id, self.proj1env1.id, "foo" ) == 2 ) def test_get_tag_keys(self): expected_keys = set( ["baz", "browser", "environment", "foo", "sentry:release", "sentry:user"] ) keys = { k.key: k for k in self.ts.get_tag_keys( project_id=self.proj1.id, environment_id=self.proj1env1.id ) } assert set(keys) == expected_keys keys = { k.key: k for k in self.ts.get_tag_keys( project_id=self.proj1.id, environment_id=self.proj1env1.id, include_values_seen=True ) } assert set(keys) == expected_keys def test_get_group_tag_key(self): with pytest.raises(GroupTagKeyNotFound): self.ts.get_group_tag_key( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key="notreal", ) assert ( self.ts.get_group_tag_key( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key="foo", ).key == "foo" ) keys = { k.key: k for k in self.ts.get_group_tag_keys( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_ids=[self.proj1env1.id], ) } assert set(keys) == set(["baz", "environment", "foo", "sentry:release", "sentry:user"]) def test_get_group_tag_value(self): with pytest.raises(GroupTagValueNotFound): self.ts.get_group_tag_value( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key="foo", value="notreal", ) assert self.ts.get_group_tag_values( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key="notreal", ) == set([]) assert ( list( self.ts.get_group_tag_values( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key="foo", ) )[0].value == "bar" ) assert ( self.ts.get_group_tag_value( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key="foo", value="bar", ).value == "bar" ) def test_get_tag_key(self): with pytest.raises(TagKeyNotFound): self.ts.get_tag_key( project_id=self.proj1.id, environment_id=self.proj1env1.id, key="notreal" ) def test_get_tag_value(self): with pytest.raises(TagValueNotFound): self.ts.get_tag_value( project_id=self.proj1.id, environment_id=self.proj1env1.id, key="foo", value="notreal", ) def test_get_tag_value_label(self): assert self.ts.get_tag_value_label("foo", "notreal") == "notreal" assert self.ts.get_tag_value_label("sentry:user", None) is None assert self.ts.get_tag_value_label("sentry:user", "id:stuff") == "stuff" assert self.ts.get_tag_value_label("sentry:user", "email:stuff") == "stuff" assert self.ts.get_tag_value_label("sentry:user", "username:stuff") == "stuff" assert self.ts.get_tag_value_label("sentry:user", "ip:stuff") == "stuff" def test_get_groups_user_counts(self): assert self.ts.get_groups_user_counts( project_ids=[self.proj1.id], group_ids=[self.proj1group1.id, self.proj1group2.id], environment_ids=[self.proj1env1.id], ) == {self.proj1group1.id: 2, self.proj1group2.id: 1} # test filtering by date range where there shouldn't be results assert ( self.ts.get_groups_user_counts( project_ids=[self.proj1.id], group_ids=[self.proj1group1.id, self.proj1group2.id], environment_ids=[self.proj1env1.id], start=self.now - timedelta(days=5), end=self.now - timedelta(days=4), ) == {} ) def test_get_releases(self): assert ( self.ts.get_first_release(project_id=self.proj1.id, group_id=self.proj1group1.id) == "200" ) assert ( self.ts.get_first_release(project_id=self.proj1.id, group_id=self.proj1group2.id) is None ) assert ( self.ts.get_last_release(project_id=self.proj1.id, group_id=self.proj1group1.id) == "100" ) assert ( self.ts.get_last_release(project_id=self.proj1.id, group_id=self.proj1group2.id) is None ) def test_get_group_ids_for_users(self): assert self.ts.get_group_ids_for_users( [self.proj1.id], [EventUser(project_id=self.proj1.id, ident="user1")] ) == set([self.proj1group1.id, self.proj1group2.id]) assert self.ts.get_group_ids_for_users( [self.proj1.id], [EventUser(project_id=self.proj1.id, ident="user2")] ) == set([self.proj1group1.id]) def test_get_group_tag_values_for_users(self): result = self.ts.get_group_tag_values_for_users( [EventUser(project_id=self.proj1.id, ident="user1")] ) assert len(result) == 2 assert set(v.group_id for v in result) == set([self.proj1group1.id, self.proj1group2.id]) assert set(v.last_seen for v in result) == set( [self.now - timedelta(seconds=1), self.now - timedelta(seconds=2)] ) result.sort(key=lambda x: x.last_seen) assert result[0].last_seen == self.now - timedelta(seconds=2) assert result[1].last_seen == self.now - timedelta(seconds=1) for v in result: assert v.value == "user1" result = self.ts.get_group_tag_values_for_users( [EventUser(project_id=self.proj1.id, ident="user2")] ) assert len(result) == 1 assert result[0].value == "user2" assert result[0].last_seen == self.now - timedelta(seconds=2) def test_get_release_tags(self): tags = list(self.ts.get_release_tags([self.proj1.id], None, ["100"])) assert len(tags) == 1 one_second_ago = self.now - timedelta(seconds=1) assert tags[0].last_seen == one_second_ago assert tags[0].first_seen == one_second_ago assert tags[0].times_seen == 1 assert tags[0].key == "sentry:release" def test_get_group_event_filter(self): assert self.ts.get_group_event_filter( self.proj1.id, self.proj1group1.id, [self.proj1env1.id], {"foo": "bar"}, None, None ) == {"event_id__in": set(["1" * 32, "2" * 32])} assert self.ts.get_group_event_filter( self.proj1.id, self.proj1group1.id, [self.proj1env1.id], {"foo": "bar"}, (self.now - timedelta(seconds=1)), None, ) == {"event_id__in": set(["1" * 32])} assert self.ts.get_group_event_filter( self.proj1.id, self.proj1group1.id, [self.proj1env1.id], {"foo": "bar"}, None, (self.now - timedelta(seconds=1)), ) == {"event_id__in": set(["2" * 32])} assert self.ts.get_group_event_filter( self.proj1.id, self.proj1group1.id, [self.proj1env1.id, self.proj1env2.id], {"foo": "bar"}, None, None, ) == {"event_id__in": set(["1" * 32, "2" * 32, "4" * 32])} assert self.ts.get_group_event_filter( self.proj1.id, self.proj1group1.id, [self.proj1env1.id], {"foo": "bar", "sentry:release": "200"}, # AND None, None, ) == {"event_id__in": set(["2" * 32])} assert self.ts.get_group_event_filter( self.proj1.id, self.proj1group2.id, [self.proj1env1.id], {"browser": "chrome"}, None, None, ) == {"event_id__in": set(["3" * 32])} assert ( self.ts.get_group_event_filter( self.proj1.id, self.proj1group2.id, [self.proj1env1.id], {"browser": "ie"}, None, None, ) is None ) def test_get_tag_value_paginator(self): from sentry.tagstore.types import TagValue assert list( self.ts.get_tag_value_paginator( self.proj1.id, self.proj1env1.id, "sentry:user" ).get_result(10) ) == [ TagValue( key="sentry:user", value="id:user1", times_seen=2, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=1), ), TagValue( key="sentry:user", value="id:user2", times_seen=1, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=2), ), ] assert list( self.ts.get_tag_value_paginator( self.proj1.id, self.proj1env1.id, "sentry:user", query="user1" ).get_result(10) ) == [ TagValue( key="sentry:user", value="id:user1", times_seen=2, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=1), ) ] def test_get_tag_value_paginator_with_dates(self): from sentry.tagstore.types import TagValue day_ago = self.now - timedelta(days=1) two_days_ago = self.now - timedelta(days=2) assert list( self.ts.get_tag_value_paginator( self.proj1.id, self.proj1env1.id, "sentry:user", start=day_ago, end=self.now ).get_result(10) ) == [ TagValue( key="sentry:user", value="id:user1", times_seen=2, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=1), ), TagValue( key="sentry:user", value="id:user2", times_seen=1, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=2), ), ] day_ago = self.now - timedelta(days=1) assert ( list( self.ts.get_tag_value_paginator( self.proj1.id, self.proj1env1.id, "sentry:user", start=two_days_ago, end=day_ago ).get_result(10) ) == [] ) def test_numeric_tag_value_paginator(self): from sentry.tagstore.types import TagValue assert list( self.ts.get_tag_value_paginator( self.proj1.id, self.proj1env1.id, "stack.lineno" ).get_result(10) ) == [ TagValue( key="stack.lineno", value="29", times_seen=2, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=1), ) ] assert list( self.ts.get_tag_value_paginator( self.proj1.id, self.proj1env1.id, "stack.lineno", query="30" ).get_result(10) ) == [ TagValue( key="stack.lineno", value="29", times_seen=2, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=1), ) ] def test_get_group_tag_value_iter(self): from sentry.tagstore.types import GroupTagValue assert list( self.ts.get_group_tag_value_iter( self.proj1.id, self.proj1group1.id, self.proj1env1.id, "sentry:user" ) ) == [ GroupTagValue( group_id=self.proj1group1.id, key="sentry:user", value="id:user1", times_seen=1, first_seen=self.now - timedelta(seconds=1), last_seen=self.now - timedelta(seconds=1), ), GroupTagValue( group_id=self.proj1group1.id, key="sentry:user", value="id:user2", times_seen=1, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=2), ), ] def test_get_group_tag_value_paginator(self): from sentry.tagstore.types import GroupTagValue assert list( self.ts.get_group_tag_value_paginator( self.proj1.id, self.proj1group1.id, self.proj1env1.id, "sentry:user" ).get_result(10) ) == [ GroupTagValue( group_id=self.proj1group1.id, key="sentry:user", value="id:user1", times_seen=1, first_seen=self.now - timedelta(seconds=1), last_seen=self.now - timedelta(seconds=1), ), GroupTagValue( group_id=self.proj1group1.id, key="sentry:user", value="id:user2", times_seen=1, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=2), ), ] def test_get_group_seen_values_for_environments(self): assert self.ts.get_group_seen_values_for_environments( [self.proj1.id], [self.proj1group1.id], [self.proj1env1.id] ) == { self.proj1group1.id: { "first_seen": self.now - timedelta(seconds=2), "last_seen": self.now - timedelta(seconds=1), "times_seen": 2, } } # test where there should be no results because of time filters assert ( self.ts.get_group_seen_values_for_environments( [self.proj1.id], [self.proj1group1.id], [self.proj1env1.id], start=self.now - timedelta(hours=5), end=self.now - timedelta(hours=4), ) == {} ) def test_cache_suffix_time(self): starting_key = cache_suffix_time(self.now, 0) finishing_key = cache_suffix_time(self.now + timedelta(seconds=300), 0) assert starting_key != finishing_key def test_cache_suffix_hour_edges(self): """ a suffix should still behave correctly around the end of the hour At a duration of 10 only one key between 0-10 should flip on the hour, the other 9 should flip at different times. """ before = datetime(2019, 9, 5, 17, 59, 59) on_hour = datetime(2019, 9, 5, 18, 0, 0) changed_on_hour = 0 # Check multiple keyhashes so that this test doesn't depend on implementation for key_hash in range(10): before_key = cache_suffix_time(before, key_hash, duration=10) on_key = cache_suffix_time(on_hour, key_hash, duration=10) if before_key != on_key: changed_on_hour += 1 assert changed_on_hour == 1 def test_cache_suffix_day_edges(self): """ a suffix should still behave correctly around the end of a day This test is nearly identical to test_cache_suffix_hour_edges, but is to confirm that date changes don't cause a different behaviour """ before = datetime(2019, 9, 5, 23, 59, 59) next_day = datetime(2019, 9, 6, 0, 0, 0) changed_on_hour = 0 for key_hash in range(10): before_key = cache_suffix_time(before, key_hash, duration=10) next_key = cache_suffix_time(next_day, key_hash, duration=10) if before_key != next_key: changed_on_hour += 1 assert changed_on_hour == 1 def test_cache_suffix_time_matches_duration(self): """ The number of seconds between keys changing should match duration """ previous_key = cache_suffix_time(self.now, 0, duration=10) changes = [] for i in range(21): current_time = self.now + timedelta(seconds=i) current_key = cache_suffix_time(current_time, 0, duration=10) if current_key != previous_key: changes.append(current_time) previous_key = current_key assert len(changes) == 2 assert (changes[1] - changes[0]).total_seconds() == 10 def test_cache_suffix_time_jitter(self): """ Different key hashes should change keys at different times While starting_key and other_key might begin as the same values they should change at different times """ starting_key = cache_suffix_time(self.now, 0, duration=10) for i in range(11): current_key = cache_suffix_time(self.now + timedelta(seconds=i), 0, duration=10) if current_key != starting_key: break other_key = cache_suffix_time(self.now, 5, duration=10) for j in range(11): current_key = cache_suffix_time(self.now + timedelta(seconds=j), 5, duration=10) if current_key != other_key: break assert i != j
class TagStorageTest(SnubaTestCase): def setUp(self): super(TagStorageTest, self).setUp() self.ts = SnubaTagStorage() self.proj1 = self.create_project() self.proj1env1 = self.create_environment(project=self.proj1, name='test') self.proj1group1 = self.create_group(self.proj1) self.proj1group2 = self.create_group(self.proj1) hash1 = '1' * 32 hash2 = '2' * 32 GroupHash.objects.create(project=self.proj1, group=self.proj1group1, hash=hash1) GroupHash.objects.create(project=self.proj1, group=self.proj1group2, hash=hash2) self.now = timezone.now().replace(microsecond=0) data = json.dumps([{ 'event_id': six.text_type(r) * 32, 'primary_hash': hash1, 'group_id': self.proj1group1.id, 'project_id': self.proj1.id, 'message': 'message 1', 'platform': 'python', 'datetime': (self.now - timedelta(seconds=r)).strftime('%Y-%m-%dT%H:%M:%S.%fZ'), 'data': { 'received': calendar.timegm(self.now.timetuple()) - r, 'tags': { 'foo': 'bar', 'baz': 'quux', 'environment': self.proj1env1.name, 'sentry:release': 100 * r, 'sentry:user': u"id:user{}".format(r), }, 'user': { 'id': u"user{}".format(r), 'email': u"user{}@sentry.io".format(r) } }, } for r in [1, 2]] + [{ 'event_id': '3' * 32, 'primary_hash': hash2, 'group_id': self.proj1group2.id, 'project_id': self.proj1.id, 'message': 'message 2', 'platform': 'python', 'datetime': (self.now - timedelta(seconds=2)).strftime('%Y-%m-%dT%H:%M:%S.%fZ'), 'data': { 'received': calendar.timegm(self.now.timetuple()) - 2, 'tags': { 'browser': 'chrome', 'environment': self.proj1env1.name, 'sentry:user': "******", }, 'user': { 'id': "user1" } }, }]) assert requests.post(settings.SENTRY_SNUBA + '/tests/insert', data=data).status_code == 200 def test_get_group_tag_keys_and_top_values(self): result = list(self.ts.get_group_tag_keys_and_top_values( self.proj1.id, self.proj1group1.id, self.proj1env1.id, )) tags = [r.key for r in result] assert set(tags) == set(['foo', 'baz', 'environment', 'sentry:release', 'sentry:user']) result.sort(key=lambda r: r.key) assert result[0].key == 'baz' assert result[0].top_values[0].value == 'quux' assert result[0].values_seen == 1 assert result[0].count == 2 assert result[3].key == 'sentry:release' assert result[3].values_seen == 2 assert result[3].count == 2 top_release_values = result[3].top_values assert len(top_release_values) == 2 assert set(v.value for v in top_release_values) == set(['100', '200']) assert all(v.times_seen == 1 for v in top_release_values) # Now with only a specific set of keys, result = list(self.ts.get_group_tag_keys_and_top_values( self.proj1.id, self.proj1group1.id, self.proj1env1.id, keys=['environment', 'sentry:release'], )) tags = [r.key for r in result] assert set(tags) == set(['environment', 'sentry:release']) result.sort(key=lambda r: r.key) assert result[0].key == 'environment' assert result[0].top_values[0].value == 'test' assert result[1].key == 'sentry:release' top_release_values = result[1].top_values assert len(top_release_values) == 2 assert set(v.value for v in top_release_values) == set(['100', '200']) assert all(v.times_seen == 1 for v in top_release_values) def test_get_top_group_tag_values(self): resp = self.ts.get_top_group_tag_values( self.proj1.id, self.proj1group1.id, self.proj1env1.id, 'foo', 1 ) assert len(resp) == 1 assert resp[0].times_seen == 2 assert resp[0].key == 'foo' assert resp[0].value == 'bar' assert resp[0].group_id == self.proj1group1.id def test_get_group_tag_value_count(self): assert self.ts.get_group_tag_value_count( self.proj1.id, self.proj1group1.id, self.proj1env1.id, 'foo' ) == 2 def test_get_group_tag_key(self): with pytest.raises(GroupTagKeyNotFound): self.ts.get_group_tag_key( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key='notreal', ) assert self.ts.get_group_tag_key( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key='foo', ).key == 'foo' keys = { k.key: k for k in self.ts.get_group_tag_keys( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, ) } assert set(keys) == set(['baz', 'environment', 'foo', 'sentry:release', 'sentry:user']) for k in keys.values(): if k.key not in set(['sentry:release', 'sentry:user']): assert k.values_seen == 1, u'expected {!r} to have 1 unique value'.format(k.key) else: assert k.values_seen == 2 def test_get_group_tag_value(self): with pytest.raises(GroupTagValueNotFound): self.ts.get_group_tag_value( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key='foo', value='notreal', ) assert self.ts.get_group_tag_values( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key='notreal', ) == set([]) assert list(self.ts.get_group_tag_values( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key='foo', ))[0].value == 'bar' assert self.ts.get_group_tag_value( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key='foo', value='bar', ).value == 'bar' def test_get_tag_key(self): with pytest.raises(TagKeyNotFound): self.ts.get_tag_key( project_id=self.proj1.id, environment_id=self.proj1env1.id, key='notreal' ) def test_get_tag_value(self): with pytest.raises(TagValueNotFound): self.ts.get_tag_value( project_id=self.proj1.id, environment_id=self.proj1env1.id, key='foo', value='notreal', ) def test_get_groups_user_counts(self): assert self.ts.get_groups_user_counts( project_ids=[self.proj1.id], group_ids=[self.proj1group1.id, self.proj1group2.id], environment_ids=[self.proj1env1.id] ) == { self.proj1group1.id: 2, self.proj1group2.id: 1, } def test_get_releases(self): assert self.ts.get_first_release( project_id=self.proj1.id, group_id=self.proj1group1.id, ) == '200' assert self.ts.get_first_release( project_id=self.proj1.id, group_id=self.proj1group2.id, ) is None assert self.ts.get_last_release( project_id=self.proj1.id, group_id=self.proj1group1.id, ) == '100' assert self.ts.get_last_release( project_id=self.proj1.id, group_id=self.proj1group2.id, ) is None def test_get_group_ids_for_users(self): assert self.ts.get_group_ids_for_users( [self.proj1.id], [EventUser(project_id=self.proj1.id, ident='user1')] ) == set([self.proj1group1.id, self.proj1group2.id]) assert self.ts.get_group_ids_for_users( [self.proj1.id], [EventUser(project_id=self.proj1.id, ident='user2')] ) == set([self.proj1group1.id]) def test_get_group_tag_values_for_users(self): result = self.ts.get_group_tag_values_for_users( [EventUser(project_id=self.proj1.id, ident='user1')] ) assert len(result) == 2 assert set(v.group_id for v in result) == set([ self.proj1group1.id, self.proj1group2.id, ]) assert set(v.last_seen for v in result) == \ set([self.now - timedelta(seconds=1), self.now - timedelta(seconds=2)]) result.sort(key=lambda x: x.last_seen) assert result[0].last_seen == self.now - timedelta(seconds=2) assert result[1].last_seen == self.now - timedelta(seconds=1) for v in result: assert v.value == 'user1' result = self.ts.get_group_tag_values_for_users( [EventUser(project_id=self.proj1.id, ident='user2')] ) assert len(result) == 1 assert result[0].value == 'user2' assert result[0].last_seen == self.now - timedelta(seconds=2) def test_get_release_tags(self): tags = list( self.ts.get_release_tags( [self.proj1.id], None, ['100'] ) ) assert len(tags) == 1 one_second_ago = self.now - timedelta(seconds=1) assert tags[0].last_seen == one_second_ago assert tags[0].first_seen == one_second_ago assert tags[0].times_seen == 1 assert tags[0].key == 'sentry:release' def test_get_group_event_filter(self): assert self.ts.get_group_event_filter( self.proj1.id, self.proj1group1.id, self.proj1env1.id, { 'foo': 'bar', } ) == {'event_id__in': set(["1" * 32, "2" * 32])} assert self.ts.get_group_event_filter( self.proj1.id, self.proj1group1.id, self.proj1env1.id, { 'foo': 'bar', # AND 'sentry:release': '200' } ) == {'event_id__in': set(["2" * 32])} assert self.ts.get_group_event_filter( self.proj1.id, self.proj1group2.id, self.proj1env1.id, { 'browser': 'chrome' } ) == {'event_id__in': set(["3" * 32])} assert self.ts.get_group_event_filter( self.proj1.id, self.proj1group2.id, self.proj1env1.id, { 'browser': 'ie' } ) is None def test_get_tag_value_paginator(self): from sentry.tagstore.types import TagValue assert list(self.ts.get_tag_value_paginator( self.proj1.id, self.proj1env1.id, 'sentry:user', ).get_result(10)) == [ TagValue( key='sentry:user', value='id:user1', times_seen=2, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=1) ), TagValue( key='sentry:user', value='id:user2', times_seen=1, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=2) ) ] assert list(self.ts.get_tag_value_paginator( self.proj1.id, self.proj1env1.id, 'sentry:user', query='user1', ).get_result(10)) == [ TagValue( key='sentry:user', value='id:user1', times_seen=2, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=1) ), ] def test_get_group_tag_value_iter(self): from sentry.tagstore.types import GroupTagValue assert list(self.ts.get_group_tag_value_iter( self.proj1.id, self.proj1group1.id, self.proj1env1.id, 'sentry:user', )) == [ GroupTagValue( group_id=self.proj1group1.id, key='sentry:user', value='id:user1', times_seen=1, first_seen=self.now - timedelta(seconds=1), last_seen=self.now - timedelta(seconds=1) ), GroupTagValue( group_id=self.proj1group1.id, key='sentry:user', value='id:user2', times_seen=1, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=2) ) ] def test_get_group_tag_value_paginator(self): from sentry.tagstore.types import GroupTagValue assert list(self.ts.get_group_tag_value_paginator( self.proj1.id, self.proj1group1.id, self.proj1env1.id, 'sentry:user', ).get_result(10)) == [ GroupTagValue( group_id=self.proj1group1.id, key='sentry:user', value='id:user1', times_seen=1, first_seen=self.now - timedelta(seconds=1), last_seen=self.now - timedelta(seconds=1) ), GroupTagValue( group_id=self.proj1group1.id, key='sentry:user', value='id:user2', times_seen=1, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=2) ) ]
class TagStorageTest(TestCase, SnubaTestCase): def setUp(self): super().setUp() self.ts = SnubaTagStorage() self.proj1 = self.create_project() env1 = "test" env2 = "test2" self.env3 = Environment.objects.create( organization_id=self.proj1.organization_id, name="test3") self.now = timezone.now().replace(microsecond=0) self.store_event( data={ "event_id": "1" * 32, "message": "message 1", "platform": "python", "environment": env1, "fingerprint": ["group-1"], "timestamp": iso_format(self.now - timedelta(seconds=1)), "tags": { "foo": "bar", "baz": "quux", "sentry:release": 100, "sentry:user": "******", }, "user": { "id": "user1" }, "exception": exception, }, project_id=self.proj1.id, ) self.proj1group1 = self.store_event( data={ "event_id": "2" * 32, "message": "message 1", "platform": "python", "environment": env1, "fingerprint": ["group-1"], "timestamp": iso_format(self.now - timedelta(seconds=2)), "tags": { "foo": "bar", "baz": "quux", "sentry:release": 200, "sentry:user": "******", }, "user": { "id": "user2" }, "exception": exception, }, project_id=self.proj1.id, ).group self.proj1group2 = self.store_event( data={ "event_id": "3" * 32, "message": "message 2", "platform": "python", "environment": env1, "fingerprint": ["group-2"], "timestamp": iso_format(self.now - timedelta(seconds=2)), "tags": { "browser": "chrome", "sentry:user": "******" }, "user": { "id": "user1" }, }, project_id=self.proj1.id, ).group self.store_event( data={ "event_id": "4" * 32, "message": "message2", "platform": "python", "environment": env2, "fingerprint": ["group-1"], "timestamp": iso_format(self.now - timedelta(seconds=2)), "tags": { "foo": "bar" }, }, project_id=self.proj1.id, ) self.proj1env1 = Environment.objects.get(name=env1) self.proj1env2 = Environment.objects.get(name=env2) def test_get_group_tag_keys_and_top_values(self): result = list( self.ts.get_group_tag_keys_and_top_values(self.proj1.id, self.proj1group1.id, [self.proj1env1.id])) tags = [r.key for r in result] assert set(tags) == { "foo", "baz", "environment", "sentry:release", "sentry:user", "level" } result.sort(key=lambda r: r.key) assert result[0].key == "baz" assert result[0].top_values[0].value == "quux" assert result[0].count == 2 assert result[4].key == "sentry:release" assert result[4].count == 2 top_release_values = result[4].top_values assert len(top_release_values) == 2 assert {v.value for v in top_release_values} == {"100", "200"} assert all(v.times_seen == 1 for v in top_release_values) # Now with only a specific set of keys, result = list( self.ts.get_group_tag_keys_and_top_values( self.proj1.id, self.proj1group1.id, [self.proj1env1.id], keys=["environment", "sentry:release"], )) tags = [r.key for r in result] assert set(tags) == {"environment", "sentry:release"} result.sort(key=lambda r: r.key) assert result[0].key == "environment" assert result[0].top_values[0].value == "test" assert result[1].key == "sentry:release" top_release_values = result[1].top_values assert len(top_release_values) == 2 assert {v.value for v in top_release_values} == {"100", "200"} assert all(v.times_seen == 1 for v in top_release_values) def test_get_top_group_tag_values(self): resp = self.ts.get_top_group_tag_values(self.proj1.id, self.proj1group1.id, self.proj1env1.id, "foo", 1) assert len(resp) == 1 assert resp[0].times_seen == 2 assert resp[0].key == "foo" assert resp[0].value == "bar" assert resp[0].group_id == self.proj1group1.id def test_get_group_tag_value_count(self): assert (self.ts.get_group_tag_value_count(self.proj1.id, self.proj1group1.id, self.proj1env1.id, "foo") == 2) def test_get_tag_keys(self): expected_keys = { "baz", "browser", "environment", "foo", "sentry:release", "sentry:user", "level", } keys = { k.key: k for k in self.ts.get_tag_keys(project_id=self.proj1.id, environment_id=self.proj1env1.id) } assert set(keys) == expected_keys keys = { k.key: k for k in self.ts.get_tag_keys(project_id=self.proj1.id, environment_id=self.proj1env1.id, include_values_seen=True) } assert set(keys) == expected_keys def test_get_group_tag_key(self): with pytest.raises(GroupTagKeyNotFound): self.ts.get_group_tag_key( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key="notreal", ) assert (self.ts.get_group_tag_key( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key="foo", ).key == "foo") keys = { k.key: k for k in self.ts.get_group_tag_keys( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_ids=[self.proj1env1.id], ) } assert set(keys) == { "baz", "environment", "foo", "sentry:release", "sentry:user", "level" } def test_get_group_tag_value(self): with pytest.raises(GroupTagValueNotFound): self.ts.get_group_tag_value( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key="foo", value="notreal", ) assert (self.ts.get_group_tag_values( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key="notreal", ) == set()) assert (list( self.ts.get_group_tag_values( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key="foo", ))[0].value == "bar") assert (self.ts.get_group_tag_value( project_id=self.proj1.id, group_id=self.proj1group1.id, environment_id=self.proj1env1.id, key="foo", value="bar", ).value == "bar") def test_get_tag_key(self): with pytest.raises(TagKeyNotFound): self.ts.get_tag_key(project_id=self.proj1.id, environment_id=self.proj1env1.id, key="notreal") def test_get_tag_value(self): with pytest.raises(TagValueNotFound): self.ts.get_tag_value( project_id=self.proj1.id, environment_id=self.proj1env1.id, key="foo", value="notreal", ) def test_get_tag_value_label(self): assert self.ts.get_tag_value_label("foo", "notreal") == "notreal" assert self.ts.get_tag_value_label("sentry:user", None) is None assert self.ts.get_tag_value_label("sentry:user", "id:stuff") == "stuff" assert self.ts.get_tag_value_label("sentry:user", "email:stuff") == "stuff" assert self.ts.get_tag_value_label("sentry:user", "username:stuff") == "stuff" assert self.ts.get_tag_value_label("sentry:user", "ip:stuff") == "stuff" def test_get_groups_user_counts(self): assert (self.ts.get_groups_user_counts( project_ids=[self.proj1.id], group_ids=[self.proj1group1.id, self.proj1group2.id], environment_ids=[self.proj1env1.id], ) == { self.proj1group1.id: 2, self.proj1group2.id: 1 }) # test filtering by date range where there shouldn't be results assert (self.ts.get_groups_user_counts( project_ids=[self.proj1.id], group_ids=[self.proj1group1.id, self.proj1group2.id], environment_ids=[self.proj1env1.id], start=self.now - timedelta(days=5), end=self.now - timedelta(days=4), ) == {}) def test_get_group_ids_for_users(self): assert self.ts.get_group_ids_for_users( [self.proj1.id], [EventUser(project_id=self.proj1.id, ident="user1")]) == { self.proj1group1.id, self.proj1group2.id } assert self.ts.get_group_ids_for_users( [self.proj1.id], [EventUser(project_id=self.proj1.id, ident="user2")]) == { self.proj1group1.id } def test_get_group_tag_values_for_users(self): result = self.ts.get_group_tag_values_for_users( [EventUser(project_id=self.proj1.id, ident="user1")]) assert len(result) == 2 assert {v.group_id for v in result} == {self.proj1group1.id, self.proj1group2.id} assert {v.last_seen for v in result} == { self.now - timedelta(seconds=1), self.now - timedelta(seconds=2), } result.sort(key=lambda x: x.last_seen) assert result[0].last_seen == self.now - timedelta(seconds=2) assert result[1].last_seen == self.now - timedelta(seconds=1) for v in result: assert v.value == "user1" result = self.ts.get_group_tag_values_for_users( [EventUser(project_id=self.proj1.id, ident="user2")]) assert len(result) == 1 assert result[0].value == "user2" assert result[0].last_seen == self.now - timedelta(seconds=2) def test_get_release_tags(self): tags = list( self.ts.get_release_tags(self.proj1.organization_id, [self.proj1.id], None, ["100"])) assert len(tags) == 1 one_second_ago = self.now - timedelta(seconds=1) assert tags[0].last_seen == one_second_ago assert tags[0].first_seen == one_second_ago assert tags[0].times_seen == 1 assert tags[0].key == "sentry:release" def test_get_release_tags_uses_release_project_environment(self): tags = list( self.ts.get_release_tags(self.proj1.organization_id, [self.proj1.id], None, ["100"])) assert len(tags) == 1 one_second_ago = self.now - timedelta(seconds=1) assert tags[0].last_seen == one_second_ago assert tags[0].first_seen == one_second_ago assert tags[0].times_seen == 1 one_day_ago = self.now - timedelta(days=1) two_days_ago = self.now - timedelta(days=2) self.store_event( data={ "event_id": "5" * 32, "message": "message3", "platform": "python", "environment": None, "fingerprint": ["group-1"], "timestamp": iso_format(one_day_ago), "tags": { "sentry:release": 100, }, }, project_id=self.proj1.id, ) release = Release.objects.create(version="100", organization=self.organization) ReleaseProjectEnvironment.objects.create( release_id=release.id, project_id=self.proj1.id, environment_id=self.env3.id, first_seen=one_day_ago, ) self.store_event( data={ "event_id": "6" * 32, "message": "message3", "platform": "python", "environment": None, "fingerprint": ["group-1"], "timestamp": iso_format(two_days_ago), "tags": { "sentry:release": 100, }, }, project_id=self.proj1.id, ) tags = list( self.ts.get_release_tags(self.proj1.organization_id, [self.proj1.id], None, ["100"])) assert tags[0].last_seen == one_second_ago assert tags[0].first_seen == one_day_ago assert ( tags[0].times_seen == 2 ) # Isn't 3 because start was limited by the ReleaseProjectEnvironment entry def test_get_group_event_filter(self): assert self.ts.get_group_event_filter(self.proj1.id, self.proj1group1.id, [self.proj1env1.id], {"foo": "bar"}, None, None) == { "event_id__in": {"1" * 32, "2" * 32} } assert (self.ts.get_group_event_filter( self.proj1.id, self.proj1group1.id, [self.proj1env1.id], {"foo": "bar"}, (self.now - timedelta(seconds=1)), None, ) == { "event_id__in": {"1" * 32} }) assert (self.ts.get_group_event_filter( self.proj1.id, self.proj1group1.id, [self.proj1env1.id], {"foo": "bar"}, None, (self.now - timedelta(seconds=1)), ) == { "event_id__in": {"2" * 32} }) assert (self.ts.get_group_event_filter( self.proj1.id, self.proj1group1.id, [self.proj1env1.id, self.proj1env2.id], {"foo": "bar"}, None, None, ) == { "event_id__in": {"1" * 32, "2" * 32, "4" * 32} }) assert (self.ts.get_group_event_filter( self.proj1.id, self.proj1group1.id, [self.proj1env1.id], { "foo": "bar", "sentry:release": "200" }, # AND None, None, ) == { "event_id__in": {"2" * 32} }) assert (self.ts.get_group_event_filter( self.proj1.id, self.proj1group2.id, [self.proj1env1.id], {"browser": "chrome"}, None, None, ) == { "event_id__in": {"3" * 32} }) assert (self.ts.get_group_event_filter( self.proj1.id, self.proj1group2.id, [self.proj1env1.id], {"browser": "ie"}, None, None, ) is None) def test_get_tag_value_paginator(self): from sentry.tagstore.types import TagValue assert list( self.ts.get_tag_value_paginator( self.proj1.id, self.proj1env1.id, "sentry:user").get_result(10)) == [ TagValue( key="sentry:user", value="id:user1", times_seen=2, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=1), ), TagValue( key="sentry:user", value="id:user2", times_seen=1, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=2), ), ] assert list( self.ts.get_tag_value_paginator( self.proj1.id, self.proj1env1.id, "sentry:user", query="user1").get_result(10)) == [ TagValue( key="sentry:user", value="id:user1", times_seen=2, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=1), ) ] def test_get_tag_value_paginator_with_dates(self): from sentry.tagstore.types import TagValue day_ago = self.now - timedelta(days=1) two_days_ago = self.now - timedelta(days=2) assert list( self.ts.get_tag_value_paginator( self.proj1.id, self.proj1env1.id, "sentry:user", start=day_ago, end=self.now).get_result(10)) == [ TagValue( key="sentry:user", value="id:user1", times_seen=2, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=1), ), TagValue( key="sentry:user", value="id:user2", times_seen=1, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=2), ), ] day_ago = self.now - timedelta(days=1) assert (list( self.ts.get_tag_value_paginator(self.proj1.id, self.proj1env1.id, "sentry:user", start=two_days_ago, end=day_ago).get_result(10)) == []) def test_numeric_tag_value_paginator(self): from sentry.tagstore.types import TagValue assert list( self.ts.get_tag_value_paginator( self.proj1.id, self.proj1env1.id, "stack.lineno").get_result(10)) == [ TagValue( key="stack.lineno", value="29", times_seen=2, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=1), ) ] assert list( self.ts.get_tag_value_paginator( self.proj1.id, self.proj1env1.id, "stack.lineno", query="30").get_result(10)) == [ TagValue( key="stack.lineno", value="29", times_seen=2, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=1), ) ] def test_get_group_tag_value_iter(self): from sentry.tagstore.types import GroupTagValue assert list( self.ts.get_group_tag_value_iter( self.proj1.id, self.proj1group1.id, [self.proj1env1.id], "sentry:user")) == [ GroupTagValue( group_id=self.proj1group1.id, key="sentry:user", value="id:user1", times_seen=1, first_seen=self.now - timedelta(seconds=1), last_seen=self.now - timedelta(seconds=1), ), GroupTagValue( group_id=self.proj1group1.id, key="sentry:user", value="id:user2", times_seen=1, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=2), ), ] def test_get_group_tag_value_paginator(self): from sentry.tagstore.types import GroupTagValue assert list( self.ts.get_group_tag_value_paginator( self.proj1.id, self.proj1group1.id, [self.proj1env1.id], "sentry:user").get_result(10)) == [ GroupTagValue( group_id=self.proj1group1.id, key="sentry:user", value="id:user1", times_seen=1, first_seen=self.now - timedelta(seconds=1), last_seen=self.now - timedelta(seconds=1), ), GroupTagValue( group_id=self.proj1group1.id, key="sentry:user", value="id:user2", times_seen=1, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=2), ), ] def test_get_group_tag_value_paginator_times_seen(self): from sentry.tagstore.types import GroupTagValue self.store_event( data={ "event_id": "5" * 32, "message": "message 1", "platform": "python", "environment": self.proj1env1.name, "fingerprint": ["group-1"], "timestamp": iso_format(self.now - timedelta(seconds=2)), "tags": { "foo": "bar", "baz": "quux", "sentry:release": 100, "sentry:user": "******", }, "user": { "id": "user2" }, "exception": exception, }, project_id=self.proj1.id, ) assert list( self.ts.get_group_tag_value_paginator( self.proj1.id, self.proj1group1.id, [self.proj1env1.id], "sentry:user", order_by="-times_seen", ).get_result(10)) == [ GroupTagValue( group_id=self.proj1group1.id, key="sentry:user", value="id:user2", times_seen=2, first_seen=self.now - timedelta(seconds=2), last_seen=self.now - timedelta(seconds=2), ), GroupTagValue( group_id=self.proj1group1.id, key="sentry:user", value="id:user1", times_seen=1, first_seen=self.now - timedelta(seconds=1), last_seen=self.now - timedelta(seconds=1), ), ] def test_get_group_seen_values_for_environments(self): assert self.ts.get_group_seen_values_for_environments( [self.proj1.id], [self.proj1group1.id], [self.proj1env1.id]) == { self.proj1group1.id: { "first_seen": self.now - timedelta(seconds=2), "last_seen": self.now - timedelta(seconds=1), "times_seen": 2, } } # test where there should be no results because of time filters assert (self.ts.get_group_seen_values_for_environments( [self.proj1.id], [self.proj1group1.id], [self.proj1env1.id], start=self.now - timedelta(hours=5), end=self.now - timedelta(hours=4), ) == {})