incident.AlertSource

import * as pulumi from "@pulumi/pulumi";
import * as incident from "@pulumi/incident";

// An alert's priority is a catalog entry, so the priorities themselves are looked up rather
// than declared. Urgent and In-hours are the ones a new account starts with; use whichever
// your organisation has.
const alertPriority = incident.getCatalogType({
    typeName: "AlertPriority",
});
const urgentPriority = alertPriority.then(alertPriority => incident.getCatalogEntry({
    catalogTypeId: alertPriority.id,
    identifier: "Urgent",
}));
const inHoursPriority = alertPriority.then(alertPriority => incident.getCatalogEntry({
    catalogTypeId: alertPriority.id,
    identifier: "In-hours",
}));
const prometheusAlert = incident.getRichText({
    featureSet: "rich",
    markdown: `Fired by the **Prometheus alertmanager**.

Runbook: {{payload.annotations.runbook_url}}
`,
});
// An alert source, without the attributes it populates. Each of those is its own
// incident_alert_source_attribute resource, so editing one attribute doesn't
// mean rewriting the source.
const prometheus = new incident.AlertSource("prometheus", {
    name: "Prometheus",
    sourceType: "http",
    owningTeamIds: [platformTeam.id],
    title: {
        literal: "{{payload.labels.alertname}} on {{payload.labels.service}}",
    },
    description: {
        literal: prometheusAlert.then(prometheusAlert => prometheusAlert.json),
    },
    namedExpressions: [
        {
            name: "severity_string",
            startFrom: "payload",
            operations: [{
                parse: {
                    "function": "$.labels.severity",
                    as: "String",
                },
            }],
        },
        {
            name: "severity_lookup",
            startFrom: ".",
            operations: [{
                branches: {
                    as: alertPriority.then(alertPriority => alertPriority.attributeType),
                    "if": {
                        conditions: [{
                            subject: "expressions[\"severity_string\"]",
                            operation: "one_of",
                            params: [{
                                values: [
                                    "critical",
                                    "page",
                                ],
                            }],
                        }],
                        result: {
                            valueLiteral: urgentPriority.then(urgentPriority => urgentPriority.id),
                        },
                    },
                },
            }],
            fallback: {
                result: {
                    valueLiteral: inHoursPriority.then(inHoursPriority => inHoursPriority.id),
                },
            },
        },
    ],
    priority: {
        expressionRef: "severity_lookup",
    },
});
// A heartbeat source writes its own title and description, and needs the interval a
// ping is expected within.
const nightlyBackup = new incident.AlertSource("nightly_backup", {
    name: "Nightly backup",
    sourceType: "heartbeat",
    heartbeatOptions: {
        intervalSeconds: 86400,
        failureThreshold: 1,
        gracePeriodSeconds: 3600,
    },
    disabled: false,
});
// A private source's alerts are visible to nobody until you say which teams can
// see them.
const securityScanner = new incident.AlertSource("security_scanner", {
    name: "Security scanner",
    sourceType: "http",
    title: {
        literal: "{{payload.rule}} on {{payload.target}}",
    },
    description: {
        literal: "{{payload.detail}}",
    },
    isPrivate: true,
    visibleToTeams: {
        values: [securityTeam.id],
    },
});

import pulumi
import pulumi_incident as incident

# An alert's priority is a catalog entry, so the priorities themselves are looked up rather
# than declared. Urgent and In-hours are the ones a new account starts with; use whichever
# your organisation has.
alert_priority = incident.get_catalog_type(type_name="AlertPriority")
urgent_priority = incident.get_catalog_entry(catalog_type_id=alert_priority.id,
    identifier="Urgent")
in_hours_priority = incident.get_catalog_entry(catalog_type_id=alert_priority.id,
    identifier="In-hours")
