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