def get(self, request, project):
"""
Fetches alert rules and legacy rules for a project
"""
alert_rules = AlertRule.objects.fetch_for_project(project)
if not features.has("organizations:performance-view", project.organization):
# Filter to only error alert rules
alert_rules = alert_rules.filter(snuba_query__dataset=Dataset.Events.value)
alert_rule_intermediary = CombinedQuerysetIntermediary(alert_rules, "date_added")
rule_intermediary = CombinedQuerysetIntermediary(
Rule.objects.filter(
project=project, status__in=[RuleStatus.ACTIVE, RuleStatus.INACTIVE]
),
"date_added",
)
return self.paginate(
request,
paginator_cls=CombinedQuerysetPaginator,
on_results=lambda x: serialize(x, request.user, CombinedRuleSerializer()),
default_per_page=25,
intermediaries=[alert_rule_intermediary, rule_intermediary],
desc=True,
)
def get(self, request, organization):
"""
Fetches alert rules and legacy rules for an organization
"""
project_ids = self.get_requested_project_ids(request) or None
alert_rules = AlertRule.objects.fetch_for_organization(organization, project_ids)
if not features.has("organizations:performance-view", organization):
# Filter to only error alert rules
alert_rules = alert_rules.filter(snuba_query__dataset=Dataset.Events.value)
if project_ids is None:
project_ids = Project.objects.filter(organization=organization).values_list(
"id", flat=True
)
issue_rules = Rule.objects.filter(
status__in=[RuleStatus.ACTIVE, RuleStatus.INACTIVE], project__in=project_ids
)
is_asc = request.GET.get("asc", False)
sort_key = request.GET.get("sort", "date_added")
rule_sort_key = (
sort_key if sort_key != "name" else "label"
) # Rule's don't share the same field name for their title/label/name...so we account for that here.
alert_rule_intermediary = CombinedQuerysetIntermediary(alert_rules, sort_key)
rule_intermediary = CombinedQuerysetIntermediary(issue_rules, rule_sort_key)
return self.paginate(
request,
paginator_cls=CombinedQuerysetPaginator,
on_results=lambda x: serialize(x, request.user, CombinedRuleSerializer()),
default_per_page=25,
intermediaries=[alert_rule_intermediary, rule_intermediary],
desc=not is_asc,
)
def get(self, request, organization):
"""
Fetches alert rules and legacy rules for an organization
"""
project_ids = self.get_requested_project_ids(request) or None
alert_rules = AlertRule.objects.fetch_for_organization(organization, project_ids)
if not features.has("organizations:performance-view", organization):
# Filter to only error alert rules
alert_rules = alert_rules.filter(snuba_query__dataset=Dataset.Events.value)
if project_ids is None:
project_ids = Project.objects.filter(organization=organization).values_list(
"id", flat=True
)
issue_rules = Rule.objects.filter(
status__in=[RuleStatus.ACTIVE, RuleStatus.INACTIVE], project__in=project_ids
)
return self.paginate(
request,
paginator_cls=CombinedQuerysetPaginator,
on_results=lambda x: serialize(x, request.user, CombinedRuleSerializer()),
default_per_page=25,
order_by="-date_added",
querysets=[alert_rules, issue_rules],
)
def get(self, request, project):
"""
Fetches alert rules and legacy rules for an organization
"""
if not features.has("organizations:incidents",
project.organization,
actor=request.user):
raise ResourceDoesNotExist
cursor_string = request.GET.get(
"cursor",
six.binary_type(int(time.time() * 1000000)) + ":0:0")
try:
limit = min(100, int(request.GET.get("limit", 25)))
except ValueError as e:
return Response(
{
"detail":
"Invalid input for `limit`. Error: %s" % six.text_type(e)
},
status=400)
cursor = Cursor.from_string(cursor_string)
cursor_date = datetime.fromtimestamp(
float(cursor.value) / 1000000).replace(tzinfo=timezone.utc)
alert_rule_queryset = (
AlertRule.objects.fetch_for_project(project).filter(
date_added__lte=cursor_date).order_by("-date_added")[:limit +
1])
legacy_rule_queryset = (Rule.objects.filter(
project=project,
status__in=[
RuleStatus.ACTIVE, RuleStatus.INACTIVE
]).select_related("project").filter(
date_added__lte=cursor_date).order_by("-date_added")[:(limit +
1)])
combined_rules = list(alert_rule_queryset) + list(legacy_rule_queryset)
combined_rules.sort(key=lambda instance:
(instance.date_added, type(instance)),
reverse=True)
combined_rules = combined_rules[cursor.offset:cursor.offset + limit +
1]
def get_item_key(item, for_prev=False):
return 1000000 * float(item.date_added.strftime("%s.%f"))
cursor_result = build_cursor(results=combined_rules,
cursor=cursor,
key=get_item_key,
limit=limit,
is_desc=True)
results = list(cursor_result)
context = serialize(results, request.user, CombinedRuleSerializer())
response = Response(context)
self.add_cursor_headers(request, response, cursor_result)
return response
def get(self, request, project):
"""
Fetches alert rules and legacy rules for an organization
"""
return self.paginate(
request,
paginator_cls=CombinedQuerysetPaginator,
on_results=lambda x: serialize(x, request.user,
CombinedRuleSerializer()),
default_per_page=25,
order_by="-date_added",
querysets=[
AlertRule.objects.fetch_for_project(project),
Rule.objects.filter(
project=project,
status__in=[RuleStatus.ACTIVE, RuleStatus.INACTIVE]),
],
)
def get(self, request, organization):
"""
Fetches alert rules and legacy rules for an organization
"""
project_ids = self.get_requested_project_ids(request) or None
if project_ids == {-1}: # All projects for org:
project_ids = Project.objects.filter(
organization=organization).values_list("id", flat=True)
elif project_ids is None: # All projects for user
org_team_list = Team.objects.filter(
organization=organization).values_list("id", flat=True)
user_team_list = OrganizationMemberTeam.objects.filter(
organizationmember__user=request.user,
team__in=org_team_list).values_list("team", flat=True)
project_ids = Project.objects.filter(
teams__in=user_team_list).values_list("id", flat=True)
teams = set(request.GET.getlist("team", []))
team_filter_query = None
if teams:
# do normal teams lookup based on request params
verified_ids = set()
unassigned = None
if "unassigned" in teams:
teams.remove("unassigned")
unassigned = Q(owner_id=None)
if "myteams" in teams:
teams.remove("myteams")
if is_active_superuser(request):
# retrieve all teams within the organization
myteams = Team.objects.filter(
organization=organization,
status=TeamStatus.VISIBLE).values_list("id", flat=True)
verified_ids.update(myteams)
else:
myteams = [t.id for t in request.access.teams]
verified_ids.update(myteams)
for team_id in teams: # Verify each passed Team id is numeric
if type(team_id) is not int and not team_id.isdigit():
return Response(f"Invalid Team ID: {team_id}",
status=status.HTTP_400_BAD_REQUEST)
teams.update(verified_ids)
teams = Team.objects.filter(id__in=teams)
for team in teams:
if team.id in verified_ids:
continue
if not request.access.has_team_access(team):
return Response(
f"Error: You do not have permission to access {team.name}",
status=status.HTTP_400_BAD_REQUEST,
)
team_filter_query = Q(
owner_id__in=teams.values_list("actor_id", flat=True))
if unassigned:
team_filter_query = team_filter_query | unassigned
alert_rules = AlertRule.objects.fetch_for_organization(
organization, project_ids)
if not features.has("organizations:performance-view", organization):
# Filter to only error alert rules
alert_rules = alert_rules.filter(
snuba_query__dataset=Dataset.Events.value)
issue_rules = Rule.objects.filter(
status__in=[RuleStatus.ACTIVE, RuleStatus.INACTIVE],
project__in=project_ids)
name = request.GET.get("name", None)
if name:
alert_rules = alert_rules.filter(Q(name__icontains=name))
issue_rules = issue_rules.filter(Q(label__icontains=name))
if team_filter_query:
alert_rules = alert_rules.filter(team_filter_query)
issue_rules = issue_rules.filter(team_filter_query)
is_asc = request.GET.get("asc", False) == "1"
sort_key = request.GET.get("sort", "date_added")
rule_sort_key = (
sort_key if sort_key != "name" else "label"
) # Rule's don't share the same field name for their title/label/name...so we account for that here.
case_insensitive = sort_key == "name"
alert_rule_intermediary = CombinedQuerysetIntermediary(
alert_rules, sort_key)
rule_intermediary = CombinedQuerysetIntermediary(
issue_rules, rule_sort_key)
return self.paginate(
request,
paginator_cls=CombinedQuerysetPaginator,
on_results=lambda x: serialize(x, request.user,
CombinedRuleSerializer()),
default_per_page=25,
intermediaries=[alert_rule_intermediary, rule_intermediary],
desc=not is_asc,
cursor_cls=StringCursor if case_insensitive else Cursor,
case_insensitive=case_insensitive,
)
