def attach_metadata(self, objects, request=None):
from sentry.templatetags.sentry_plugins import handle_before_events
attach_foreignkey(objects, Group.project, ['team'])
if request and objects:
handle_before_events(request, objects)
if request and request.user.is_authenticated() and objects:
bookmarks = set(GroupBookmark.objects.filter(
user=request.user,
group__in=objects,
).values_list('group_id', flat=True))
else:
bookmarks = set()
if objects:
historical_data = Group.objects.get_chart_data_for_group(
instances=objects,
max_days=1,
key='group',
)
else:
historical_data = {}
for g in objects:
g.is_bookmarked = g.pk in bookmarks
g.historical_data = [x[1] for x in historical_data.get(g.id, [])]
def get_attrs(self, item_list, user):
from sentry.plugins import plugins
GroupMeta.objects.populate_cache(item_list)
attach_foreignkey(item_list, Group.project, ['team'])
if user.is_authenticated() and item_list:
bookmarks = set(GroupBookmark.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', flat=True))
seen_groups = dict(GroupSeen.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', 'last_seen'))
else:
bookmarks = set()
seen_groups = {}
assignees = dict(
(a.group_id, a.user)
for a in GroupAssignee.objects.filter(
group__in=item_list,
).select_related('user')
)
user_counts = dict(
GroupTagKey.objects.filter(
group__in=item_list,
key='sentry:user',
).values_list('group', 'values_seen')
)
snoozes = dict(
GroupSnooze.objects.filter(
group__in=item_list,
).values_list('group', 'until')
)
result = {}
for item in item_list:
active_date = item.active_at or item.last_seen
annotations = []
for plugin in plugins.for_project(project=item.project, version=1):
safe_execute(plugin.tags, None, item, annotations)
for plugin in plugins.for_project(project=item.project, version=2):
annotations.extend(safe_execute(plugin.get_annotations, group=item) or ())
result[item] = {
'assigned_to': serialize(assignees.get(item.id)),
'is_bookmarked': item.id in bookmarks,
'has_seen': seen_groups.get(item.id, active_date) > active_date,
'annotations': annotations,
'user_count': user_counts.get(item.id, 0),
'snooze': snoozes.get(item.id),
}
return result
def get_attrs(self, item_list, user):
from sentry.plugins import plugins
GroupMeta.objects.populate_cache(item_list)
attach_foreignkey(item_list, Group.project, ["team"])
if user.is_authenticated() and item_list:
bookmarks = set(
GroupBookmark.objects.filter(user=user, group__in=item_list).values_list("group_id", flat=True)
)
seen_groups = dict(
GroupSeen.objects.filter(user=user, group__in=item_list).values_list("group_id", "last_seen")
)
else:
bookmarks = set()
seen_groups = {}
tag_counts = defaultdict(dict)
tag_results = GroupTagKey.objects.filter(group__in=item_list).values_list("key", "group", "values_seen")
for key, group_id, values_seen in tag_results:
tag_counts[key][group_id] = values_seen
assignees = dict(
(a.group_id, a.user) for a in GroupAssignee.objects.filter(group__in=item_list).select_related("user")
)
result = {}
for item in item_list:
active_date = item.active_at or item.last_seen
tags = {}
for key in tag_counts.iterkeys():
label = TAG_LABELS.get(key, key.replace("_", " ")).lower()
try:
value = tag_counts[key].get(item.id, 0)
except KeyError:
value = 0
tags[key] = {"label": label, "count": value}
annotations = []
for plugin in plugins.for_project(project=item.project, version=1):
safe_execute(plugin.tags, None, item, annotations)
for plugin in plugins.for_project(project=item.project, version=2):
annotations.extend(safe_execute(plugin.get_annotations, item) or ())
result[item] = {
"assigned_to": serialize(assignees.get(item.id)),
"is_bookmarked": item.id in bookmarks,
"has_seen": seen_groups.get(item.id, active_date) > active_date,
"tags": tags,
"annotations": annotations,
}
return result
def attach_metadata(self, objects, request=None):
from sentry.templatetags.sentry_plugins import handle_before_events
attach_foreignkey(objects, Group.project, ["team"])
if request and objects:
handle_before_events(request, objects)
if request and request.user.is_authenticated() and objects:
bookmarks = set(
GroupBookmark.objects.filter(user=request.user, group__in=objects).values_list("group_id", flat=True)
)
seen_groups = dict(
GroupSeen.objects.filter(user=request.user, group__in=objects).values_list("group_id", "last_seen")
)
else:
bookmarks = set()
seen_groups = {}
if objects:
historical_data = Group.objects.get_chart_data_for_group(instances=objects, max_days=1, key="group")
else:
historical_data = {}
project_list = set(o.project for o in objects)
tag_keys = set(["sentry:user"])
project_annotations = {}
for project in project_list:
enabled_annotations = ProjectOption.objects.get_value(project, "annotations", ["sentry:user"])
project_annotations[project] = enabled_annotations
tag_keys.update(enabled_annotations)
annotation_counts = defaultdict(dict)
annotation_results = GroupTagKey.objects.filter(group__in=objects, key__in=tag_keys).values_list(
"key", "group", "values_seen"
)
for key, group_id, values_seen in annotation_results:
annotation_counts[key][group_id] = values_seen
for g in objects:
g.is_bookmarked = g.pk in bookmarks
g.historical_data = [x[1] for x in historical_data.get(g.id, [])]
active_date = g.active_at or g.last_seen
g.has_seen = seen_groups.get(g.id, active_date) > active_date
g.annotations = []
for key in sorted(tag_keys):
if key in project_annotations[project]:
label = TAG_LABELS.get(key, key.replace("_", " ")).lower() + "s"
try:
value = annotation_counts[key].get(g.id, 0)
except KeyError:
value = 0
g.annotations.append({"label": label, "count": value})
def get_attrs(self, item_list, user):
attach_foreignkey(item_list, Group.project, ['team'])
if user.is_authenticated() and item_list:
bookmarks = set(GroupBookmark.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', flat=True))
seen_groups = dict(GroupSeen.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', 'last_seen'))
else:
bookmarks = set()
seen_groups = {}
tag_counts = defaultdict(dict)
tag_results = GroupTagKey.objects.filter(
group__in=item_list,
).values_list('key', 'group', 'values_seen')
for key, group_id, values_seen in tag_results:
tag_counts[key][group_id] = values_seen
assignees = dict(
(a.group_id, a.user)
for a in GroupAssignee.objects.filter(
group__in=item_list,
).select_related('user')
)
result = {}
for item in item_list:
active_date = item.active_at or item.last_seen
tags = {}
for key in tag_counts.iterkeys():
label = TAG_LABELS.get(key, key.replace('_', ' ')).lower()
try:
value = tag_counts[key].get(item.id, 0)
except KeyError:
value = 0
tags[key] = {
'label': label,
'count': value,
}
result[item] = {
'assigned_to': serialize(assignees.get(item.id)),
'is_bookmarked': item.id in bookmarks,
'has_seen': seen_groups.get(item.id, active_date) > active_date,
'tags': tags,
}
return result
def attach_metadata(self, objects, user):
attach_foreignkey(objects, Group.project, ['team'])
# if request and objects:
# handle_before_events(request, objects)
if user.is_authenticated() and objects:
bookmarks = set(GroupBookmark.objects.filter(
user=user,
group__in=objects,
).values_list('group_id', flat=True))
seen_groups = dict(GroupSeen.objects.filter(
user=user,
group__in=objects,
).values_list('group_id', 'last_seen'))
else:
bookmarks = set()
seen_groups = {}
project_list = set(o.project for o in objects)
tag_keys = set(['sentry:user'])
project_annotations = {}
for project in project_list:
enabled_annotations = ProjectOption.objects.get_value(
project, 'annotations', ['sentry:user'])
project_annotations[project] = enabled_annotations
tag_keys.update(enabled_annotations)
annotation_counts = defaultdict(dict)
annotation_results = GroupTagKey.objects.filter(
group__in=objects,
key__in=tag_keys,
).values_list('key', 'group', 'values_seen')
for key, group_id, values_seen in annotation_results:
annotation_counts[key][group_id] = values_seen
for g in objects:
g.is_bookmarked = g.pk in bookmarks
active_date = g.active_at or g.last_seen
g.has_seen = seen_groups.get(g.id, active_date) > active_date
g.annotations = []
for key in sorted(tag_keys):
if key in project_annotations[project]:
label = TAG_LABELS.get(key, key.replace('_', ' ')).lower() + 's'
try:
value = annotation_counts[key].get(g.id, 0)
except KeyError:
value = 0
g.annotations.append({
'label': label,
'count': value,
})
def attach_metadata(self, objects, user):
team_map = dict(
(t.id, t) for t in Team.objects.get_for_user(user).itervalues()
)
for project in objects:
try:
team = team_map[project.team_id]
project.access_type = team.access_type
project.team = team
except KeyError:
project.access_type = None
attach_foreignkey(objects, Project.team)
def get_for_user(self, user=None, access=None, hidden=False, team=None,
superuser=True):
"""
Returns a SortedDict of all projects a user has some level of access to.
"""
from sentry.models import Team
if not (user and user.is_authenticated()):
return []
# TODO: the result of this function should be cached
is_authenticated = (user and user.is_authenticated())
base_qs = self
if not hidden:
base_qs = base_qs.filter(status=0)
if team:
base_qs = base_qs.filter(team=team)
if team and user.is_superuser and superuser:
projects = set(base_qs)
else:
projects_qs = base_qs
if not settings.SENTRY_PUBLIC:
# If the user is authenticated, include their memberships
teams = Team.objects.get_for_user(
user, access, access_groups=False).values()
if not teams:
projects_qs = self.none()
if team and team not in teams:
projects_qs = self.none()
elif not team:
projects_qs = projects_qs.filter(team__in=teams)
projects = set(projects_qs)
if is_authenticated:
projects |= set(base_qs.filter(accessgroup__members=user))
attach_foreignkey(projects, self.model.team)
return sorted(projects, key=lambda x: x.name.lower())
def attach_metadata(self, objects, request=None):
from sentry.templatetags.sentry_plugins import handle_before_events
attach_foreignkey(objects, Group.project, ['team'])
if request and objects:
handle_before_events(request, objects)
if request and request.user.is_authenticated() and objects:
bookmarks = set(GroupBookmark.objects.filter(
user=request.user,
group__in=objects,
).values_list('group_id', flat=True))
seen_groups = dict(GroupSeen.objects.filter(
user=request.user,
group__in=objects,
).values_list('group_id', 'last_seen'))
else:
bookmarks = set()
seen_groups = {}
if objects:
historical_data = Group.objects.get_chart_data_for_group(
instances=objects,
max_days=1,
key='group',
)
else:
historical_data = {}
user_counts = dict(GroupTagKey.objects.filter(
group__in=objects,
key='sentry:user',
).values_list('group', 'values_seen'))
for g in objects:
g.is_bookmarked = g.pk in bookmarks
g.historical_data = [x[1] for x in historical_data.get(g.id, [])]
if user_counts:
g.users_seen = user_counts.get(g.id, 0)
active_date = g.active_at or g.last_seen
g.has_seen = seen_groups.get(g.id, active_date) > active_date
def get_for_user(self, user=None, access=None, hidden=False, team=None):
"""
Returns a SortedDict of all projects a user has some level of access to.
"""
from sentry.models import Team
if not (user and user.is_authenticated()):
return []
# TODO: the result of this function should be cached
is_authenticated = (user and user.is_authenticated())
base_qs = self
if not hidden:
base_qs = base_qs.filter(status=0)
if team:
base_qs = base_qs.filter(team=team)
if team and user.is_superuser:
projects = set(base_qs)
else:
if not settings.PUBLIC:
# If the user is authenticated, include their memberships
teams = Team.objects.get_for_user(user, access).values()
if not teams:
return []
if team and team not in teams:
return []
elif not team:
base_qs = base_qs.filter(team__in=teams)
projects = set(base_qs)
if is_authenticated:
projects |= set(base_qs.filter(accessgroup__members=user))
attach_foreignkey(projects, self.model.team)
return sorted(projects, key=lambda x: x.name)
def attach_metadata(self, objects, user):
if not objects:
return
organization = objects[0].team.organization
team_map = dict(
(t.id, t) for t in Team.objects.get_for_user(
organization=organization,
user=user,
)
)
for project in objects:
try:
team = team_map[project.team_id]
project.access_type = team.access_type
project.team = team
except KeyError:
project.access_type = None
attach_foreignkey(objects, Project.team)
def get_attrs(self, item_list, user, **kwargs):
results = super(DetailedIncidentSerializer, self).get_attrs(item_list,
user=user,
**kwargs)
attach_foreignkey(item_list, Incident.alert_rule)
subscribed_incidents = set()
if user.is_authenticated():
subscribed_incidents = set(
IncidentSubscription.objects.filter(incident__in=item_list,
user=user).values_list(
"incident_id",
flat=True))
incident_groups = defaultdict(list)
for incident_id, group_id in IncidentGroup.objects.filter(
incident__in=item_list).values_list("incident_id", "group_id"):
incident_groups[incident_id].append(six.text_type(group_id))
for item in item_list:
results[item]["is_subscribed"] = item.id in subscribed_incidents
results[item]["groups"] = incident_groups.get(item.id, [])
return results
def get_attrs(self, item_list, user, **kwargs):
alert_rules = {item.id: item for item in item_list}
attach_foreignkey(item_list, AlertRule.snuba_query, related=("environment",))
result = defaultdict(dict)
triggers = AlertRuleTrigger.objects.filter(alert_rule__in=item_list).order_by("label")
serialized_triggers = serialize(list(triggers))
for trigger, serialized in zip(triggers, serialized_triggers):
alert_rule_triggers = result[alert_rules[trigger.alert_rule_id]].setdefault(
"triggers", []
)
alert_rule_triggers.append(serialized)
alert_rule_projects = AlertRule.objects.filter(
id__in=[item.id for item in item_list]
).values_list("id", "snuba_query__subscriptions__project__slug")
alert_rules = {item.id: item for item in item_list}
for alert_rule_id, project_slug in alert_rule_projects:
rule_result = result[alert_rules[alert_rule_id]].setdefault("projects", [])
rule_result.append(project_slug)
for rule_activity in AlertRuleActivity.objects.filter(
alert_rule__in=item_list, type=AlertRuleActivityType.CREATED.value
).select_related("alert_rule", "user"):
if rule_activity.user:
user = {
"id": rule_activity.user.id,
"name": rule_activity.user.get_display_name(),
"email": rule_activity.user.email,
}
else:
user = None
result[alert_rules[rule_activity.alert_rule.id]].update({"created_by": user})
return result
def get_attrs(self, item_list, user, **kwargs):
attach_foreignkey(item_list, IncidentActivity.incident, related=("organization",))
attach_foreignkey(item_list, IncidentActivity.event_stats_snapshot)
attach_foreignkey(item_list, IncidentActivity.user)
user_serializer = UserSerializer()
serialized_users = serialize(
set(item.user for item in item_list if item.user_id),
user=user,
serializer=user_serializer,
)
user_lookup = {user["id"]: user for user in serialized_users}
return {item: {"user": user_lookup.get(six.text_type(item.user_id))} for item in item_list}
def get_attrs(self, item_list, user):
attach_foreignkey(item_list, Group.project, ['team'])
if user.is_authenticated() and item_list:
bookmarks = set(GroupBookmark.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', flat=True))
seen_groups = dict(GroupSeen.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', 'last_seen'))
else:
bookmarks = set()
seen_groups = {}
tag_counts = defaultdict(dict)
tag_results = GroupTagKey.objects.filter(
group__in=item_list,
).values_list('key', 'group', 'values_seen')
for key, group_id, values_seen in tag_results:
tag_counts[key][group_id] = values_seen
# we need to compute stats at 1d (1h resolution), and 14d/30d (1 day res)
group_ids = [g.id for g in item_list]
now = timezone.now()
hourly_stats = tsdb.get_range(
model=tsdb.models.group,
keys=group_ids,
end=now,
start=now - timedelta(days=1),
rollup=3600,
)
daily_stats = tsdb.get_range(
model=tsdb.models.group,
keys=group_ids,
end=now,
start=now - timedelta(days=30),
rollup=3600 * 24,
)
result = {}
for item in item_list:
active_date = item.active_at or item.last_seen
tags = {}
for key in tag_counts.iterkeys():
label = TAG_LABELS.get(key, key.replace('_', ' ')).lower() + 's'
try:
value = tag_counts[key].get(item.id, 0)
except KeyError:
value = 0
tags[key] = {
'label': label,
'count': value,
}
result[item] = {
'is_bookmarked': item.id in bookmarks,
'has_seen': seen_groups.get(item.id, active_date) > active_date,
'tags': tags,
'hourly_stats': hourly_stats[item.id],
'daily_stats': daily_stats[item.id],
}
return result
def get_attrs(self, item_list, user):
from sentry.plugins import plugins
GroupMeta.objects.populate_cache(item_list)
attach_foreignkey(item_list, Group.project, ['team'])
if user.is_authenticated() and item_list:
bookmarks = set(GroupBookmark.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', flat=True))
seen_groups = dict(GroupSeen.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', 'last_seen'))
else:
bookmarks = set()
seen_groups = {}
tag_counts = defaultdict(dict)
tag_results = GroupTagKey.objects.filter(
group__in=item_list,
).values_list('key', 'group', 'values_seen')
for key, group_id, values_seen in tag_results:
tag_counts[key][group_id] = values_seen
assignees = dict(
(a.group_id, a.user)
for a in GroupAssignee.objects.filter(
group__in=item_list,
).select_related('user')
)
tagkeys = dict(
(t.key, t)
for t in TagKey.objects.filter(
project=item_list[0].project,
key__in=tag_counts.keys(),
)
)
result = {}
for item in item_list:
active_date = item.active_at or item.last_seen
# TODO(dcramer): switch to serializers
tags = {}
for key in tag_counts.iterkeys():
try:
tagkey = tagkeys[key]
except KeyError:
label = key.replace('_', ' ').title()
else:
if tagkey.status != TagKeyStatus.VISIBLE:
continue
label = tagkey.get_label()
try:
value = tag_counts[key].get(item.id, 0)
except KeyError:
value = 0
if key.startswith('sentry:'):
key = key.split('sentry:', 1)[-1]
tags[key] = {
'name': label,
'count': value,
}
annotations = []
for plugin in plugins.for_project(project=item.project, version=1):
safe_execute(plugin.tags, None, item, annotations)
for plugin in plugins.for_project(project=item.project, version=2):
annotations.extend(safe_execute(plugin.get_annotations, group=item) or ())
result[item] = {
'assigned_to': serialize(assignees.get(item.id)),
'is_bookmarked': item.id in bookmarks,
'has_seen': seen_groups.get(item.id, active_date) > active_date,
'tags': tags,
'annotations': annotations,
}
return result
def get_attrs(self, item_list, user):
from sentry.plugins import plugins
GroupMeta.objects.populate_cache(item_list)
attach_foreignkey(item_list, Group.project, ['team'])
if user.is_authenticated() and item_list:
bookmarks = set(GroupBookmark.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', flat=True))
seen_groups = dict(GroupSeen.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', 'last_seen'))
else:
bookmarks = set()
seen_groups = {}
tag_counts = defaultdict(dict)
tag_results = GroupTagKey.objects.filter(
group__in=item_list,
).values_list('key', 'group', 'values_seen')
for key, group_id, values_seen in tag_results:
tag_counts[key][group_id] = values_seen
assignees = dict(
(a.group_id, a.user)
for a in GroupAssignee.objects.filter(
group__in=item_list,
).select_related('user')
)
result = {}
for item in item_list:
active_date = item.active_at or item.last_seen
tags = {}
for key in tag_counts.iterkeys():
label = TAG_LABELS.get(key, key.replace('_', ' ')).lower()
try:
value = tag_counts[key].get(item.id, 0)
except KeyError:
value = 0
tags[key] = {
'label': label,
'count': value,
}
annotations = []
for plugin in plugins.for_project(project=item.project, version=1):
safe_execute(plugin.tags, None, item, annotations)
for plugin in plugins.for_project(project=item.project, version=2):
annotations.extend(safe_execute(plugin.get_annotations, item) or ())
result[item] = {
'assigned_to': serialize(assignees.get(item.id)),
'is_bookmarked': item.id in bookmarks,
'has_seen': seen_groups.get(item.id, active_date) > active_date,
'tags': tags,
'annotations': annotations,
}
return result
def get_attrs(self, item_list, user):
from sentry.plugins import plugins
GroupMeta.objects.populate_cache(item_list)
attach_foreignkey(item_list, Group.project, ['team'])
if user.is_authenticated() and item_list:
bookmarks = set(
GroupBookmark.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', flat=True))
seen_groups = dict(
GroupSeen.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', 'last_seen'))
else:
bookmarks = set()
seen_groups = {}
tag_counts = defaultdict(dict)
tag_results = GroupTagKey.objects.filter(
group__in=item_list, ).values_list('key', 'group', 'values_seen')
for key, group_id, values_seen in tag_results:
tag_counts[key][group_id] = values_seen
assignees = dict((a.group_id, a.user)
for a in GroupAssignee.objects.filter(
group__in=item_list, ).select_related('user'))
result = {}
for item in item_list:
active_date = item.active_at or item.last_seen
tags = {}
for key in tag_counts.iterkeys():
label = TAG_LABELS.get(key, key.replace('_', ' ')).lower()
try:
value = tag_counts[key].get(item.id, 0)
except KeyError:
value = 0
tags[key] = {
'label': label,
'count': value,
}
annotations = []
for plugin in plugins.for_project(project=item.project, version=1):
safe_execute(plugin.tags, None, item, annotations)
for plugin in plugins.for_project(project=item.project, version=2):
annotations.extend(
safe_execute(plugin.get_annotations, item) or ())
result[item] = {
'assigned_to': serialize(assignees.get(item.id)),
'is_bookmarked': item.id in bookmarks,
'has_seen':
seen_groups.get(item.id, active_date) > active_date,
'tags': tags,
'annotations': annotations,
}
return result
def get_attrs(self, item_list, user):
from sentry.plugins import plugins
GroupMeta.objects.populate_cache(item_list)
attach_foreignkey(item_list, Group.project)
if user.is_authenticated() and item_list:
bookmarks = set(
GroupBookmark.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', flat=True))
seen_groups = dict(
GroupSeen.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', 'last_seen'))
subscriptions = self._get_subscriptions(item_list, user)
else:
bookmarks = set()
seen_groups = {}
subscriptions = set()
assignees = dict((a.group_id, a.user)
for a in GroupAssignee.objects.filter(
group__in=item_list, ).select_related('user'))
user_counts = dict(
GroupTagKey.objects.filter(
group__in=item_list,
key='sentry:user',
).values_list('group', 'values_seen'))
ignore_durations = dict(
GroupSnooze.objects.filter(group__in=item_list, ).values_list(
'group', 'until'))
pending_resolutions = dict(
GroupResolution.objects.filter(
group__in=item_list,
status=GroupResolutionStatus.PENDING,
).values_list('group', 'release'))
result = {}
for item in item_list:
active_date = item.active_at or item.last_seen
annotations = []
for plugin in plugins.for_project(project=item.project, version=1):
safe_execute(plugin.tags,
None,
item,
annotations,
_with_transaction=False)
for plugin in plugins.for_project(project=item.project, version=2):
annotations.extend(
safe_execute(plugin.get_annotations,
group=item,
_with_transaction=False) or ())
result[item] = {
'assigned_to': serialize(assignees.get(item.id)),
'is_bookmarked': item.id in bookmarks,
'is_subscribed': item.id in subscriptions,
'has_seen':
seen_groups.get(item.id, active_date) > active_date,
'annotations': annotations,
'user_count': user_counts.get(item.id, 0),
'ignore_duration': ignore_durations.get(item.id),
'pending_resolution': pending_resolutions.get(item.id),
}
return result
def attach_metadata(self, objects, request=None):
from sentry.templatetags.sentry_plugins import handle_before_events
attach_foreignkey(objects, Group.project, ['team'])
GroupMeta.objects.populate_cache(objects)
if request and objects:
handle_before_events(request, objects)
if request and request.user.is_authenticated() and objects:
bookmarks = set(GroupBookmark.objects.filter(
user=request.user,
group__in=objects,
).values_list('group_id', flat=True))
seen_groups = dict(GroupSeen.objects.filter(
user=request.user,
group__in=objects,
).values_list('group_id', 'last_seen'))
else:
bookmarks = set()
seen_groups = {}
if objects:
end = timezone.now()
start = end - timedelta(days=1)
historical_data = tsdb.get_range(
model=tsdb.models.group,
keys=[g.id for g in objects],
start=start,
end=end,
)
else:
historical_data = {}
project_list = set(o.project for o in objects)
tag_keys = set(['sentry:user'])
project_annotations = {}
for project in project_list:
enabled_annotations = ProjectOption.objects.get_value(
project, 'annotations', ['sentry:user'])
project_annotations[project] = enabled_annotations
tag_keys.update(enabled_annotations)
annotation_counts = defaultdict(dict)
annotation_results = GroupTagKey.objects.filter(
group__in=objects,
key__in=tag_keys,
).values_list('key', 'group', 'values_seen')
for key, group_id, values_seen in annotation_results:
annotation_counts[key][group_id] = values_seen
for g in objects:
g.is_bookmarked = g.pk in bookmarks
g.historical_data = [x[1] for x in historical_data.get(g.id, [])]
active_date = g.active_at or g.last_seen
g.has_seen = seen_groups.get(g.id, active_date) > active_date
g.annotations = []
for key in sorted(tag_keys):
if key in project_annotations[project]:
label = TAG_LABELS.get(key, key.replace('_', ' ')).lower() + 's'
try:
value = annotation_counts[key].get(g.id, 0)
except KeyError:
value = 0
g.annotations.append({
'label': label,
'count': value,
})
def get_attrs(self, item_list, user):
attach_foreignkey(item_list, Group.project, ['team'])
if user.is_authenticated() and item_list:
bookmarks = set(GroupBookmark.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', flat=True))
seen_groups = dict(GroupSeen.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', 'last_seen'))
else:
bookmarks = set()
seen_groups = {}
tag_counts = defaultdict(dict)
tag_results = GroupTagKey.objects.filter(
group__in=item_list,
).values_list('key', 'group', 'values_seen')
for key, group_id, values_seen in tag_results:
tag_counts[key][group_id] = values_seen
# we need to compute stats at 1d (1h resolution), and 14d/30d (1 day res)
group_ids = [g.id for g in item_list]
now = timezone.now()
hourly_stats = tsdb.get_range(
model=tsdb.models.group,
keys=group_ids,
end=now,
start=now - timedelta(days=1),
rollup=3600,
)
daily_stats = tsdb.get_range(
model=tsdb.models.group,
keys=group_ids,
end=now,
start=now - timedelta(days=30),
rollup=3600 * 24,
)
result = {}
for item in item_list:
active_date = item.active_at or item.last_seen
tags = {}
for key in tag_counts.iterkeys():
label = TAG_LABELS.get(key, key.replace('_', ' ')).lower()
try:
value = tag_counts[key].get(item.id, 0)
except KeyError:
value = 0
tags[key] = {
'label': label,
'count': value,
}
result[item] = {
'is_bookmarked': item.id in bookmarks,
'has_seen': seen_groups.get(item.id, active_date) > active_date,
'tags': tags,
'hourly_stats': hourly_stats[item.id],
'daily_stats': daily_stats[item.id],
}
return result
def get_attrs(self, item_list, user):
from sentry.plugins import plugins
GroupMeta.objects.populate_cache(item_list)
attach_foreignkey(item_list, Group.project)
if user.is_authenticated() and item_list:
bookmarks = set(
GroupBookmark.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', flat=True))
seen_groups = dict(
GroupSeen.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', 'last_seen'))
subscriptions = self._get_subscriptions(item_list, user)
else:
bookmarks = set()
seen_groups = {}
subscriptions = defaultdict(lambda: (False, None))
assignees = dict((a.group_id, a.user)
for a in GroupAssignee.objects.filter(
group__in=item_list, ).select_related('user'))
user_counts = tagstore.get_group_values_seen([g.id for g in item_list],
'sentry:user')
ignore_items = {
g.group_id: g
for g in GroupSnooze.objects.filter(group__in=item_list, )
}
resolutions = {
i[0]: i[1:]
for i in GroupResolution.objects.filter(group__in=item_list,
).values_list(
'group',
'type',
'release__version',
'actor_id',
)
}
actor_ids = set(r[-1] for r in six.itervalues(resolutions))
actor_ids.update(r.actor_id for r in six.itervalues(ignore_items))
if actor_ids:
users = list(
User.objects.filter(
id__in=actor_ids,
is_active=True,
))
actors = {u.id: d for u, d in izip(users, serialize(users, user))}
else:
actors = {}
share_ids = dict(
GroupShare.objects.filter(group__in=item_list, ).values_list(
'group_id', 'uuid'))
result = {}
for item in item_list:
active_date = item.active_at or item.first_seen
annotations = []
for plugin in plugins.for_project(project=item.project, version=1):
safe_execute(plugin.tags,
None,
item,
annotations,
_with_transaction=False)
for plugin in plugins.for_project(project=item.project, version=2):
annotations.extend(
safe_execute(plugin.get_annotations,
group=item,
_with_transaction=False) or ())
resolution = resolutions.get(item.id)
if resolution:
resolution_actor = actors.get(resolution[-1])
else:
resolution_actor = None
ignore_item = ignore_items.get(item.id)
if ignore_item:
ignore_actor = actors.get(ignore_item.actor_id)
else:
ignore_actor = None
result[item] = {
'assigned_to': serialize(assignees.get(item.id)),
'is_bookmarked': item.id in bookmarks,
'subscription': subscriptions[item.id],
'has_seen':
seen_groups.get(item.id, active_date) > active_date,
'annotations': annotations,
'user_count': user_counts.get(item.id, 0),
'ignore_until': ignore_item,
'ignore_actor': ignore_actor,
'resolution': resolution,
'resolution_actor': resolution_actor,
'share_id': share_ids.get(item.id),
}
return result
def get_attrs(self, item_list, user):
from sentry.plugins import plugins
GroupMeta.objects.populate_cache(item_list)
attach_foreignkey(item_list, Group.project)
if user.is_authenticated() and item_list:
bookmarks = set(
GroupBookmark.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', flat=True)
)
seen_groups = dict(
GroupSeen.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', 'last_seen')
)
subscriptions = self._get_subscriptions(item_list, user)
else:
bookmarks = set()
seen_groups = {}
subscriptions = defaultdict(lambda: (False, None))
assignees = {
a.group_id: a.assigned_actor() for a in
GroupAssignee.objects.filter(
group__in=item_list,
)
}
resolved_assignees = Actor.resolve_dict(assignees)
ignore_items = {g.group_id: g for g in GroupSnooze.objects.filter(
group__in=item_list,
)}
resolved_item_list = [i for i in item_list if i.status == GroupStatus.RESOLVED]
if resolved_item_list:
release_resolutions = {
i[0]: i[1:]
for i in GroupResolution.objects.filter(
group__in=resolved_item_list,
).values_list(
'group',
'type',
'release__version',
'actor_id',
)
}
# due to our laziness, and django's inability to do a reasonable join here
# we end up with two queries
commit_results = list(Commit.objects.extra(
select={
'group_id': 'sentry_grouplink.group_id',
},
tables=['sentry_grouplink'],
where=[
'sentry_grouplink.linked_id = sentry_commit.id',
'sentry_grouplink.group_id IN ({})'.format(
', '.join(six.text_type(i.id) for i in resolved_item_list)),
'sentry_grouplink.linked_type = %s',
'sentry_grouplink.relationship = %s',
],
params=[
int(GroupLink.LinkedType.commit),
int(GroupLink.Relationship.resolves),
]
))
commit_resolutions = {
i.group_id: d for i, d in itertools.izip(commit_results, serialize(commit_results, user))
}
else:
release_resolutions = {}
commit_resolutions = {}
actor_ids = set(r[-1] for r in six.itervalues(release_resolutions))
actor_ids.update(r.actor_id for r in six.itervalues(ignore_items))
if actor_ids:
users = list(User.objects.filter(
id__in=actor_ids,
is_active=True,
))
actors = {u.id: d for u, d in itertools.izip(users, serialize(users, user))}
else:
actors = {}
share_ids = dict(GroupShare.objects.filter(
group__in=item_list,
).values_list('group_id', 'uuid'))
result = {}
seen_stats = self._get_seen_stats(item_list, user)
for item in item_list:
active_date = item.active_at or item.first_seen
annotations = []
for plugin in plugins.for_project(project=item.project, version=1):
safe_execute(plugin.tags, None, item, annotations, _with_transaction=False)
for plugin in plugins.for_project(project=item.project, version=2):
annotations.extend(
safe_execute(plugin.get_annotations, group=item, _with_transaction=False) or ()
)
from sentry.integrations import IntegrationFeatures
for integration in Integration.objects.filter(
organizations=item.project.organization_id):
if not (integration.has_feature(IntegrationFeatures.ISSUE_BASIC) or integration.has_feature(
IntegrationFeatures.ISSUE_SYNC)):
continue
install = integration.get_installation(item.project.organization_id)
annotations.extend(
safe_execute(install.get_annotations, group=item, _with_transaction=False) or ()
)
resolution_actor = None
resolution_type = None
resolution = release_resolutions.get(item.id)
if resolution:
resolution_type = 'release'
resolution_actor = actors.get(resolution[-1])
if not resolution:
resolution = commit_resolutions.get(item.id)
if resolution:
resolution_type = 'commit'
ignore_item = ignore_items.get(item.id)
if ignore_item:
ignore_actor = actors.get(ignore_item.actor_id)
else:
ignore_actor = None
result[item] = {
'assigned_to': resolved_assignees.get(item.id),
'is_bookmarked': item.id in bookmarks,
'subscription': subscriptions[item.id],
'has_seen': seen_groups.get(item.id, active_date) > active_date,
'annotations': annotations,
'ignore_until': ignore_item,
'ignore_actor': ignore_actor,
'resolution': resolution,
'resolution_type': resolution_type,
'resolution_actor': resolution_actor,
'share_id': share_ids.get(item.id),
}
result[item].update(seen_stats.get(item, {}))
return result
def get_attrs(self, item_list, user):
from sentry.plugins import plugins
GroupMeta.objects.populate_cache(item_list)
attach_foreignkey(item_list, Group.project)
if user.is_authenticated() and item_list:
bookmarks = set(
GroupBookmark.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', flat=True))
seen_groups = dict(
GroupSeen.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', 'last_seen'))
subscriptions = self._get_subscriptions(item_list, user)
else:
bookmarks = set()
seen_groups = {}
subscriptions = defaultdict(lambda: (False, None))
assignees = {
a.group_id: a.assigned_actor()
for a in GroupAssignee.objects.filter(group__in=item_list, )
}
resolved_assignees = Actor.resolve_dict(assignees)
try:
environment = self.environment_func()
except Environment.DoesNotExist:
user_counts = {}
first_seen = {}
last_seen = {}
times_seen = {}
else:
project_id = item_list[0].project_id
item_ids = [g.id for g in item_list]
user_counts = tagstore.get_groups_user_counts(
project_id,
item_ids,
environment_id=environment and environment.id,
)
first_seen = {}
last_seen = {}
times_seen = {}
if environment is not None:
environment_tagvalues = tagstore.get_group_list_tag_value(
project_id,
item_ids,
environment.id,
'environment',
environment.name,
)
for item_id, value in environment_tagvalues.items():
first_seen[item_id] = value.first_seen
last_seen[item_id] = value.last_seen
times_seen[item_id] = value.times_seen
else:
for item in item_list:
first_seen[item.id] = item.first_seen
last_seen[item.id] = item.last_seen
times_seen[item.id] = item.times_seen
ignore_items = {
g.group_id: g
for g in GroupSnooze.objects.filter(group__in=item_list, )
}
resolutions = {
i[0]: i[1:]
for i in GroupResolution.objects.filter(group__in=item_list,
).values_list(
'group',
'type',
'release__version',
'actor_id',
)
}
actor_ids = set(r[-1] for r in six.itervalues(resolutions))
actor_ids.update(r.actor_id for r in six.itervalues(ignore_items))
if actor_ids:
users = list(
User.objects.filter(
id__in=actor_ids,
is_active=True,
))
actors = {
u.id: d
for u, d in itertools.izip(users, serialize(users, user))
}
else:
actors = {}
share_ids = dict(
GroupShare.objects.filter(group__in=item_list, ).values_list(
'group_id', 'uuid'))
result = {}
for item in item_list:
active_date = item.active_at or item.first_seen
annotations = []
for plugin in plugins.for_project(project=item.project, version=1):
safe_execute(plugin.tags,
None,
item,
annotations,
_with_transaction=False)
for plugin in plugins.for_project(project=item.project, version=2):
annotations.extend(
safe_execute(plugin.get_annotations,
group=item,
_with_transaction=False) or ())
resolution = resolutions.get(item.id)
if resolution:
resolution_actor = actors.get(resolution[-1])
else:
resolution_actor = None
ignore_item = ignore_items.get(item.id)
if ignore_item:
ignore_actor = actors.get(ignore_item.actor_id)
else:
ignore_actor = None
result[item] = {
'assigned_to': resolved_assignees.get(item.id),
'is_bookmarked': item.id in bookmarks,
'subscription': subscriptions[item.id],
'has_seen':
seen_groups.get(item.id, active_date) > active_date,
'annotations': annotations,
'user_count': user_counts.get(item.id, 0),
'ignore_until': ignore_item,
'ignore_actor': ignore_actor,
'resolution': resolution,
'resolution_actor': resolution_actor,
'share_id': share_ids.get(item.id),
'times_seen': times_seen.get(item.id, 0),
'first_seen': first_seen.get(item.id), # TODO: missing?
'last_seen': last_seen.get(item.id),
}
return result
def get_attrs(self, item_list, user):
from sentry.plugins import plugins
GroupMeta.objects.populate_cache(item_list)
attach_foreignkey(item_list, Group.project)
if user.is_authenticated() and item_list:
bookmarks = set(
GroupBookmark.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', flat=True))
seen_groups = dict(
GroupSeen.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', 'last_seen'))
subscriptions = self._get_subscriptions(item_list, user)
else:
bookmarks = set()
seen_groups = {}
subscriptions = defaultdict(lambda: (False, None))
assignees = {
a.group_id: a.assigned_actor()
for a in GroupAssignee.objects.filter(group__in=item_list, )
}
resolved_assignees = Actor.resolve_dict(assignees)
try:
environment = self.environment_func()
except Environment.DoesNotExist:
user_counts = {}
first_seen = {}
last_seen = {}
times_seen = {}
else:
project_id = item_list[0].project_id
item_ids = [g.id for g in item_list]
user_counts = tagstore.get_groups_user_counts(
project_id,
item_ids,
environment_id=environment and environment.id,
)
first_seen = {}
last_seen = {}
times_seen = {}
if environment is not None:
environment_tagvalues = tagstore.get_group_list_tag_value(
project_id,
item_ids,
environment.id,
'environment',
environment.name,
)
for item_id, value in environment_tagvalues.items():
first_seen[item_id] = value.first_seen
last_seen[item_id] = value.last_seen
times_seen[item_id] = value.times_seen
else:
for item in item_list:
first_seen[item.id] = item.first_seen
last_seen[item.id] = item.last_seen
times_seen[item.id] = item.times_seen
ignore_items = {
g.group_id: g
for g in GroupSnooze.objects.filter(group__in=item_list, )
}
resolved_item_list = [
i for i in item_list if i.status == GroupStatus.RESOLVED
]
if resolved_item_list:
release_resolutions = {
i[0]: i[1:]
for i in GroupResolution.objects.filter(
group__in=resolved_item_list, ).values_list(
'group',
'type',
'release__version',
'actor_id',
)
}
# due to our laziness, and django's inability to do a reasonable join here
# we end up with two queries
commit_results = list(
Commit.objects.extra(
select={
'group_id': 'sentry_grouplink.group_id',
},
tables=['sentry_grouplink'],
where=[
'sentry_grouplink.linked_id = sentry_commit.id',
'sentry_grouplink.group_id IN ({})'.format(', '.join(
six.text_type(i.id) for i in resolved_item_list)),
'sentry_grouplink.linked_type = %s',
'sentry_grouplink.relationship = %s',
],
params=[
int(GroupLink.LinkedType.commit),
int(GroupLink.Relationship.resolves),
]))
commit_resolutions = {
i.group_id: d
for i, d in itertools.izip(commit_results,
serialize(commit_results, user))
}
else:
release_resolutions = {}
commit_resolutions = {}
actor_ids = set(r[-1] for r in six.itervalues(release_resolutions))
actor_ids.update(r.actor_id for r in six.itervalues(ignore_items))
if actor_ids:
users = list(
User.objects.filter(
id__in=actor_ids,
is_active=True,
))
actors = {
u.id: d
for u, d in itertools.izip(users, serialize(users, user))
}
else:
actors = {}
share_ids = dict(
GroupShare.objects.filter(group__in=item_list, ).values_list(
'group_id', 'uuid'))
result = {}
for item in item_list:
active_date = item.active_at or item.first_seen
annotations = []
for plugin in plugins.for_project(project=item.project, version=1):
safe_execute(plugin.tags,
None,
item,
annotations,
_with_transaction=False)
for plugin in plugins.for_project(project=item.project, version=2):
annotations.extend(
safe_execute(plugin.get_annotations,
group=item,
_with_transaction=False) or ())
from sentry.integrations import IntegrationFeatures
for integration in Integration.objects.filter(
organizations=item.project.organization_id):
if not (integration.has_feature(
IntegrationFeatures.ISSUE_BASIC)
or integration.has_feature(
IntegrationFeatures.ISSUE_SYNC)):
continue
install = integration.get_installation(
item.project.organization_id)
annotations.extend(
safe_execute(install.get_annotations,
group=item,
_with_transaction=False) or ())
resolution_actor = None
resolution_type = None
resolution = release_resolutions.get(item.id)
if resolution:
resolution_type = 'release'
resolution_actor = actors.get(resolution[-1])
if not resolution:
resolution = commit_resolutions.get(item.id)
if resolution:
resolution_type = 'commit'
ignore_item = ignore_items.get(item.id)
if ignore_item:
ignore_actor = actors.get(ignore_item.actor_id)
else:
ignore_actor = None
result[item] = {
'assigned_to': resolved_assignees.get(item.id),
'is_bookmarked': item.id in bookmarks,
'subscription': subscriptions[item.id],
'has_seen':
seen_groups.get(item.id, active_date) > active_date,
'annotations': annotations,
'user_count': user_counts.get(item.id, 0),
'ignore_until': ignore_item,
'ignore_actor': ignore_actor,
'resolution': resolution,
'resolution_type': resolution_type,
'resolution_actor': resolution_actor,
'share_id': share_ids.get(item.id),
'times_seen': times_seen.get(item.id, 0),
'first_seen': first_seen.get(item.id), # TODO: missing?
'last_seen': last_seen.get(item.id),
}
return result
def get_attrs(self, item_list, user):
from sentry.plugins import plugins
GroupMeta.objects.populate_cache(item_list)
attach_foreignkey(item_list, Group.project)
if user.is_authenticated() and item_list:
bookmarks = set(GroupBookmark.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', flat=True))
seen_groups = dict(GroupSeen.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', 'last_seen'))
subscriptions = self._get_subscriptions(item_list, user)
else:
bookmarks = set()
seen_groups = {}
subscriptions = defaultdict(lambda: (False, None))
assignees = dict(
(a.group_id, a.user)
for a in GroupAssignee.objects.filter(
group__in=item_list,
).select_related('user')
)
user_counts = dict(
GroupTagKey.objects.filter(
group__in=item_list,
key='sentry:user',
).values_list('group', 'values_seen')
)
ignore_durations = dict(
GroupSnooze.objects.filter(
group__in=item_list,
).values_list('group', 'until')
)
pending_resolutions = dict(
GroupResolution.objects.filter(
group__in=item_list,
status=GroupResolutionStatus.PENDING,
).values_list('group', 'release')
)
result = {}
for item in item_list:
active_date = item.active_at or item.first_seen
annotations = []
for plugin in plugins.for_project(project=item.project, version=1):
safe_execute(plugin.tags, None, item, annotations,
_with_transaction=False)
for plugin in plugins.for_project(project=item.project, version=2):
annotations.extend(safe_execute(plugin.get_annotations, group=item,
_with_transaction=False) or ())
result[item] = {
'assigned_to': serialize(assignees.get(item.id)),
'is_bookmarked': item.id in bookmarks,
'subscription': subscriptions[item.id],
'has_seen': seen_groups.get(item.id, active_date) > active_date,
'annotations': annotations,
'user_count': user_counts.get(item.id, 0),
'ignore_duration': ignore_durations.get(item.id),
'pending_resolution': pending_resolutions.get(item.id),
}
return result
def get_attrs(self, item_list, user):
from sentry.plugins import plugins
GroupMeta.objects.populate_cache(item_list)
attach_foreignkey(item_list, Group.project)
if user.is_authenticated() and item_list:
bookmarks = set(
GroupBookmark.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', flat=True)
)
seen_groups = dict(
GroupSeen.objects.filter(
user=user,
group__in=item_list,
).values_list('group_id', 'last_seen')
)
subscriptions = self._get_subscriptions(item_list, user)
else:
bookmarks = set()
seen_groups = {}
subscriptions = defaultdict(lambda: (False, None))
assignees = dict(
(a.group_id, a.user)
for a in GroupAssignee.objects.filter(
group__in=item_list,
).select_related('user')
)
user_counts = tagstore.get_group_values_seen([g.id for g in item_list], 'sentry:user')
ignore_items = {g.group_id: g for g in GroupSnooze.objects.filter(
group__in=item_list,
)}
resolutions = {
i[0]: i[1:]
for i in GroupResolution.objects.filter(
group__in=item_list,
).values_list(
'group',
'type',
'release__version',
'actor_id',
)
}
actor_ids = set(r[-1] for r in six.itervalues(resolutions))
actor_ids.update(r.actor_id for r in six.itervalues(ignore_items))
if actor_ids:
users = list(User.objects.filter(
id__in=actor_ids,
is_active=True,
))
actors = {u.id: d for u, d in itertools.izip(users, serialize(users, user))}
else:
actors = {}
share_ids = dict(GroupShare.objects.filter(
group__in=item_list,
).values_list('group_id', 'uuid'))
result = {}
for item in item_list:
active_date = item.active_at or item.first_seen
annotations = []
for plugin in plugins.for_project(project=item.project, version=1):
safe_execute(plugin.tags, None, item, annotations, _with_transaction=False)
for plugin in plugins.for_project(project=item.project, version=2):
annotations.extend(
safe_execute(plugin.get_annotations, group=item, _with_transaction=False) or ()
)
resolution = resolutions.get(item.id)
if resolution:
resolution_actor = actors.get(resolution[-1])
else:
resolution_actor = None
ignore_item = ignore_items.get(item.id)
if ignore_item:
ignore_actor = actors.get(ignore_item.actor_id)
else:
ignore_actor = None
result[item] = {
'assigned_to': serialize(assignees.get(item.id)),
'is_bookmarked': item.id in bookmarks,
'subscription': subscriptions[item.id],
'has_seen': seen_groups.get(item.id, active_date) > active_date,
'annotations': annotations,
'user_count': user_counts.get(item.id, 0),
'ignore_until': ignore_item,
'ignore_actor': ignore_actor,
'resolution': resolution,
'resolution_actor': resolution_actor,
'share_id': share_ids.get(item.id),
}
return result
def get_attrs(self, item_list, user):
from sentry.plugins.base import plugins
GroupMeta.objects.populate_cache(item_list)
attach_foreignkey(item_list, Group.project)
if user.is_authenticated() and item_list:
bookmarks = set(
GroupBookmark.objects.filter(
user=user, group__in=item_list).values_list("group_id",
flat=True))
seen_groups = dict(
GroupSeen.objects.filter(user=user,
group__in=item_list).values_list(
"group_id", "last_seen"))
subscriptions = self._get_subscriptions(item_list, user)
else:
bookmarks = set()
seen_groups = {}
subscriptions = defaultdict(lambda: (False, None))
assignees = {
a.group_id: a.assigned_actor()
for a in GroupAssignee.objects.filter(group__in=item_list)
}
resolved_assignees = Actor.resolve_dict(assignees)
ignore_items = {
g.group_id: g
for g in GroupSnooze.objects.filter(group__in=item_list)
}
resolved_item_list = [
i for i in item_list if i.status == GroupStatus.RESOLVED
]
if resolved_item_list:
release_resolutions = {
i[0]: i[1:]
for i in GroupResolution.objects.filter(
group__in=resolved_item_list).values_list(
"group", "type", "release__version", "actor_id")
}
# due to our laziness, and django's inability to do a reasonable join here
# we end up with two queries
commit_results = list(
Commit.objects.extra(
select={"group_id": "sentry_grouplink.group_id"},
tables=["sentry_grouplink"],
where=[
"sentry_grouplink.linked_id = sentry_commit.id",
"sentry_grouplink.group_id IN ({})".format(", ".join(
six.text_type(i.id) for i in resolved_item_list)),
"sentry_grouplink.linked_type = %s",
"sentry_grouplink.relationship = %s",
],
params=[
int(GroupLink.LinkedType.commit),
int(GroupLink.Relationship.resolves)
],
))
commit_resolutions = {
i.group_id: d
for i, d in zip(commit_results, serialize(
commit_results, user))
}
else:
release_resolutions = {}
commit_resolutions = {}
actor_ids = set(r[-1] for r in six.itervalues(release_resolutions))
actor_ids.update(r.actor_id for r in six.itervalues(ignore_items))
if actor_ids:
users = list(User.objects.filter(id__in=actor_ids, is_active=True))
actors = {u.id: d for u, d in zip(users, serialize(users, user))}
else:
actors = {}
share_ids = dict(
GroupShare.objects.filter(group__in=item_list).values_list(
"group_id", "uuid"))
result = {}
seen_stats = self._get_seen_stats(item_list, user)
for item in item_list:
active_date = item.active_at or item.first_seen
annotations = []
for plugin in plugins.for_project(project=item.project, version=1):
safe_execute(plugin.tags,
None,
item,
annotations,
_with_transaction=False)
for plugin in plugins.for_project(project=item.project, version=2):
annotations.extend(
safe_execute(plugin.get_annotations,
group=item,
_with_transaction=False) or ())
from sentry.integrations import IntegrationFeatures
for integration in Integration.objects.filter(
organizations=item.project.organization_id):
if not (integration.has_feature(
IntegrationFeatures.ISSUE_BASIC)
or integration.has_feature(
IntegrationFeatures.ISSUE_SYNC)):
continue
install = integration.get_installation(
item.project.organization_id)
annotations.extend(
safe_execute(install.get_annotations,
group=item,
_with_transaction=False) or ())
from sentry.models import PlatformExternalIssue
annotations.extend(
safe_execute(PlatformExternalIssue.get_annotations,
group=item,
_with_transaction=False) or ())
resolution_actor = None
resolution_type = None
resolution = release_resolutions.get(item.id)
if resolution:
resolution_type = "release"
resolution_actor = actors.get(resolution[-1])
if not resolution:
resolution = commit_resolutions.get(item.id)
if resolution:
resolution_type = "commit"
ignore_item = ignore_items.get(item.id)
if ignore_item:
ignore_actor = actors.get(ignore_item.actor_id)
else:
ignore_actor = None
result[item] = {
"assigned_to": resolved_assignees.get(item.id),
"is_bookmarked": item.id in bookmarks,
"subscription": subscriptions[item.id],
"has_seen":
seen_groups.get(item.id, active_date) > active_date,
"annotations": annotations,
"ignore_until": ignore_item,
"ignore_actor": ignore_actor,
"resolution": resolution,
"resolution_type": resolution_type,
"resolution_actor": resolution_actor,
"share_id": share_ids.get(item.id),
}
result[item].update(seen_stats.get(item, {}))
return result
def get_attrs(self, item_list, user):
from sentry.plugins.base import plugins
from sentry.integrations import IntegrationFeatures
from sentry.models import PlatformExternalIssue
GroupMeta.objects.populate_cache(item_list)
attach_foreignkey(item_list, Group.project)
if user.is_authenticated() and item_list:
bookmarks = set(
GroupBookmark.objects.filter(user=user, group__in=item_list).values_list(
"group_id", flat=True
)
)
seen_groups = dict(
GroupSeen.objects.filter(user=user, group__in=item_list).values_list(
"group_id", "last_seen"
)
)
subscriptions = self._get_subscriptions(item_list, user)
else:
bookmarks = set()
seen_groups = {}
subscriptions = defaultdict(lambda: (False, None))
assignees = {
a.group_id: a.assigned_actor()
for a in GroupAssignee.objects.filter(group__in=item_list)
}
resolved_assignees = Actor.resolve_dict(assignees)
ignore_items = {g.group_id: g for g in GroupSnooze.objects.filter(group__in=item_list)}
resolved_item_list = [i for i in item_list if i.status == GroupStatus.RESOLVED]
if resolved_item_list:
release_resolutions = {
i[0]: i[1:]
for i in GroupResolution.objects.filter(group__in=resolved_item_list).values_list(
"group", "type", "release__version", "actor_id"
)
}
# due to our laziness, and django's inability to do a reasonable join here
# we end up with two queries
commit_results = list(
Commit.objects.extra(
select={"group_id": "sentry_grouplink.group_id"},
tables=["sentry_grouplink"],
where=[
"sentry_grouplink.linked_id = sentry_commit.id",
"sentry_grouplink.group_id IN ({})".format(
", ".join(six.text_type(i.id) for i in resolved_item_list)
),
"sentry_grouplink.linked_type = %s",
"sentry_grouplink.relationship = %s",
],
params=[int(GroupLink.LinkedType.commit), int(GroupLink.Relationship.resolves)],
)
)
commit_resolutions = {
i.group_id: d for i, d in zip(commit_results, serialize(commit_results, user))
}
else:
release_resolutions = {}
commit_resolutions = {}
actor_ids = set(r[-1] for r in six.itervalues(release_resolutions))
actor_ids.update(r.actor_id for r in six.itervalues(ignore_items))
if actor_ids:
users = list(User.objects.filter(id__in=actor_ids, is_active=True))
actors = {u.id: d for u, d in zip(users, serialize(users, user))}
else:
actors = {}
share_ids = dict(
GroupShare.objects.filter(group__in=item_list).values_list("group_id", "uuid")
)
result = {}
seen_stats = self._get_seen_stats(item_list, user)
annotations_by_group_id = defaultdict(list)
organization_id_list = list(set(item.project.organization_id for item in item_list))
# if no groups, then we can't proceed but this seems to be a valid use case
if not item_list:
return {}
if len(organization_id_list) > 1:
# this should never happen but if it does we should know about it
logger.warn(
"Found multiple organizations for groups: %s, with orgs: %s"
% ([item.id for item in item_list], organization_id_list)
)
# should only have 1 org at this point
organization_id = organization_id_list[0]
organization = Organization.objects.get_from_cache(id=organization_id)
has_unhandled_flag = features.has(
"organizations:unhandled-issue-flag", organization, actor=user
)
# find all the integration installs that have issue tracking
for integration in Integration.objects.filter(organizations=organization_id):
if not (
integration.has_feature(IntegrationFeatures.ISSUE_BASIC)
or integration.has_feature(IntegrationFeatures.ISSUE_SYNC)
):
continue
install = integration.get_installation(organization_id)
local_annotations_by_group_id = (
safe_execute(
install.get_annotations_for_group_list,
group_list=item_list,
_with_transaction=False,
)
or {}
)
merge_list_dictionaries(annotations_by_group_id, local_annotations_by_group_id)
# find the external issues for sentry apps and add them in
local_annotations_by_group_id = (
safe_execute(
PlatformExternalIssue.get_annotations_for_group_list,
group_list=item_list,
_with_transaction=False,
)
or {}
)
merge_list_dictionaries(annotations_by_group_id, local_annotations_by_group_id)
snuba_stats = {}
if has_unhandled_flag:
snuba_stats = self._get_group_snuba_stats(item_list, seen_stats)
for item in item_list:
active_date = item.active_at or item.first_seen
annotations = []
annotations.extend(annotations_by_group_id[item.id])
# add the annotations for plugins
# note that the model GroupMeta where all the information is stored is already cached at the top of this function
# so these for loops doesn't make a bunch of queries
for plugin in plugins.for_project(project=item.project, version=1):
safe_execute(plugin.tags, None, item, annotations, _with_transaction=False)
for plugin in plugins.for_project(project=item.project, version=2):
annotations.extend(
safe_execute(plugin.get_annotations, group=item, _with_transaction=False) or ()
)
resolution_actor = None
resolution_type = None
resolution = release_resolutions.get(item.id)
if resolution:
resolution_type = "release"
resolution_actor = actors.get(resolution[-1])
if not resolution:
resolution = commit_resolutions.get(item.id)
if resolution:
resolution_type = "commit"
ignore_item = ignore_items.get(item.id)
if ignore_item:
ignore_actor = actors.get(ignore_item.actor_id)
else:
ignore_actor = None
result[item] = {
"id": item.id,
"assigned_to": resolved_assignees.get(item.id),
"is_bookmarked": item.id in bookmarks,
"subscription": subscriptions[item.id],
"has_seen": seen_groups.get(item.id, active_date) > active_date,
"annotations": annotations,
"ignore_until": ignore_item,
"ignore_actor": ignore_actor,
"resolution": resolution,
"resolution_type": resolution_type,
"resolution_actor": resolution_actor,
"share_id": share_ids.get(item.id),
}
if has_unhandled_flag:
result[item]["is_unhandled"] = bool(snuba_stats.get(item.id, {}).get("unhandled"))
if seen_stats:
result[item].update(seen_stats.get(item, {}))
return result
def get_attrs(self, item_list, user, **kwargs):
alert_rules = {item.id: item for item in item_list}
attach_foreignkey(item_list,
AlertRule.snuba_query,
related=("environment", ))
result = defaultdict(dict)
triggers = AlertRuleTrigger.objects.filter(
alert_rule__in=item_list).order_by("label")
serialized_triggers = serialize(list(triggers))
for trigger, serialized in zip(triggers, serialized_triggers):
alert_rule_triggers = result[alert_rules[
trigger.alert_rule_id]].setdefault("triggers", [])
alert_rule_triggers.append(serialized)
alert_rule_projects = AlertRule.objects.filter(
id__in=[item.id for item in item_list]).values_list(
"id", "snuba_query__subscriptions__project__slug")
for alert_rule_id, project_slug in alert_rule_projects:
rule_result = result[alert_rules[alert_rule_id]].setdefault(
"projects", [])
rule_result.append(project_slug)
for rule_activity in AlertRuleActivity.objects.filter(
alert_rule__in=item_list,
type=AlertRuleActivityType.CREATED.value).select_related(
"alert_rule", "user"):
if rule_activity.user:
user = {
"id": rule_activity.user.id,
"name": rule_activity.user.get_display_name(),
"email": rule_activity.user.email,
}
else:
user = None
result[alert_rules[rule_activity.alert_rule.id]].update(
{"created_by": user})
resolved_actors = {}
owners_by_type = defaultdict(list)
for item in item_list:
if item.owner_id is not None:
owners_by_type[actor_type_to_string(item.owner.type)].append(
item.owner_id)
for k, v in ACTOR_TYPES.items():
resolved_actors[k] = {
a.actor_id: a.id
for a in actor_type_to_class(v).objects.filter(
actor_id__in=owners_by_type[k])
}
for alert_rule in alert_rules.values():
if alert_rule.owner_id:
type = actor_type_to_string(alert_rule.owner.type)
result[alert_rule][
"owner"] = f"{type}:{resolved_actors[type][alert_rule.owner_id]}"
if "original_alert_rule" in self.expand:
snapshot_activities = AlertRuleActivity.objects.filter(
alert_rule__in=item_list,
type=AlertRuleActivityType.SNAPSHOT.value,
)
for activity in snapshot_activities:
result[alert_rules[activity.alert_rule_id]][
"originalAlertRuleId"] = activity.previous_alert_rule_id
return result
