def merge_to(self, project):
from sentry.models import (Group, Event)
if not isinstance(project, Project):
project = Project.objects.get_from_cache(pk=project)
for group in Group.objects.filter(project=self):
try:
other = Group.objects.get(project=project, )
except Group.DoesNotExist:
group.update(project=project)
tagstore.update_project_for_group(group_id=group.id,
old_project_id=self.id,
new_project_id=project.id)
else:
Event.objects.filter(
group_id=group.id, ).update(group_id=other.id)
for obj in tagstore.get_group_tag_values(group_id=group.id):
obj2, created = tagstore.get_or_create_group_tag_value(
project_id=project.id,
group_id=group.id,
key=obj.key,
value=obj.value,
defaults={'times_seen': obj.times_seen})
if not created:
obj2.update(times_seen=F('times_seen') +
obj.times_seen)
for fv in tagstore.get_tag_values(self.id):
tagstore.get_or_create_tag_value(project_id=project.id,
key=fv.key,
value=fv.value)
fv.delete()
self.delete()
def index_event_tags(organization_id,
project_id,
event_id,
tags,
group_id=None,
**kwargs):
from sentry import tagstore
from sentry.models import EventTag
Raven.tags_context({
'project': project_id,
})
for key, value in tags:
tagkey, _ = tagstore.get_or_create_tag_key(project_id, key)
tagvalue, _ = tagstore.get_or_create_tag_value(project_id, key, value)
try:
# handle replaying of this task
with transaction.atomic():
EventTag.objects.create(
project_id=project_id,
group_id=group_id,
event_id=event_id,
key_id=tagkey.id,
value_id=tagvalue.id,
)
except IntegrityError:
pass
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, **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,
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 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 merge_to(self, project):
from sentry.models import (Group, Event)
if not isinstance(project, Project):
project = Project.objects.get_from_cache(pk=project)
for group in Group.objects.filter(project=self):
try:
other = Group.objects.get(
project=project,
)
except Group.DoesNotExist:
group.update(project=project)
tagstore.update_project_for_group(
group_id=group.id,
old_project_id=self.id,
new_project_id=project.id)
else:
Event.objects.filter(
group_id=group.id,
).update(group_id=other.id)
for obj in tagstore.get_group_tag_values(group_id=group.id):
obj2, created = tagstore.get_or_create_group_tag_value(
project_id=project.id,
group_id=group.id,
key=obj.key,
value=obj.value,
defaults={'times_seen': obj.times_seen}
)
if not created:
obj2.update(times_seen=F('times_seen') + obj.times_seen)
for fv in tagstore.get_tag_values(self.id):
tagstore.get_or_create_tag_value(project_id=project.id, key=fv.key, value=fv.value)
fv.delete()
self.delete()
def index_event_tags(organization_id, project_id, event_id, tags, group_id=None, **kwargs):
from sentry import tagstore
Raven.tags_context({
'project': project_id,
})
for key, value in tags:
tagkey, _ = tagstore.get_or_create_tag_key(project_id, key)
tagvalue, _ = tagstore.get_or_create_tag_value(project_id, key, value)
tagstore.create_event_tag(
project_id=project_id,
group_id=group_id,
event_id=event_id,
key_id=tagkey.id,
value_id=tagvalue.id,
)