prometheus_alert = incident.get_rich_text(feature_set="rich",
    markdown="""Fired by the **Prometheus alertmanager**.

Runbook: {{payload.annotations.runbook_url}}
""")
# An alert source, without the attributes it populates. Each of those is its own
# incident_alert_source_attribute resource, so editing one attribute doesn't
# mean rewriting the source.
prometheus = incident.AlertSource("prometheus",
    name="Prometheus",
    source_type="http",
    owning_team_ids=[platform_team["id"]],
    title={
        "literal": "{{payload.labels.alertname}} on {{payload.labels.service}}",
    },
    description={
        "literal": prometheus_alert.json,
    },
    named_expressions=[
        {
            "name": "severity_string",
            "start_from": "payload",
            "operations": [{
                "parse": {
                    "function": "$.labels.severity",
                    "as_": "String",
                },
            }],
        },
        {
            "name": "severity_lookup",
            "start_from": ".",
            "operations": [{
                "branches": {
                    "as_": alert_priority.attribute_type,
                    "if_": {
                        "conditions": [{
                            "subject": "expressions[\"severity_string\"]",
                            "operation": "one_of",
                            "params": [{
                                "values": [
                                    "critical",
                                    "page",
                                ],
                            }],
                        }],
                        "result": {
                            "value_literal": urgent_priority.id,
                        },
                    },
                },
            }],
            "fallback": {
                "result": {
                    "value_literal": in_hours_priority.id,
                },
            },
        },
    ],
    priority={
        "expression_ref": "severity_lookup",
    })
# A heartbeat source writes its own title and description, and needs the interval a
# ping is expected within.
nightly_backup = incident.AlertSource("nightly_backup",
    name="Nightly backup",
    source_type="heartbeat",
    heartbeat_options={
        "interval_seconds": 86400,
        "failure_threshold": 1,
        "grace_period_seconds": 3600,
    },
    disabled=False)
