def get_attrs(
self, item_list: List[ExternalActor], user: User, **kwargs: Any
) -> MutableMapping[ExternalActor, MutableMapping[str, Any]]:
# get all of the actor ids we need to lookup
external_actors_by_actor_id = {
external_actor.actor_id: external_actor
for external_actor in item_list
}
# iterating over each actor id and split it up by type.
actor_ids_by_type = defaultdict(list)
for actor_id, external_actor in external_actors_by_actor_id.items():
if actor_id is not None:
type_str = actor_type_to_string(external_actor.actor.type)
actor_ids_by_type[type_str].append(actor_id)
# each actor id maps to an object
resolved_actors: MutableMapping[int, Any] = {}
for type_str, type_id in ACTOR_TYPES.items():
klass = actor_type_to_class(type_id)
actor_ids = actor_ids_by_type[type_str]
for model in klass.objects.filter(actor_id__in=actor_ids):
resolved_actors[model.actor_id] = {type_str: model}
# create a mapping of external actor to a set of attributes. Those attributes are either {"user": User} or {"team": Team}.
return {
external_actor: resolved_actors[external_actor.actor_id]
for external_actor in item_list
}
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]}"
return result
def get_attrs(
self, item_list: List[ExternalActor], user: User, **kwargs: Any
) -> MutableMapping[Any, Any]:
external_actors_by_actor_id = {
external_actor.actor_id: external_actor for external_actor in item_list
}
actor_ids_by_type = defaultdict(list)
for actor_id, external_actor in external_actors_by_actor_id.items():
if actor_id is not None:
type_str = actor_type_to_string(external_actor.actor.type)
actor_ids_by_type[type_str].append(actor_id)
resolved_actors_by_type: MutableMapping[str, Mapping[int, int]] = defaultdict(dict)
for type_str, type_id in ACTOR_TYPES.items():
klass = actor_type_to_class(type_id)
actor_ids = actor_ids_by_type[type_str]
resolved_actors = klass.objects.filter(actor_id__in=actor_ids)
resolved_actors_by_type[type_str] = {model.actor_id: model for model in resolved_actors}
results: MutableMapping[ExternalActor, MutableMapping[str, Any]] = defaultdict(dict)
for type_str, mapping in resolved_actors_by_type.items():
for actor_id, model in mapping.items():
external_actor = external_actors_by_actor_id[actor_id]
results[external_actor][type_str] = model
return results
def get_attrs(self, item_list, user, **kwargs):
environments = Environment.objects.in_bulk(
[_f for _f in [i.environment_id for i in item_list] if _f])
result = {
i: {
"environment": environments.get(i.environment_id)
}
for i in item_list
}
for rule_activity in RuleActivity.objects.filter(
rule__in=item_list,
type=RuleActivityType.CREATED.value).select_related(
"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[rule_activity.rule].update({"created_by": user})
rules = {item.id: item for item in item_list}
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 rule in rules.values():
if rule.owner_id:
type = actor_type_to_string(rule.owner.type)
if rule.owner_id in resolved_actors[type]:
result[rule][
"owner"] = f"{type}:{resolved_actors[type][rule.owner_id]}"
return result
def get_attrs(self, item_list, user, **kwargs):
alert_rules = {item.id: item for item in item_list}
prefetch_related_objects(item_list, "snuba_query__environment")
result = defaultdict(dict)
triggers = AlertRuleTrigger.objects.filter(
alert_rule__in=item_list).order_by("label")
serialized_triggers = serialize(list(triggers), **kwargs)
trigger_actions = AlertRuleTriggerAction.objects.filter(
alert_rule_trigger__alert_rule_id__in=alert_rules.keys()).exclude(
sentry_app_config__isnull=True, sentry_app_id__isnull=True)
sentry_app_installations_by_sentry_app_id = (
SentryAppInstallation.objects.get_related_sentry_app_components(
organization_ids={
alert_rule.organization_id
for alert_rule in alert_rules.values()
},
sentry_app_ids=trigger_actions.values_list("sentry_app_id",
flat=True),
type="alert-rule-action",
))
for trigger, serialized in zip(triggers, serialized_triggers):
alert_rule_triggers = result[alert_rules[
trigger.alert_rule_id]].setdefault("triggers", [])
for action in serialized.get("actions", []):
install = sentry_app_installations_by_sentry_app_id.get(
action.get("sentryAppId"))
if install:
action["_sentry_app_component"] = install.get(
"sentry_app_component")
action["_sentry_app_installation"] = install.get(
"sentry_app_installation")
action["sentryAppInstallationUuid"] = install.get(
"sentry_app_installation").get("uuid")
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)
if alert_rule.owner_id in resolved_actors[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
def get_attrs(self, item_list, user, **kwargs):
environments = Environment.objects.in_bulk(
[_f for _f in [i.environment_id for i in item_list] if _f])
result = {
i: {
"environment": environments.get(i.environment_id)
}
for i in item_list
}
for rule_activity in RuleActivity.objects.filter(
rule__in=item_list,
type=RuleActivityType.CREATED.value).select_related(
"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[rule_activity.rule].update({"created_by": user})
rules = {item.id: item for item in item_list}
resolved_actors = {}
owners_by_type = defaultdict(list)
sentry_app_uuids = {
action.get("sentryAppInstallationUuid")
for rule in rules.values()
for action in rule.data.get("actions", [])
}
sentry_app_ids = (SentryAppInstallation.objects.filter(
uuid__in=sentry_app_uuids).distinct("sentry_app_id").values_list(
"sentry_app_id", flat=True))
sentry_app_installations_by_uuid = (
SentryAppInstallation.objects.get_related_sentry_app_components(
organization_ids={
rule.project.organization_id
for rule in rules.values()
},
sentry_app_ids=sentry_app_ids,
type="alert-rule-action",
group_by="uuid",
))
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 rule in rules.values():
if rule.owner_id:
type = actor_type_to_string(rule.owner.type)
if rule.owner_id in resolved_actors[type]:
result[rule][
"owner"] = f"{type}:{resolved_actors[type][rule.owner_id]}"
for action in rule.data.get("actions", []):
install = sentry_app_installations_by_uuid.get(
action.get("sentryAppInstallationUuid"))
if install:
action["_sentry_app_component"] = install.get(
"sentry_app_component")
action["_sentry_app_installation"] = install.get(
"sentry_app_installation")
if "lastTriggered" in self.expand:
last_triggered_lookup = {
rfh["rule_id"]: rfh["date_added"]
for rfh in RuleFireHistory.objects.filter(
rule__in=item_list).values("rule_id").annotate(
date_added=Max("date_added"))
}
for rule in item_list:
result[rule]["last_triggered"] = last_triggered_lookup.get(
rule.id, None)
return result
