def index_event_tags(organization_id,
project_id,
event_id,
tags,
group_id,
environment_id,
date_added=None,
**kwargs):
from sentry import tagstore
with configure_scope() as scope:
scope.set_tag("project", project_id)
create_event_tags_kwargs = {}
if date_added is not None:
create_event_tags_kwargs['date_added'] = date_added
metrics.timing('tagstore.tags_per_event',
len(tags),
tags={
'organization_id': organization_id,
})
tagstore.create_event_tags(project_id=project_id,
group_id=group_id,
environment_id=environment_id,
event_id=event_id,
tags=tags,
**create_event_tags_kwargs)
def test_simple(self):
project = self.create_project()
group = self.create_group(project=project,
status=GroupStatus.PENDING_DELETION)
event = self.create_event(group=group)
tv, _ = tagstore.get_or_create_tag_value(project.id,
self.environment.id, "key1",
"value1")
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
tags=[(tv.key, tv.value)],
)
GroupAssignee.objects.create(group=group,
project=project,
user=self.user)
GroupHash.objects.create(project=project,
group=group,
hash=uuid4().hex)
GroupMeta.objects.create(group=group, key="foo", value="bar")
GroupRedirect.objects.create(group_id=group.id, previous_group_id=1)
with self.tasks():
delete_groups(object_ids=[group.id])
assert not Event.objects.filter(id=event.id).exists()
assert not EventTag.objects.filter(event_id=event.id).exists()
assert not GroupRedirect.objects.filter(group_id=group.id).exists()
assert not GroupHash.objects.filter(group_id=group.id).exists()
assert not Group.objects.filter(id=group.id).exists()
def index_event_tags(organization_id, project_id, event_id, tags, group_id,
environment_id, **kwargs):
from sentry import tagstore
Raven.tags_context({
'project': project_id,
})
tag_ids = []
for key, value in tags:
tagkey, _ = tagstore.get_or_create_tag_key(project_id, environment_id,
key)
tagvalue, _ = tagstore.get_or_create_tag_value(project_id,
environment_id,
key,
value,
key_id=tagkey.id)
tag_ids.append((tagkey.id, tagvalue.id))
tagstore.create_event_tags(
project_id=project_id,
group_id=group_id,
environment_id=environment_id,
event_id=event_id,
tags=tag_ids,
)
def index_event_tags(organization_id, project_id, event_id, tags,
group_id, environment_id, date_added=None, **kwargs):
from sentry import tagstore
with configure_scope() as scope:
scope.set_tag("project", project_id)
create_event_tags_kwargs = {}
if date_added is not None:
create_event_tags_kwargs['date_added'] = date_added
metrics.timing(
'tagstore.tags_per_event',
len(tags),
tags={
'organization_id': organization_id,
}
)
tagstore.create_event_tags(
project_id=project_id,
group_id=group_id,
environment_id=environment_id,
event_id=event_id,
tags=tags,
**create_event_tags_kwargs
)
def index_event_tags(organization_id, project_id, event_id, tags,
group_id, environment_id, date_added=None, **kwargs):
from sentry import tagstore
Raven.tags_context({
'project': project_id,
})
create_event_tags_kwargs = {}
if date_added is not None:
create_event_tags_kwargs['date_added'] = date_added
metrics.timing(
'tagstore.tags_per_event',
len(tags),
tags={
'organization_id': organization_id,
}
)
tagstore.create_event_tags(
project_id=project_id,
group_id=group_id,
environment_id=environment_id,
event_id=event_id,
tags=tags,
**create_event_tags_kwargs
)
def index_event_tags(organization_id, project_id, event_id, tags, group_id,
environment_id, **kwargs):
from sentry import tagstore
Raven.tags_context({
'project': project_id,
})
tag_ids = []
for key, value in tags:
tagkey, _ = tagstore.get_or_create_tag_key(project_id, environment_id,
key)
# TODO(brett): optimization to hand `get_or_create_tag_value` the key_id
# so it doesn't have to hit the database for something we just had on hand
tagvalue, _ = tagstore.get_or_create_tag_value(project_id,
environment_id, key,
value)
tag_ids.append((tagkey.id, tagvalue.id))
tagstore.create_event_tags(
project_id=project_id,
group_id=group_id,
environment_id=environment_id,
event_id=event_id,
tags=tag_ids,
)
def test_simple(self):
project = self.create_project()
group = self.create_group(project=project, )
event = self.create_event(group=group)
UserReport.objects.create(
group_id=group.id,
project_id=event.project_id,
name='Jane Doe',
)
key = 'key'
value = 'value'
tk = tagstore.create_tag_key(project_id=project.id,
environment_id=self.environment.id,
key=key)
tv = tagstore.create_tag_value(project_id=project.id,
environment_id=self.environment.id,
key=key,
value=value)
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
tags=[
(tk.key, tv.value),
],
)
GroupAssignee.objects.create(
group=group,
project=project,
user=self.user,
)
GroupHash.objects.create(
project=project,
group=group,
hash=uuid4().hex,
)
GroupMeta.objects.create(
group=group,
key='foo',
value='bar',
)
GroupRedirect.objects.create(
group_id=group.id,
previous_group_id=1,
)
deletion = ScheduledDeletion.schedule(group, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventTag.objects.filter(event_id=event.id).exists()
assert not UserReport.objects.filter(group_id=group.id).exists()
assert not GroupRedirect.objects.filter(group_id=group.id).exists()
assert not GroupHash.objects.filter(group_id=group.id).exists()
assert not Group.objects.filter(id=group.id).exists()
def index_event_tags(organization_id,
project_id,
event_id,
tags,
group_id,
environment_id,
date_added=None,
**kwargs):
from sentry import tagstore
Raven.tags_context({
'project': project_id,
})
create_event_tags_kwargs = {}
if date_added is not None:
create_event_tags_kwargs['date_added'] = date_added
metrics.timing('tagstore.tags_per_event',
len(tags),
tags={
'organization_id': organization_id,
})
tagstore.create_event_tags(project_id=project_id,
group_id=group_id,
environment_id=environment_id,
event_id=event_id,
tags=tags,
**create_event_tags_kwargs)
def test_environment(self):
self.login_as(user=self.user)
group = self.create_group()
events = {}
for name in ['production', 'development']:
environment = Environment.get_or_create(group.project, name)
tagstore.get_or_create_tag_key(
project_id=group.project_id,
environment_id=environment.id,
key='environment',
)
tagstore.create_tag_value(
project_id=group.project_id,
environment_id=environment.id,
key='environment',
value=name,
)
events[name] = event = self.create_event(
group=group,
tags={'environment': name},
)
tagstore.create_event_tags(
project_id=group.project_id,
group_id=group.id,
environment_id=environment.id,
event_id=event.id,
tags=[
('environment', name),
],
)
url = u'/api/0/issues/{}/events/'.format(group.id)
response = self.client.get(url + '?environment=production',
format='json')
assert response.status_code == 200, response.content
assert set(map(lambda x: x['id'], response.data)) == set([
six.text_type(events['production'].id),
])
url = u'/api/0/issues/{}/events/'.format(group.id)
response = self.client.get(url + '?environment=invalid', format='json')
assert response.status_code == 200, response.content
assert response.data == []
url = u'/api/0/issues/{}/events/'.format(group.id)
response = self.client.get(
url + '?environment=production&query=environment:development',
format='json')
assert response.status_code == 200, response.content
assert response.data == []
def test_environment(self):
self.login_as(user=self.user)
group = self.create_group()
events = {}
for name in ['production', 'development']:
environment = Environment.get_or_create(group.project, name)
tagstore.get_or_create_tag_key(
project_id=group.project_id,
environment_id=environment.id,
key='environment',
)
tagstore.create_tag_value(
project_id=group.project_id,
environment_id=environment.id,
key='environment',
value=name,
)
events[name] = event = self.create_event(
group=group,
tags={'environment': name},
)
tagstore.create_event_tags(
project_id=group.project_id,
group_id=group.id,
environment_id=environment.id,
event_id=event.id,
tags=[
('environment', name),
],
)
url = u'/api/0/issues/{}/events/'.format(group.id)
response = self.client.get(url + '?environment=production', format='json')
assert response.status_code == 200, response.content
assert set(map(lambda x: x['id'], response.data)) == set([
six.text_type(events['production'].id),
])
url = u'/api/0/issues/{}/events/'.format(group.id)
response = self.client.get(url + '?environment=invalid', format='json')
assert response.status_code == 200, response.content
assert response.data == []
url = u'/api/0/issues/{}/events/'.format(group.id)
response = self.client.get(
url + '?environment=production&query=environment:development',
format='json')
assert response.status_code == 200, response.content
assert response.data == []
def test_simple(self):
project = self.create_project()
group = self.create_group(
project=project,
status=GroupStatus.PENDING_DELETION,
)
event = self.create_event(group=group)
EventMapping.objects.create(
project_id=project.id,
event_id='a' * 32,
group_id=group.id,
)
tv, _ = tagstore.get_or_create_tag_value(project.id,
self.environment.id, 'key1',
'value1')
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
tags=[
(tv.key, tv.value),
],
)
GroupAssignee.objects.create(
group=group,
project=project,
user=self.user,
)
GroupHash.objects.create(
project=project,
group=group,
hash=uuid4().hex,
)
GroupMeta.objects.create(
group=group,
key='foo',
value='bar',
)
GroupRedirect.objects.create(
group_id=group.id,
previous_group_id=1,
)
with self.tasks():
delete_group(object_id=group.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventMapping.objects.filter(
event_id='a' * 32,
group_id=group.id,
).exists()
assert not EventTag.objects.filter(event_id=event.id).exists()
assert not GroupRedirect.objects.filter(group_id=group.id).exists()
assert not GroupHash.objects.filter(group_id=group.id).exists()
assert not Group.objects.filter(id=group.id).exists()
def _setup_tags_for_event(self, event):
tags = dict(event.data.get('tags') or ())
try:
environment = self.environments[event.data['environment']]
except KeyError:
environment = self.environments[
event.data['environment']] = Environment.get_or_create(
event.project,
event.data['environment'],
)
GroupEnvironment.objects.get_or_create(
environment_id=environment.id,
group_id=event.group_id,
)
for key, value in tags.items():
for environment_id in [AGGREGATE_ENVIRONMENT_ID, environment.id]:
tag_value, created = tagstore.get_or_create_group_tag_value(
project_id=event.project_id,
group_id=event.group_id,
environment_id=environment_id,
key=key,
value=value,
)
if created: # XXX: Hack for tagstore compat
tag_value.update(
times_seen=1,
first_seen=event.datetime,
last_seen=event.datetime,
)
else:
updates = {
'times_seen': tag_value.times_seen + 1,
}
if event.datetime < tag_value.first_seen:
updates['first_seen'] = event.datetime
if event.datetime > tag_value.last_seen:
updates['last_seen'] = event.datetime
if updates:
tag_value.update(**updates)
tagstore.create_event_tags(
project_id=event.project_id,
group_id=event.group_id,
environment_id=environment_id,
event_id=event.id,
tags=tags.items(),
date_added=event.datetime,
)
def test_simple(self):
project = self.create_project()
group = self.create_group(
project=project,
)
event = self.create_event(group=group)
EventMapping.objects.create(
project_id=project.id,
event_id='a' * 32,
group_id=group.id,
)
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
tags=[
(1, 1),
],
)
GroupAssignee.objects.create(
group=group,
project=project,
user=self.user,
)
GroupHash.objects.create(
project=project,
group=group,
hash=uuid4().hex,
)
GroupMeta.objects.create(
group=group,
key='foo',
value='bar',
)
GroupRedirect.objects.create(
group_id=group.id,
previous_group_id=1,
)
deletion = ScheduledDeletion.schedule(group, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventMapping.objects.filter(
event_id='a' * 32,
group_id=group.id,
).exists()
assert not EventTag.objects.filter(event_id=event.id).exists()
assert not GroupRedirect.objects.filter(group_id=group.id).exists()
assert not GroupHash.objects.filter(group_id=group.id).exists()
assert not Group.objects.filter(id=group.id).exists()
def test_simple(self):
project = self.create_project()
group = self.create_group(
project=project,
status=GroupStatus.PENDING_DELETION,
)
event = self.create_event(group=group)
EventMapping.objects.create(
project_id=project.id,
event_id='a' * 32,
group_id=group.id,
)
tv, _ = tagstore.get_or_create_tag_value(project.id, self.environment.id, 'key1', 'value1')
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
tags=[
(tv.key, tv.value),
],
)
GroupAssignee.objects.create(
group=group,
project=project,
user=self.user,
)
GroupHash.objects.create(
project=project,
group=group,
hash=uuid4().hex,
)
GroupMeta.objects.create(
group=group,
key='foo',
value='bar',
)
GroupRedirect.objects.create(
group_id=group.id,
previous_group_id=1,
)
with self.tasks():
delete_group(object_id=group.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventMapping.objects.filter(
event_id='a' * 32,
group_id=group.id,
).exists()
assert not EventTag.objects.filter(event_id=event.id).exists()
assert not GroupRedirect.objects.filter(group_id=group.id).exists()
assert not GroupHash.objects.filter(group_id=group.id).exists()
assert not Group.objects.filter(id=group.id).exists()
def _setup_tags_for_event(self, event):
tags = dict(event.data['tags'])
try:
environment = self.environments[tags['environment']]
except KeyError:
environment = self.environments[tags['environment']] = Environment.get_or_create(
event.project,
tags['environment'],
)
GroupEnvironment.objects.get_or_create(
environment_id=environment.id,
group_id=event.group_id,
)
for key, value in tags.items():
for environment_id in [AGGREGATE_ENVIRONMENT_ID, environment.id]:
tag_value, created = tagstore.get_or_create_group_tag_value(
project_id=event.project_id,
group_id=event.group_id,
environment_id=environment_id,
key=key,
value=value,
)
if created: # XXX: Hack for tagstore compat
tag_value.update(
times_seen=1,
first_seen=event.datetime,
last_seen=event.datetime,
)
else:
updates = {
'times_seen': tag_value.times_seen + 1,
}
if event.datetime < tag_value.first_seen:
updates['first_seen'] = event.datetime
if event.datetime > tag_value.last_seen:
updates['last_seen'] = event.datetime
if updates:
tag_value.update(**updates)
tagstore.create_event_tags(
project_id=event.project_id,
group_id=event.group_id,
environment_id=environment_id,
event_id=event.id,
tags=tags.items(),
date_added=event.datetime,
)
def test_simple(self):
project = self.create_project()
group = self.create_group(
project=project,
)
event = self.create_event(group=group)
EventMapping.objects.create(
project_id=project.id,
event_id='a' * 32,
group_id=group.id,
)
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
tags=[
(1, 1),
],
)
GroupAssignee.objects.create(
group=group,
project=project,
user=self.user,
)
GroupHash.objects.create(
project=project,
group=group,
hash=uuid4().hex,
)
GroupMeta.objects.create(
group=group,
key='foo',
value='bar',
)
GroupRedirect.objects.create(
group_id=group.id,
previous_group_id=1,
)
deletion = ScheduledDeletion.schedule(group, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventMapping.objects.filter(
event_id='a' * 32,
group_id=group.id,
).exists()
assert not tagstore.get_event_tag_qs(event_id=event.id).exists()
assert not GroupRedirect.objects.filter(group_id=group.id).exists()
assert not GroupHash.objects.filter(group_id=group.id).exists()
assert not Group.objects.filter(id=group.id).exists()
def test_simple(self):
project = self.create_project()
group = self.create_group(project=project, )
event = self.create_event(group=group)
EventAttachment.objects.create(
event_id=event.event_id,
project_id=event.project_id,
file=File.objects.create(
name='hello.png',
type='image/png',
),
name='hello.png',
)
UserReport.objects.create(
event_id=event.event_id,
project_id=event.project_id,
name='Jane Doe',
)
key = 'key'
value = 'value'
tk = tagstore.create_tag_key(project_id=project.id,
environment_id=self.environment.id,
key=key)
tv = tagstore.create_tag_value(project_id=project.id,
environment_id=self.environment.id,
key=key,
value=value)
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
tags=[
(tk.key, tv.value),
],
)
deletion = ScheduledDeletion.schedule(event, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventAttachment.objects.filter(
event_id=event.event_id,
project_id=project.id,
).exists()
assert not UserReport.objects.filter(
event_id=event.event_id,
project_id=project.id,
).exists()
assert not EventTag.objects.filter(event_id=event.id).exists()
def index_event_tags(organization_id, project_id, event_id, tags,
group_id, environment_id, **kwargs):
from sentry import tagstore
Raven.tags_context({
'project': project_id,
})
tagstore.create_event_tags(
project_id=project_id,
group_id=group_id,
environment_id=environment_id,
event_id=event_id,
tags=tags,
)
def test_simple(self):
event_id = "a" * 32
project = self.create_project()
node_id = Event.generate_node_id(project.id, event_id)
group = self.create_group(project=project)
event = self.create_event(group=group, event_id=event_id)
EventAttachment.objects.create(
event_id=event.event_id,
project_id=event.project_id,
file=File.objects.create(name="hello.png", type="image/png"),
name="hello.png",
)
UserReport.objects.create(event_id=event.event_id,
project_id=event.project_id,
name="Jane Doe")
key = "key"
value = "value"
tk = tagstore.create_tag_key(project_id=project.id,
environment_id=self.environment.id,
key=key)
tv = tagstore.create_tag_value(project_id=project.id,
environment_id=self.environment.id,
key=key,
value=value)
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
tags=[(tk.key, tv.value)],
)
assert nodestore.get(node_id) is not None
deletion = ScheduledDeletion.schedule(event, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventAttachment.objects.filter(
event_id=event.event_id, project_id=project.id).exists()
assert not UserReport.objects.filter(event_id=event.event_id,
project_id=project.id).exists()
assert not EventTag.objects.filter(event_id=event.id).exists()
assert nodestore.get(node_id) is None
def index_event_tags(organization_id, project_id, event_id, tags,
group_id=None, environment_id=None, **kwargs):
from sentry import tagstore
Raven.tags_context({
'project': project_id,
})
tag_ids = []
for key, value in tags:
tagkey, _ = tagstore.get_or_create_tag_key(project_id, environment_id, key)
tagvalue, _ = tagstore.get_or_create_tag_value(project_id, environment_id, key, value)
tag_ids.append((tagkey.id, tagvalue.id))
tagstore.create_event_tags(
project_id=project_id,
group_id=group_id,
event_id=event_id,
tags=tag_ids,
)
def test_simple(self):
from sentry.tagstore.tasks import delete_tag_key as delete_tag_key_task
team = self.create_team(name='test', slug='test')
project = self.create_project(teams=[team], name='test1', slug='test1')
group = self.create_group(project=project)
key = 'foo'
value = 'bar'
tk = tagstore.create_tag_key(key=key,
project_id=project.id,
environment_id=self.environment.id)
tv = tagstore.create_tag_value(key=key,
value=value,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(key=key,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(key=key,
value=value,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_event_tags(
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
event_id=1,
tags=[
(tk.key, tv.value),
],
)
project2 = self.create_project(teams=[team], name='test2')
env2 = self.create_environment(project=project2)
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(
key=key,
project_id=project2.id,
environment_id=env2.id,
)
tv2 = tagstore.create_tag_value(project_id=project2.id,
environment_id=env2.id,
key=key,
value=value)
tagstore.create_group_tag_key(
key=key,
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
)
tagstore.create_group_tag_value(
key=key,
value=value,
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
)
tagstore.create_event_tags(
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
event_id=1,
tags=[(tk2.key, tv2.value)],
)
with self.tasks():
from sentry.tagstore.models import TagKey
delete_tag_key_task(object_id=tk.id, model=TagKey)
try:
tagstore.get_group_tag_value(group.project_id, group.id, None,
key, value)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.project_id, group.id, None,
key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, None, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
try:
tagstore.get_tag_key(project.id, None, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(project2.id, env2.id, key) is not None
assert tagstore.get_group_tag_key(group2.project_id, group2.id,
env2.id, key) is not None
assert tagstore.get_group_tag_value(group2.project_id, group2.id,
env2.id, key, value) is not None
assert EventTag.objects.filter(key_id=tk2.id).exists()
def test_simple(self):
team = self.create_team(name='test', slug='test')
project = self.create_project(team=team, name='test1', slug='test1')
group = self.create_group(project=project)
key = 'foo'
value = 'bar'
tk = tagstore.create_tag_key(key=key,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_tag_value(key=key,
value=value,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(key=key,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(key=key,
value=value,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_event_tags(group_id=group.id,
project_id=project.id,
event_id=1,
environment_id=self.environment.id,
tags=[
(tk.id, 1),
])
project2 = self.create_project(team=team, name='test2')
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(project2.id, self.environment.id, key)
tagstore.create_group_tag_key(key=key,
group_id=group2.id,
project_id=project2.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(key=key,
value=value,
group_id=group2.id,
project_id=project2.id,
environment_id=self.environment.id)
tagstore.create_event_tags(
group_id=group2.id,
project_id=project.id,
environment_id=self.environment.id,
event_id=1,
tags=[
(tk2.id, 1),
],
)
deletion = ScheduledDeletion.schedule(tk, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
try:
tagstore.get_group_tag_value(group.project_id, group.id, None, key,
value)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.project_id, group.id, None, key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, None, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
try:
tagstore.get_tag_key(project.id, None, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(project2.id, None, key) is not None
assert tagstore.get_group_tag_key(group2.project_id, group2.id, None,
key) is not None
assert tagstore.get_group_tag_value(group2.project_id, group2.id, None,
key, value) is not None
assert EventTag.objects.filter(key_id=tk.id).exists()
assert EventTag.objects.filter(key_id=tk2.id).exists()
def test_simple(self):
project = self.create_project()
group = self.create_group(
project=project,
)
event = self.create_event(group=group)
EventAttachment.objects.create(
event_id=event.event_id,
project_id=event.project_id,
file=File.objects.create(
name='hello.png',
type='image/png',
),
name='hello.png',
)
UserReport.objects.create(
event_id=event.event_id,
project_id=event.project_id,
name='Jane Doe',
)
key = 'key'
value = 'value'
tk = tagstore.create_tag_key(
project_id=project.id,
environment_id=self.environment.id,
key=key
)
tv = tagstore.create_tag_value(
project_id=project.id,
environment_id=self.environment.id,
key=key,
value=value
)
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
tags=[
(tk.key, tv.value),
],
)
deletion = ScheduledDeletion.schedule(event, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventAttachment.objects.filter(
event_id=event.event_id,
project_id=project.id,
).exists()
assert not EventMapping.objects.filter(
event_id=event.event_id,
project_id=project.id,
).exists()
assert not UserReport.objects.filter(
event_id=event.event_id,
project_id=project.id,
).exists()
assert not EventTag.objects.filter(event_id=event.id).exists()
def test_tags(self):
self.login_as(user=self.user)
group = self.create_group()
event_1 = self.create_event(event_id='a' * 32, group=group)
event_2 = self.create_event(event_id='b' * 32, group=group)
tagkey_1 = tagstore.create_tag_key(
project_id=group.project_id,
environment_id=self.environment.id,
key='foo')
tagkey_2 = tagstore.create_tag_key(
project_id=group.project_id,
environment_id=self.environment.id,
key='bar')
tagvalue_1 = tagstore.create_tag_value(
project_id=group.project_id,
environment_id=self.environment.id,
key='foo',
value='baz')
tagvalue_2 = tagstore.create_tag_value(
project_id=group.project_id,
environment_id=self.environment.id,
key='bar',
value='biz')
tagvalue_3 = tagstore.create_tag_value(
project_id=group.project_id,
environment_id=self.environment.id,
key='bar',
value='buz')
tagstore.create_event_tags(
project_id=group.project_id,
group_id=group.id,
environment_id=self.environment.id,
event_id=event_1.id,
tags=[
(tagkey_1.key, tagvalue_1.value),
(tagkey_2.key, tagvalue_3.value),
],
)
tagstore.create_event_tags(
project_id=group.project_id,
group_id=group.id,
environment_id=self.environment.id,
event_id=event_2.id,
tags=[
(tagkey_2.key, tagvalue_2.value),
],
)
url = u'/api/0/issues/{}/events/'.format(group.id)
response = self.client.get(url + '?query=foo:baz', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 1
assert response.data[0]['id'] == six.text_type(event_1.id)
response = self.client.get(url + '?query=bar:biz', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 1
assert response.data[0]['id'] == six.text_type(event_2.id)
response = self.client.get(url + '?query=bar:biz%20foo:baz', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 0
response = self.client.get(url + '?query=bar:buz%20foo:baz', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 1
assert response.data[0]['id'] == six.text_type(event_1.id)
response = self.client.get(url + '?query=bar:baz', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 0
response = self.client.get(url + '?query=a:b', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 0
response = self.client.get(url + '?query=bar:b', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 0
response = self.client.get(url + '?query=bar:baz', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 0
def test_simple(self):
team = self.create_team(name="test", slug="test")
project = self.create_project(teams=[team], name="test1", slug="test1")
group = self.create_group(project=project)
key = "foo"
value = "bar"
tk = tagstore.create_tag_key(
key=key, project_id=project.id, environment_id=self.environment.id
)
tv = tagstore.create_tag_value(
key=key, value=value, project_id=project.id, environment_id=self.environment.id
)
tagstore.create_group_tag_key(
key=key, group_id=group.id, project_id=project.id, environment_id=self.environment.id
)
tagstore.create_group_tag_value(
key=key,
value=value,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
)
tagstore.create_event_tags(
group_id=group.id,
project_id=project.id,
event_id=1,
environment_id=self.environment.id,
tags=[(tk.key, tv.value)],
)
project2 = self.create_project(teams=[team], name="test2")
env2 = self.create_environment(project=project2)
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(project2.id, env2.id, key)
tv2 = tagstore.create_tag_value(
key=key, value=value, project_id=project2.id, environment_id=env2.id
)
tagstore.create_group_tag_key(
key=key, group_id=group2.id, project_id=project2.id, environment_id=env2.id
)
tagstore.create_group_tag_value(
key=key, value=value, group_id=group2.id, project_id=project2.id, environment_id=env2.id
)
tagstore.create_event_tags(
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
event_id=1,
tags=[(tk2.key, tv2.value)],
)
deletion = ScheduledDeletion.schedule(tk, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
try:
tagstore.get_group_tag_value(
group.project_id, group.id, self.environment.id, key, value
)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.project_id, group.id, self.environment.id, key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, self.environment.id, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
try:
tagstore.get_tag_key(project.id, self.environment.id, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(project2.id, env2.id, key) is not None
assert tagstore.get_group_tag_key(group2.project_id, group2.id, env2.id, key) is not None
assert (
tagstore.get_group_tag_value(group2.project_id, group2.id, env2.id, key, value)
is not None
)
assert EventTag.objects.filter(key_id=tk2.id).exists()
def test_simple(self):
from sentry.tagstore.legacy.tasks import delete_tag_key
team = self.create_team(name='test', slug='test')
project = self.create_project(team=team, name='test1', slug='test1')
group = self.create_group(project=project)
key = 'foo'
value = 'bar'
tk = tagstore.create_tag_key(
key=key,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_tag_value(
key=key,
value=value,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(
key=key,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(
key=key, value=value, group_id=group.id, project_id=project.id, environment_id=self.environment.id
)
tagstore.create_event_tags(
group_id=group.id,
project_id=project.id,
event_id=1,
tags=[
(tk.id, 1),
],
)
project2 = self.create_project(team=team, name='test2')
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(key=key, project_id=project2.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(
key=key,
group_id=group2.id,
project_id=project2.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(
key=key, value=value, group_id=group2.id, project_id=project2.id, environment_id=self.environment.id
)
tagstore.create_event_tags(
group_id=group2.id,
project_id=project.id,
event_id=1,
tags=[
(tk2.id, 1)
],
)
with self.tasks():
delete_tag_key(object_id=tk.id)
assert tagstore.get_event_tag_qs(key_id=tk.id).exists()
try:
tagstore.get_group_tag_value(group.id, key, value)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.id, key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
try:
tagstore.get_tag_key(project.id, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(project2.id, key) is not None
assert tagstore.get_group_tag_key(group2.id, key) is not None
assert tagstore.get_group_tag_value(group2.id, key, value) is not None
assert tagstore.get_event_tag_qs(key_id=tk2.id).exists()
def test_simple(self):
project = self.create_project()
group = self.create_group(
project=project,
)
event = self.create_event(group=group)
EventMapping.objects.create(
project_id=project.id,
event_id='a' * 32,
group_id=group.id,
)
EventAttachment.objects.create(
event_id=event.event_id,
group_id=event.group_id,
project_id=event.project_id,
file=File.objects.create(
name='hello.png',
type='image/png',
),
name='hello.png',
)
UserReport.objects.create(
group_id=group.id,
project_id=event.project_id,
name='Jane Doe',
)
key = 'key'
value = 'value'
tk = tagstore.create_tag_key(
project_id=project.id,
environment_id=self.environment.id,
key=key
)
tv = tagstore.create_tag_value(
project_id=project.id,
environment_id=self.environment.id,
key=key,
value=value
)
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
tags=[
(tk.key, tv.value),
],
)
GroupAssignee.objects.create(
group=group,
project=project,
user=self.user,
)
GroupHash.objects.create(
project=project,
group=group,
hash=uuid4().hex,
)
GroupMeta.objects.create(
group=group,
key='foo',
value='bar',
)
GroupRedirect.objects.create(
group_id=group.id,
previous_group_id=1,
)
deletion = ScheduledDeletion.schedule(group, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventAttachment.objects.filter(
event_id=event.event_id,
group_id=group.id,
).exists()
assert not EventMapping.objects.filter(
group_id=group.id,
).exists()
assert not EventTag.objects.filter(event_id=event.id).exists()
assert not UserReport.objects.filter(group_id=group.id).exists()
assert not GroupRedirect.objects.filter(group_id=group.id).exists()
assert not GroupHash.objects.filter(group_id=group.id).exists()
assert not Group.objects.filter(id=group.id).exists()
def test_simple(self):
team = self.create_team(name='test', slug='test')
project = self.create_project(team=team, name='test1', slug='test1')
group = self.create_group(project=project)
key = 'foo'
value = 'bar'
tk = tagstore.create_tag_key(
key=key,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_tag_value(
key=key,
value=value,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(
key=key,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(
key=key, value=value, group_id=group.id, project_id=project.id, environment_id=self.environment.id
)
tagstore.create_event_tags(
group_id=group.id,
project_id=project.id,
event_id=1,
tags=[
(tk.id, 1),
]
)
project2 = self.create_project(team=team, name='test2')
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(project2.id, self.environment.id, key)
tagstore.create_group_tag_key(
key=key,
group_id=group2.id,
project_id=project2.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(
key=key, value=value, group_id=group2.id, project_id=project2.id, environment_id=self.environment.id
)
tagstore.create_event_tags(
group_id=group2.id,
project_id=project.id,
event_id=1,
tags=[
(tk2.id, 1),
],
)
deletion = ScheduledDeletion.schedule(tk, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
try:
tagstore.get_group_tag_value(group.id, key, value)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.id, key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
try:
tagstore.get_tag_key(project.id, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(project2.id, key) is not None
assert tagstore.get_group_tag_key(group2.id, key) is not None
assert tagstore.get_group_tag_value(group2.id, key, value) is not None
assert tagstore.get_event_tag_qs(key_id=tk.id).exists()
assert tagstore.get_event_tag_qs(key_id=tk2.id).exists()
def test_simple(self):
from sentry.tagstore.legacy.tasks import delete_tag_key
team = self.create_team(name='test', slug='test')
project = self.create_project(team=team, name='test1', slug='test1')
group = self.create_group(project=project)
key = 'foo'
value = 'bar'
tk = tagstore.create_tag_key(
key=key,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_tag_value(
key=key,
value=value,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(
key=key,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(
key=key, value=value, group_id=group.id, project_id=project.id, environment_id=self.environment.id
)
tagstore.create_event_tags(
group_id=group.id,
project_id=project.id,
event_id=1,
tags=[
(tk.id, 1),
],
)
project2 = self.create_project(team=team, name='test2')
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(key=key, project_id=project2.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(
key=key,
group_id=group2.id,
project_id=project2.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(
key=key, value=value, group_id=group2.id, project_id=project2.id, environment_id=self.environment.id
)
tagstore.create_event_tags(
group_id=group2.id,
project_id=project.id,
event_id=1,
tags=[
(tk2.id, 1)
],
)
with self.tasks():
delete_tag_key(object_id=tk.id)
assert tagstore.get_event_tag_qs(key_id=tk.id).exists()
try:
tagstore.get_group_tag_value(group.id, None, key, value)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.id, None, key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, None, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
try:
tagstore.get_tag_key(project.id, None, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(project2.id, None, key) is not None
assert tagstore.get_group_tag_key(group2.id, None, key) is not None
assert tagstore.get_group_tag_value(group2.id, None, key, value) is not None
assert tagstore.get_event_tag_qs(key_id=tk2.id).exists()
def test_tags(self):
self.login_as(user=self.user)
group = self.create_group()
event_1 = self.create_event(event_id='a' * 32, group=group)
event_2 = self.create_event(event_id='b' * 32, group=group)
tagkey_1 = tagstore.create_tag_key(project_id=group.project_id,
environment_id=self.environment.id,
key='foo')
tagkey_2 = tagstore.create_tag_key(project_id=group.project_id,
environment_id=self.environment.id,
key='bar')
tagvalue_1 = tagstore.create_tag_value(
project_id=group.project_id,
environment_id=self.environment.id,
key='foo',
value='baz')
tagvalue_2 = tagstore.create_tag_value(
project_id=group.project_id,
environment_id=self.environment.id,
key='bar',
value='biz')
tagvalue_3 = tagstore.create_tag_value(
project_id=group.project_id,
environment_id=self.environment.id,
key='bar',
value='buz')
tagstore.create_event_tags(
project_id=group.project_id,
group_id=group.id,
environment_id=self.environment.id,
event_id=event_1.id,
tags=[
(tagkey_1.key, tagvalue_1.value),
(tagkey_2.key, tagvalue_3.value),
],
)
tagstore.create_event_tags(
project_id=group.project_id,
group_id=group.id,
environment_id=self.environment.id,
event_id=event_2.id,
tags=[
(tagkey_2.key, tagvalue_2.value),
],
)
url = u'/api/0/issues/{}/events/'.format(group.id)
response = self.client.get(url + '?query=foo:baz', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 1
assert response.data[0]['id'] == six.text_type(event_1.id)
response = self.client.get(url + '?query=bar:biz', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 1
assert response.data[0]['id'] == six.text_type(event_2.id)
response = self.client.get(url + '?query=bar:biz%20foo:baz',
format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 0
response = self.client.get(url + '?query=bar:buz%20foo:baz',
format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 1
assert response.data[0]['id'] == six.text_type(event_1.id)
response = self.client.get(url + '?query=bar:baz', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 0
response = self.client.get(url + '?query=a:b', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 0
response = self.client.get(url + '?query=bar:b', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 0
response = self.client.get(url + '?query=bar:baz', format='json')
assert response.status_code == 200, response.content
assert len(response.data) == 0
def test_simple(self):
from sentry.tagstore.tasks import delete_tag_key as delete_tag_key_task
team = self.create_team(name='test', slug='test')
project = self.create_project(teams=[team], name='test1', slug='test1')
group = self.create_group(project=project)
key = 'foo'
value = 'bar'
tk = tagstore.create_tag_key(
key=key,
project_id=project.id,
environment_id=self.environment.id)
tv = tagstore.create_tag_value(
key=key,
value=value,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(
key=key,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(
key=key, value=value, group_id=group.id, project_id=project.id, environment_id=self.environment.id
)
tagstore.create_event_tags(
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
event_id=1,
tags=[
(tk.key, tv.value),
],
)
project2 = self.create_project(teams=[team], name='test2')
env2 = self.create_environment(project=project2)
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(
key=key,
project_id=project2.id,
environment_id=env2.id,
)
tv2 = tagstore.create_tag_value(
project_id=project2.id,
environment_id=env2.id,
key=key,
value=value
)
tagstore.create_group_tag_key(
key=key,
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
)
tagstore.create_group_tag_value(
key=key,
value=value,
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
)
tagstore.create_event_tags(
group_id=group2.id,
project_id=project2.id,
environment_id=env2.id,
event_id=1,
tags=[
(tk2.key, tv2.value)
],
)
with self.tasks():
from sentry.tagstore.models import TagKey
delete_tag_key_task(object_id=tk.id, model=TagKey)
try:
tagstore.get_group_tag_value(group.project_id, group.id, None, key, value)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.project_id, group.id, None, key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, None, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
try:
tagstore.get_tag_key(project.id, None, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(project2.id, env2.id, key) is not None
assert tagstore.get_group_tag_key(group2.project_id, group2.id, env2.id, key) is not None
assert tagstore.get_group_tag_value(
group2.project_id, group2.id, env2.id, key, value) is not None
assert EventTag.objects.filter(key_id=tk2.id).exists()