# A private source's alerts are visible to nobody until you say which teams can
# see them.
security_scanner = incident.AlertSource("security_scanner",
    name="Security scanner",
    source_type="http",
    title={
        "literal": "{{payload.rule}} on {{payload.target}}",
    },
    description={
        "literal": "{{payload.detail}}",
    },
    is_private=True,
    visible_to_teams={
        "values": [security_team["id"]],
    })

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/incident/v7/incident"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// An alert's priority is a catalog entry, so the priorities themselves are looked up rather
		// than declared. Urgent and In-hours are the ones a new account starts with; use whichever
		// your organisation has.
		alertPriority, err := incident.LookupCatalogType(ctx, &incident.LookupCatalogTypeArgs{
			TypeName: pulumi.StringRef("AlertPriority"),
		}, nil)
		if err != nil {
			return err
		}
		urgentPriority, err := incident.LookupCatalogEntry(ctx, &incident.LookupCatalogEntryArgs{
			CatalogTypeId: alertPriority.Id,
			Identifier:    "Urgent",
		}, nil)
		if err != nil {
			return err
		}
		inHoursPriority, err := incident.LookupCatalogEntry(ctx, &incident.LookupCatalogEntryArgs{
			CatalogTypeId: alertPriority.Id,
			Identifier:    "In-hours",
		}, nil)
		if err != nil {
			return err
		}
		prometheusAlert, err := incident.GetRichText(ctx, &incident.GetRichTextArgs{
			FeatureSet: "rich",
			Markdown:   "Fired by the **Prometheus alertmanager**.\n\nRunbook: {{payload.annotations.runbook_url}}\n",
		}, nil)
		if err != nil {
			return err
		}
		// An alert source, without the attributes it populates. Each of those is its own
		// incident_alert_source_attribute resource, so editing one attribute doesn't
		// mean rewriting the source.
		_, err = incident.NewAlertSource(ctx, "prometheus", &incident.AlertSourceArgs{
			Name:       pulumi.String("Prometheus"),
			SourceType: pulumi.String("http"),
			OwningTeamIds: pulumi.StringArray{
				platformTeam.Id,
			},
			Title: &incident.AlertSourceTitleArgs{
				Literal: pulumi.String("{{payload.labels.alertname}} on {{payload.labels.service}}"),
			},
			Description: &incident.AlertSourceDescriptionArgs{
				Literal: pulumi.String(prometheusAlert.Json),
			},
			NamedExpressions: incident.AlertSourceNamedExpressionArray{
				&incident.AlertSourceNamedExpressionArgs{
					Name:      pulumi.String("severity_string"),
					StartFrom: pulumi.String("payload"),
					Operations: incident.AlertSourceNamedExpressionOperationArray{
						&incident.AlertSourceNamedExpressionOperationArgs{
							Parse: &incident.AlertSourceNamedExpressionOperationParseArgs{
								Function: pulumi.String("$.labels.severity"),
								As:       pulumi.String("String"),
							},
						},
					},
				},
				&incident.AlertSourceNamedExpressionArgs{
					Name:      pulumi.String("severity_lookup"),
					StartFrom: pulumi.String("."),
					Operations: incident.AlertSourceNamedExpressionOperationArray{
						&incident.AlertSourceNamedExpressionOperationArgs{
							Branches: &incident.AlertSourceNamedExpressionOperationBranchesArgs{
								As: pulumi.String(alertPriority.AttributeType),
								If: &incident.AlertSourceNamedExpressionOperationBranchesIfArgs{
									Conditions: incident.AlertSourceNamedExpressionOperationBranchesIfConditionArray{
										&incident.AlertSourceNamedExpressionOperationBranchesIfConditionArgs{
											Subject:   pulumi.String("expressions[\"severity_string\"]"),
											Operation: pulumi.String("one_of"),
											Params: incident.AlertSourceNamedExpressionOperationBranchesIfConditionParamArray{
												&incident.AlertSourceNamedExpressionOperationBranchesIfConditionParamArgs{
													Values: pulumi.StringArray{
														pulumi.String("critical"),
														pulumi.String("page"),
													},
												},
											},
										},
									},
									Result: &incident.AlertSourceNamedExpressionOperationBranchesIfResultArgs{
										ValueLiteral: pulumi.String(urgentPriority.Id),
									},
								},
							},
						},
					},
					Fallback: &incident.AlertSourceNamedExpressionFallbackArgs{
						Result: &incident.AlertSourceNamedExpressionFallbackResultArgs{
							ValueLiteral: pulumi.String(inHoursPriority.Id),
						},
					},
				},
			},
			Priority: &incident.AlertSourcePriorityArgs{
				ExpressionRef: pulumi.String("severity_lookup"),
			},
		})
		if err != nil {
			return err
		}
		// A heartbeat source writes its own title and description, and needs the interval a
		// ping is expected within.
		_, err = incident.NewAlertSource(ctx, "nightly_backup", &incident.AlertSourceArgs{
			Name:       pulumi.String("Nightly backup"),
			SourceType: pulumi.String("heartbeat"),
			HeartbeatOptions: &incident.AlertSourceHeartbeatOptionsArgs{
				IntervalSeconds:    pulumi.Float64(86400),
				FailureThreshold:   pulumi.Float64(1),
				GracePeriodSeconds: pulumi.Float64(3600),
			},
			Disabled: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		// A private source's alerts are visible to nobody until you say which teams can
		// see them.
		_, err = incident.NewAlertSource(ctx, "security_scanner", &incident.AlertSourceArgs{
			Name:       pulumi.String("Security scanner"),
			SourceType: pulumi.String("http"),
			Title: &incident.AlertSourceTitleArgs{
				Literal: pulumi.String("{{payload.rule}} on {{payload.target}}"),
			},
			Description: &incident.AlertSourceDescriptionArgs{
				Literal: pulumi.String("{{payload.detail}}"),
			},
			IsPrivate: pulumi.Bool(true),
			VisibleToTeams: &incident.AlertSourceVisibleToTeamsArgs{
				Values: pulumi.StringArray{
					securityTeam.Id,
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Incident = Pulumi.Incident;

return await Deployment.RunAsync(() => 
{
    // An alert's priority is a catalog entry, so the priorities themselves are looked up rather
    // than declared. Urgent and In-hours are the ones a new account starts with; use whichever
    // your organisation has.
    var alertPriority = Incident.GetCatalogType.Invoke(new()
    {
        TypeName = "AlertPriority",
    });

    var urgentPriority = Incident.GetCatalogEntry.Invoke(new()
    {
        CatalogTypeId = alertPriority.Apply(getCatalogTypeResult => getCatalogTypeResult.Id),
        Identifier = "Urgent",
    });

    var inHoursPriority = Incident.GetCatalogEntry.Invoke(new()
    {
        CatalogTypeId = alertPriority.Apply(getCatalogTypeResult => getCatalogTypeResult.Id),
        Identifier = "In-hours",
    });

    var prometheusAlert = Incident.GetRichText.Invoke(new()
    {
        FeatureSet = "rich",
        Markdown = @"Fired by the **Prometheus alertmanager**.

Runbook: {{payload.annotations.runbook_url}}
",
    });

    // An alert source, without the attributes it populates. Each of those is its own
    // incident_alert_source_attribute resource, so editing one attribute doesn't
    // mean rewriting the source.
    var prometheus = new Incident.AlertSource("prometheus", new()
    {
        Name = "Prometheus",
        SourceType = "http",
        OwningTeamIds = new[]
        {
            platformTeam.Id,
        },
        Title = new Incident.Inputs.AlertSourceTitleArgs
        {
            Literal = "{{payload.labels.alertname}} on {{payload.labels.service}}",
        },
        Description = new Incident.Inputs.AlertSourceDescriptionArgs
        {
            Literal = prometheusAlert.Apply(getRichTextResult => getRichTextResult.Json),
        },
        NamedExpressions = new[]
        {
            new Incident.Inputs.AlertSourceNamedExpressionArgs
            {
                Name = "severity_string",
                StartFrom = "payload",
                Operations = new[]
                {
                    new Incident.Inputs.AlertSourceNamedExpressionOperationArgs
                    {
                        Parse = new Incident.Inputs.AlertSourceNamedExpressionOperationParseArgs
                        {
                            Function = "$.labels.severity",
                            As = "String",
                        },
                    },
                },
            },
            new Incident.Inputs.AlertSourceNamedExpressionArgs
            {
                Name = "severity_lookup",
                StartFrom = ".",
                Operations = new[]
                {
                    new Incident.Inputs.AlertSourceNamedExpressionOperationArgs
                    {
                        Branches = new Incident.Inputs.AlertSourceNamedExpressionOperationBranchesArgs
                        {
                            As = alertPriority.Apply(getCatalogTypeResult => getCatalogTypeResult.AttributeType),
                            If = new Incident.Inputs.AlertSourceNamedExpressionOperationBranchesIfArgs
                            {
                                Conditions = new[]
                                {
                                    new Incident.Inputs.AlertSourceNamedExpressionOperationBranchesIfConditionArgs
                                    {
                                        Subject = "expressions[\"severity_string\"]",
                                        Operation = "one_of",
                                        Params = new[]
                                        {
                                            new Incident.Inputs.AlertSourceNamedExpressionOperationBranchesIfConditionParamArgs
                                            {
                                                Values = new[]
                                                {
                                                    "critical",
                                                    "page",
                                                },
                                            },
                                        },
                                    },
                                },
                                Result = new Incident.Inputs.AlertSourceNamedExpressionOperationBranchesIfResultArgs
                                {
                                    ValueLiteral = urgentPriority.Apply(getCatalogEntryResult => getCatalogEntryResult.Id),
                                },
                            },
                        },
                    },
                },
                Fallback = new Incident.Inputs.AlertSourceNamedExpressionFallbackArgs
                {
                    Result = new Incident.Inputs.AlertSourceNamedExpressionFallbackResultArgs
                    {
                        ValueLiteral = inHoursPriority.Apply(getCatalogEntryResult => getCatalogEntryResult.Id),
                    },
                },
            },
        },
        Priority = new Incident.Inputs.AlertSourcePriorityArgs
        {
            ExpressionRef = "severity_lookup",
        },
    });

    // A heartbeat source writes its own title and description, and needs the interval a
    // ping is expected within.
    var nightlyBackup = new Incident.AlertSource("nightly_backup", new()
    {
        Name = "Nightly backup",
        SourceType = "heartbeat",
        HeartbeatOptions = new Incident.Inputs.AlertSourceHeartbeatOptionsArgs
        {
            IntervalSeconds = 86400,
            FailureThreshold = 1,
            GracePeriodSeconds = 3600,
        },
        Disabled = false,
    });

    // A private source's alerts are visible to nobody until you say which teams can
    // see them.
    var securityScanner = new Incident.AlertSource("security_scanner", new()
    {
        Name = "Security scanner",
        SourceType = "http",
        Title = new Incident.Inputs.AlertSourceTitleArgs
        {
            Literal = "{{payload.rule}} on {{payload.target}}",
        },
        Description = new Incident.Inputs.AlertSourceDescriptionArgs
        {
            Literal = "{{payload.detail}}",
        },
        IsPrivate = true,
        VisibleToTeams = new Incident.Inputs.AlertSourceVisibleToTeamsArgs
        {
            Values = new[]
            {
                securityTeam.Id,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.incident.IncidentFunctions;
import com.pulumi.incident.inputs.GetCatalogTypeArgs;
import com.pulumi.incident.inputs.GetCatalogEntryArgs;
import com.pulumi.incident.inputs.GetRichTextArgs;
import com.pulumi.incident.AlertSource;
import com.pulumi.incident.AlertSourceArgs;
import com.pulumi.incident.inputs.AlertSourceTitleArgs;
import com.pulumi.incident.inputs.AlertSourceDescriptionArgs;
import com.pulumi.incident.inputs.AlertSourceNamedExpressionArgs;
import com.pulumi.incident.inputs.AlertSourceNamedExpressionFallbackArgs;
import com.pulumi.incident.inputs.AlertSourceNamedExpressionFallbackResultArgs;
import com.pulumi.incident.inputs.AlertSourcePriorityArgs;
import com.pulumi.incident.inputs.AlertSourceHeartbeatOptionsArgs;
import com.pulumi.incident.inputs.AlertSourceVisibleToTeamsArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        // An alert's priority is a catalog entry, so the priorities themselves are looked up rather
        // than declared. Urgent and In-hours are the ones a new account starts with; use whichever
        // your organisation has.
        final var alertPriority = IncidentFunctions.getCatalogType(GetCatalogTypeArgs.builder()
            .typeName("AlertPriority")
            .build());

        final var urgentPriority = IncidentFunctions.getCatalogEntry(GetCatalogEntryArgs.builder()
            .catalogTypeId(alertPriority.id())
            .identifier("Urgent")
            .build());

        final var inHoursPriority = IncidentFunctions.getCatalogEntry(GetCatalogEntryArgs.builder()
            .catalogTypeId(alertPriority.id())
            .identifier("In-hours")
            .build());

        final var prometheusAlert = IncidentFunctions.getRichText(GetRichTextArgs.builder()
            .featureSet("rich")
            .markdown("""
Fired by the **Prometheus alertmanager**.

Runbook: {{payload.annotations.runbook_url}}
            """)
            .build());

        // An alert source, without the attributes it populates. Each of those is its own
        // incident_alert_source_attribute resource, so editing one attribute doesn't
        // mean rewriting the source.
        var prometheus = new AlertSource("prometheus", AlertSourceArgs.builder()
            .name("Prometheus")
            .sourceType("http")
            .owningTeamIds(platformTeam.id())
            .title(AlertSourceTitleArgs.builder()
                .literal("{{payload.labels.alertname}} on {{payload.labels.service}}")
                .build())
            .description(AlertSourceDescriptionArgs.builder()
                .literal(prometheusAlert.json())
                .build())
            .namedExpressions(            
                AlertSourceNamedExpressionArgs.builder()
                    .name("severity_string")
                    .startFrom("payload")
                    .operations(AlertSourceNamedExpressionOperationArgs.builder()
                        .parse(AlertSourceNamedExpressionOperationParseArgs.builder()
                            .function("$.labels.severity")
                            .as("String")
                            .build())
                        .build())
                    .build(),
                AlertSourceNamedExpressionArgs.builder()
                    .name("severity_lookup")
                    .startFrom(".")
                    .operations(AlertSourceNamedExpressionOperationArgs.builder()
                        .branches(AlertSourceNamedExpressionOperationBranchesArgs.builder()
                            .as(alertPriority.attributeType())
                            .if_(AlertSourceNamedExpressionOperationBranchesIfArgs.builder()
                                .conditions(AlertSourceNamedExpressionOperationBranchesIfConditionArgs.builder()
                                    .subject("expressions[\"severity_string\"]")
                                    .operation("one_of")
                                    .params(AlertSourceNamedExpressionOperationBranchesIfConditionParamArgs.builder()
                                        .values(                                        
                                            "critical",
                                            "page")
                                        .build())
                                    .build())
                                .result(AlertSourceNamedExpressionOperationBranchesIfResultArgs.builder()
                                    .valueLiteral(urgentPriority.id())
                                    .build())
                                .build())
                            .build())
                        .build())
                    .fallback(AlertSourceNamedExpressionFallbackArgs.builder()
                        .result(AlertSourceNamedExpressionFallbackResultArgs.builder()
                            .valueLiteral(inHoursPriority.id())
                            .build())
                        .build())
                    .build())
            .priority(AlertSourcePriorityArgs.builder()
                .expressionRef("severity_lookup")
                .build())
            .build());

        // A heartbeat source writes its own title and description, and needs the interval a
        // ping is expected within.
        var nightlyBackup = new AlertSource("nightlyBackup", AlertSourceArgs.builder()
            .name("Nightly backup")
            .sourceType("heartbeat")
            .heartbeatOptions(AlertSourceHeartbeatOptionsArgs.builder()
                .intervalSeconds(86400.0)
                .failureThreshold(1.0)
                .gracePeriodSeconds(3600.0)
                .build())
            .disabled(false)
            .build());

        // A private source's alerts are visible to nobody until you say which teams can
        // see them.
        var securityScanner = new AlertSource("securityScanner", AlertSourceArgs.builder()
            .name("Security scanner")
            .sourceType("http")
            .title(AlertSourceTitleArgs.builder()
                .literal("{{payload.rule}} on {{payload.target}}")
                .build())
            .description(AlertSourceDescriptionArgs.builder()
                .literal("{{payload.detail}}")
                .build())
            .isPrivate(true)
            .visibleToTeams(AlertSourceVisibleToTeamsArgs.builder()
                .values(securityTeam.id())
                .build())
            .build());

    }
}

resources:
  # An alert source, without the attributes it populates. Each of those is its own
  # incident_alert_source_attribute resource, so editing one attribute doesn't
  # mean rewriting the source.
  prometheus:
    type: incident:AlertSource
    properties:
      name: Prometheus
      sourceType: http
      owningTeamIds:
        - ${platformTeam.id}
      title:
        literal: '{{payload.labels.alertname}} on {{payload.labels.service}}'
      description:
        literal: ${prometheusAlert.json}
      namedExpressions:
        - name: severity_string
          startFrom: payload
          operations:
            - parse:
                function: $.labels.severity
                as: String
        - name: severity_lookup
          startFrom: .
          operations:
            - branches:
                as: ${alertPriority.attributeType}
                if:
                  conditions:
                    - subject: expressions["severity_string"]
                      operation: one_of
                      params:
                        - values:
                            - critical
                            - page
                  result:
                    valueLiteral: ${urgentPriority.id}
          fallback:
            result:
              valueLiteral: ${inHoursPriority.id}
      priority:
        expressionRef: severity_lookup
  # A heartbeat source writes its own title and description, and needs the interval a
  # ping is expected within.
  nightlyBackup:
    type: incident:AlertSource
    name: nightly_backup
    properties:
      name: Nightly backup
      sourceType: heartbeat
      heartbeatOptions:
        intervalSeconds: 86400
        failureThreshold: 1
        gracePeriodSeconds: 3600
      disabled: false
  # A private source's alerts are visible to nobody until you say which teams can
  # see them.
  securityScanner:
    type: incident:AlertSource
    name: security_scanner
    properties:
      name: Security scanner
      sourceType: http
      title:
        literal: '{{payload.rule}} on {{payload.target}}'
      description:
        literal: '{{payload.detail}}'
      isPrivate: true
      visibleToTeams:
        values:
          - ${securityTeam.id}
variables:
  # An alert's priority is a catalog entry, so the priorities themselves are looked up rather
  # than declared. Urgent and In-hours are the ones a new account starts with; use whichever
  # your organisation has.
  alertPriority:
    fn::invoke:
      function: incident:getCatalogType
      arguments:
        typeName: AlertPriority
  urgentPriority:
    fn::invoke:
      function: incident:getCatalogEntry
      arguments:
        catalogTypeId: ${alertPriority.id}
        identifier: Urgent
  inHoursPriority:
    fn::invoke:
      function: incident:getCatalogEntry
      arguments:
        catalogTypeId: ${alertPriority.id}
        identifier: In-hours
  prometheusAlert:
    fn::invoke:
      function: incident:getRichText
      arguments:
        featureSet: rich
        markdown: |
          Fired by the **Prometheus alertmanager**.

          Runbook: {{payload.annotations.runbook_url}}