incident.AlertAttribute

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

// Create an alert attribute that points at a single Github user in the catalog.
//
// Take the engine type from the catalog type itself rather than writing it out: a type one
// of our integrations owns is referenced by its registry name, and a type you manage by its
// ID, so the two don't have the same shape.
const githubUser = incident.getCatalogType({
    typeName: "GithubUser",
});
const githubUserAlertAttribute = new incident.AlertAttribute("github_user", {
    name: "Github user",
    type: githubUser.then(githubUser => githubUser.attributeType),
    array: false,
    required: true,
});
// Create an optional alert attribute for severity information
const severity = new incident.AlertAttribute("severity", {
    name: "Severity",
    type: "String",
    array: false,
    required: false,
    emoji: "warning",
});
// An attribute is account-wide, so declare it once. What differs between environments is the
// binding that fills it in, which belongs to an alert source.
const gcpService = new incident.AlertAttribute("gcp_service", {
    name: "GCP service",
    type: "String",
    array: false,
});
// Staging and production each parse the same attribute out of their own source, so both
// environments' alerts are labelled with one attribute that routes can match on.
const gcpServiceStaging = new incident.AlertSourceAttribute("gcp_service_staging", {
    alertSourceId: gcpStaging.id,
    alertAttributeId: gcpService.id,
    expression: {
        startFrom: "payload",
        operations: [{
            parse: {
                "function": "$.resource.labels.service_name",
                as: "String",
            },
        }],
    },
});
const gcpServiceProduction = new incident.AlertSourceAttribute("gcp_service_production", {
    alertSourceId: gcpProduction.id,
    alertAttributeId: gcpService.id,
    expression: {
        startFrom: "payload",
        operations: [{
            parse: {
                "function": "$.resource.labels.service_name",
                as: "String",
            },
        }],
    },
});
// Where a source lives in a different workspace to the attribute it binds, read the attribute
// by name rather than declaring it again. Two workspaces declaring the same name will both plan
// cleanly, and then the second one to apply will fail.
const existingGcpService = incident.getAlertAttribute({
    name: "GCP service",
});
const gcpServiceOtherWorkspace = new incident.AlertSourceAttribute("gcp_service_other_workspace", {
    alertSourceId: gcpOther.id,
    alertAttributeId: existingGcpService.then(existingGcpService => existingGcpService.id),
    expression: {
        startFrom: "payload",
        operations: [{
            parse: {
                "function": "$.resource.labels.service_name",
                as: "String",
            },
        }],
    },
});

import pulumi
import pulumi_incident as incident

# Create an alert attribute that points at a single Github user in the catalog.
#
# Take the engine type from the catalog type itself rather than writing it out: a type one
# of our integrations owns is referenced by its registry name, and a type you manage by its
# ID, so the two don't have the same shape.
github_user = incident.get_catalog_type(type_name="GithubUser")
github_user_alert_attribute = incident.AlertAttribute("github_user",
    name="Github user",
    type=github_user.attribute_type,
    array=False,
    required=True)
# Create an optional alert attribute for severity information
severity = incident.AlertAttribute("severity",
    name="Severity",
    type="String",
    array=False,
    required=False,
    emoji="warning")
# An attribute is account-wide, so declare it once. What differs between environments is the
# binding that fills it in, which belongs to an alert source.
gcp_service = incident.AlertAttribute("gcp_service",
    name="GCP service",
    type="String",
    array=False)
# Staging and production each parse the same attribute out of their own source, so both
# environments' alerts are labelled with one attribute that routes can match on.
gcp_service_staging = incident.AlertSourceAttribute("gcp_service_staging",
    alert_source_id=gcp_staging["id"],
    alert_attribute_id=gcp_service.id,
    expression={
        "start_from": "payload",
        "operations": [{
            "parse": {
                "function": "$.resource.labels.service_name",
                "as_": "String",
            },
        }],
    })
gcp_service_production = incident.AlertSourceAttribute("gcp_service_production",
    alert_source_id=gcp_production["id"],
    alert_attribute_id=gcp_service.id,
    expression={
        "start_from": "payload",
        "operations": [{
            "parse": {
                "function": "$.resource.labels.service_name",
                "as_": "String",
            },
        }],
    })
# Where a source lives in a different workspace to the attribute it binds, read the attribute
# by name rather than declaring it again. Two workspaces declaring the same name will both plan
# cleanly, and then the second one to apply will fail.
existing_gcp_service = incident.get_alert_attribute(name="GCP service")
gcp_service_other_workspace = incident.AlertSourceAttribute("gcp_service_other_workspace",
    alert_source_id=gcp_other["id"],
    alert_attribute_id=existing_gcp_service.id,
    expression={
        "start_from": "payload",
        "operations": [{
            "parse": {
                "function": "$.resource.labels.service_name",
                "as_": "String",
            },
        }],
    })

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 {
		// Create an alert attribute that points at a single Github user in the catalog.
		//
		// Take the engine type from the catalog type itself rather than writing it out: a type one
		// of our integrations owns is referenced by its registry name, and a type you manage by its
		// ID, so the two don't have the same shape.
		githubUser, err := incident.LookupCatalogType(ctx, &incident.LookupCatalogTypeArgs{
			TypeName: pulumi.StringRef("GithubUser"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = incident.NewAlertAttribute(ctx, "github_user", &incident.AlertAttributeArgs{
			Name:     pulumi.String("Github user"),
			Type:     pulumi.String(githubUser.AttributeType),
			Array:    pulumi.Bool(false),
			Required: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		// Create an optional alert attribute for severity information
		_, err = incident.NewAlertAttribute(ctx, "severity", &incident.AlertAttributeArgs{
			Name:     pulumi.String("Severity"),
			Type:     pulumi.String("String"),
			Array:    pulumi.Bool(false),
			Required: pulumi.Bool(false),
			Emoji:    pulumi.String("warning"),
		})
		if err != nil {
			return err
		}
		// An attribute is account-wide, so declare it once. What differs between environments is the
		// binding that fills it in, which belongs to an alert source.
		gcpService, err := incident.NewAlertAttribute(ctx, "gcp_service", &incident.AlertAttributeArgs{
			Name:  pulumi.String("GCP service"),
			Type:  pulumi.String("String"),
			Array: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		// Staging and production each parse the same attribute out of their own source, so both
		// environments' alerts are labelled with one attribute that routes can match on.
		_, err = incident.NewAlertSourceAttribute(ctx, "gcp_service_staging", &incident.AlertSourceAttributeArgs{
			AlertSourceId:    pulumi.Any(gcpStaging.Id),
			AlertAttributeId: gcpService.ID(),
			Expression: &incident.AlertSourceAttributeExpressionArgs{
				StartFrom: pulumi.String("payload"),
				Operations: incident.AlertSourceAttributeExpressionOperationArray{
					&incident.AlertSourceAttributeExpressionOperationArgs{
						Parse: &incident.AlertSourceAttributeExpressionOperationParseArgs{
							Function: pulumi.String("$.resource.labels.service_name"),
							As:       pulumi.String("String"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = incident.NewAlertSourceAttribute(ctx, "gcp_service_production", &incident.AlertSourceAttributeArgs{
			AlertSourceId:    pulumi.Any(gcpProduction.Id),
			AlertAttributeId: gcpService.ID(),
			Expression: &incident.AlertSourceAttributeExpressionArgs{
				StartFrom: pulumi.String("payload"),
				Operations: incident.AlertSourceAttributeExpressionOperationArray{
					&incident.AlertSourceAttributeExpressionOperationArgs{
						Parse: &incident.AlertSourceAttributeExpressionOperationParseArgs{
							Function: pulumi.String("$.resource.labels.service_name"),
							As:       pulumi.String("String"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// Where a source lives in a different workspace to the attribute it binds, read the attribute
		// by name rather than declaring it again. Two workspaces declaring the same name will both plan
		// cleanly, and then the second one to apply will fail.
		existingGcpService, err := incident.LookupAlertAttribute(ctx, &incident.LookupAlertAttributeArgs{
			Name: "GCP service",
		}, nil)
		if err != nil {
			return err
		}
		_, err = incident.NewAlertSourceAttribute(ctx, "gcp_service_other_workspace", &incident.AlertSourceAttributeArgs{
			AlertSourceId:    pulumi.Any(gcpOther.Id),
			AlertAttributeId: pulumi.String(existingGcpService.Id),
			Expression: &incident.AlertSourceAttributeExpressionArgs{
				StartFrom: pulumi.String("payload"),
				Operations: incident.AlertSourceAttributeExpressionOperationArray{
					&incident.AlertSourceAttributeExpressionOperationArgs{
						Parse: &incident.AlertSourceAttributeExpressionOperationParseArgs{
							Function: pulumi.String("$.resource.labels.service_name"),
							As:       pulumi.String("String"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Create an alert attribute that points at a single Github user in the catalog.
    //
    // Take the engine type from the catalog type itself rather than writing it out: a type one
    // of our integrations owns is referenced by its registry name, and a type you manage by its
    // ID, so the two don't have the same shape.
    var githubUser = Incident.GetCatalogType.Invoke(new()
    {
        TypeName = "GithubUser",
    });

    var githubUserAlertAttribute = new Incident.AlertAttribute("github_user", new()
    {
        Name = "Github user",
        Type = githubUser.Apply(getCatalogTypeResult => getCatalogTypeResult.AttributeType),
        Array = false,
        Required = true,
    });

    // Create an optional alert attribute for severity information
    var severity = new Incident.AlertAttribute("severity", new()
    {
        Name = "Severity",
        Type = "String",
        Array = false,
        Required = false,
        Emoji = "warning",
    });

    // An attribute is account-wide, so declare it once. What differs between environments is the
    // binding that fills it in, which belongs to an alert source.
    var gcpService = new Incident.AlertAttribute("gcp_service", new()
    {
        Name = "GCP service",
        Type = "String",
        Array = false,
    });

    // Staging and production each parse the same attribute out of their own source, so both
    // environments' alerts are labelled with one attribute that routes can match on.
    var gcpServiceStaging = new Incident.AlertSourceAttribute("gcp_service_staging", new()
    {
        AlertSourceId = gcpStaging.Id,
        AlertAttributeId = gcpService.Id,
        Expression = new Incident.Inputs.AlertSourceAttributeExpressionArgs
        {
            StartFrom = "payload",
            Operations = new[]
            {
                new Incident.Inputs.AlertSourceAttributeExpressionOperationArgs
                {
                    Parse = new Incident.Inputs.AlertSourceAttributeExpressionOperationParseArgs
                    {
                        Function = "$.resource.labels.service_name",
                        As = "String",
                    },
                },
            },
        },
    });

    var gcpServiceProduction = new Incident.AlertSourceAttribute("gcp_service_production", new()
    {
        AlertSourceId = gcpProduction.Id,
        AlertAttributeId = gcpService.Id,
        Expression = new Incident.Inputs.AlertSourceAttributeExpressionArgs
        {
            StartFrom = "payload",
            Operations = new[]
            {
                new Incident.Inputs.AlertSourceAttributeExpressionOperationArgs
                {
                    Parse = new Incident.Inputs.AlertSourceAttributeExpressionOperationParseArgs
                    {
                        Function = "$.resource.labels.service_name",
                        As = "String",
                    },
                },
            },
        },
    });

    // Where a source lives in a different workspace to the attribute it binds, read the attribute
    // by name rather than declaring it again. Two workspaces declaring the same name will both plan
    // cleanly, and then the second one to apply will fail.
    var existingGcpService = Incident.GetAlertAttribute.Invoke(new()
    {
        Name = "GCP service",
    });

    var gcpServiceOtherWorkspace = new Incident.AlertSourceAttribute("gcp_service_other_workspace", new()
    {
        AlertSourceId = gcpOther.Id,
        AlertAttributeId = existingGcpService.Apply(getAlertAttributeResult => getAlertAttributeResult.Id),
        Expression = new Incident.Inputs.AlertSourceAttributeExpressionArgs
        {
            StartFrom = "payload",
            Operations = new[]
            {
                new Incident.Inputs.AlertSourceAttributeExpressionOperationArgs
                {
                    Parse = new Incident.Inputs.AlertSourceAttributeExpressionOperationParseArgs
                    {
                        Function = "$.resource.labels.service_name",
                        As = "String",
                    },
                },
            },
        },
    });

});

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.AlertAttribute;
import com.pulumi.incident.AlertAttributeArgs;
import com.pulumi.incident.AlertSourceAttribute;
import com.pulumi.incident.AlertSourceAttributeArgs;
import com.pulumi.incident.inputs.AlertSourceAttributeExpressionArgs;
import com.pulumi.incident.inputs.GetAlertAttributeArgs;
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) {
        // Create an alert attribute that points at a single Github user in the catalog.
        //
        // Take the engine type from the catalog type itself rather than writing it out: a type one
        // of our integrations owns is referenced by its registry name, and a type you manage by its
        // ID, so the two don't have the same shape.
        final var githubUser = IncidentFunctions.getCatalogType(GetCatalogTypeArgs.builder()
            .typeName("GithubUser")
            .build());

        var githubUserAlertAttribute = new AlertAttribute("githubUserAlertAttribute", AlertAttributeArgs.builder()
            .name("Github user")
            .type(githubUser.attributeType())
            .array(false)
            .required(true)
            .build());

        // Create an optional alert attribute for severity information
        var severity = new AlertAttribute("severity", AlertAttributeArgs.builder()
            .name("Severity")
            .type("String")
            .array(false)
            .required(false)
            .emoji("warning")
            .build());

        // An attribute is account-wide, so declare it once. What differs between environments is the
        // binding that fills it in, which belongs to an alert source.
        var gcpService = new AlertAttribute("gcpService", AlertAttributeArgs.builder()
            .name("GCP service")
            .type("String")
            .array(false)
            .build());

        // Staging and production each parse the same attribute out of their own source, so both
        // environments' alerts are labelled with one attribute that routes can match on.
        var gcpServiceStaging = new AlertSourceAttribute("gcpServiceStaging", AlertSourceAttributeArgs.builder()
            .alertSourceId(gcpStaging.id())
            .alertAttributeId(gcpService.id())
            .expression(AlertSourceAttributeExpressionArgs.builder()
                .startFrom("payload")
                .operations(AlertSourceAttributeExpressionOperationArgs.builder()
                    .parse(AlertSourceAttributeExpressionOperationParseArgs.builder()
                        .function("$.resource.labels.service_name")
                        .as("String")
                        .build())
                    .build())
                .build())
            .build());

        var gcpServiceProduction = new AlertSourceAttribute("gcpServiceProduction", AlertSourceAttributeArgs.builder()
            .alertSourceId(gcpProduction.id())
            .alertAttributeId(gcpService.id())
            .expression(AlertSourceAttributeExpressionArgs.builder()
                .startFrom("payload")
                .operations(AlertSourceAttributeExpressionOperationArgs.builder()
                    .parse(AlertSourceAttributeExpressionOperationParseArgs.builder()
                        .function("$.resource.labels.service_name")
                        .as("String")
                        .build())
                    .build())
                .build())
            .build());

        // Where a source lives in a different workspace to the attribute it binds, read the attribute
        // by name rather than declaring it again. Two workspaces declaring the same name will both plan
        // cleanly, and then the second one to apply will fail.
        final var existingGcpService = IncidentFunctions.getAlertAttribute(GetAlertAttributeArgs.builder()
            .name("GCP service")
            .build());

        var gcpServiceOtherWorkspace = new AlertSourceAttribute("gcpServiceOtherWorkspace", AlertSourceAttributeArgs.builder()
            .alertSourceId(gcpOther.id())
            .alertAttributeId(existingGcpService.id())
            .expression(AlertSourceAttributeExpressionArgs.builder()
                .startFrom("payload")
                .operations(AlertSourceAttributeExpressionOperationArgs.builder()
                    .parse(AlertSourceAttributeExpressionOperationParseArgs.builder()
                        .function("$.resource.labels.service_name")
                        .as("String")
                        .build())
                    .build())
                .build())
            .build());

    }
}

resources:
  githubUserAlertAttribute:
    type: incident:AlertAttribute
    name: github_user
    properties:
      name: Github user
      type: ${githubUser.attributeType}
      array: false
      required: true
  # Create an optional alert attribute for severity information
  severity:
    type: incident:AlertAttribute
    properties:
      name: Severity
      type: String
      array: false
      required: false
      emoji: warning
  # An attribute is account-wide, so declare it once. What differs between environments is the
  # binding that fills it in, which belongs to an alert source.
  gcpService:
    type: incident:AlertAttribute
    name: gcp_service
    properties:
      name: GCP service
      type: String
      array: false
  # Staging and production each parse the same attribute out of their own source, so both
  # environments' alerts are labelled with one attribute that routes can match on.
  gcpServiceStaging:
    type: incident:AlertSourceAttribute
    name: gcp_service_staging
    properties:
      alertSourceId: ${gcpStaging.id}
      alertAttributeId: ${gcpService.id}
      expression:
        startFrom: payload
        operations:
          - parse:
              function: $.resource.labels.service_name
              as: String
  gcpServiceProduction:
    type: incident:AlertSourceAttribute
    name: gcp_service_production
    properties:
      alertSourceId: ${gcpProduction.id}
      alertAttributeId: ${gcpService.id}
      expression:
        startFrom: payload
        operations:
          - parse:
              function: $.resource.labels.service_name
              as: String
  gcpServiceOtherWorkspace:
    type: incident:AlertSourceAttribute
    name: gcp_service_other_workspace
    properties:
      alertSourceId: ${gcpOther.id}
      alertAttributeId: ${existingGcpService.id}
      expression:
        startFrom: payload
        operations:
          - parse:
              function: $.resource.labels.service_name
              as: String
variables:
  # Create an alert attribute that points at a single Github user in the catalog.
  #
  # Take the engine type from the catalog type itself rather than writing it out: a type one
  # of our integrations owns is referenced by its registry name, and a type you manage by its
  # ID, so the two don't have the same shape.
  githubUser:
    fn::invoke:
      function: incident:getCatalogType
      arguments:
        typeName: GithubUser
  # Where a source lives in a different workspace to the attribute it binds, read the attribute
  # by name rather than declaring it again. Two workspaces declaring the same name will both plan
  # cleanly, and then the second one to apply will fail.
  existingGcpService:
    fn::invoke:
      function: incident:getAlertAttribute
      arguments:
        name: GCP service

var alertAttributeResource = new Incident.AlertAttribute("alertAttributeResource", new()
{
    Array = false,
    Type = "string",
    Emoji = "string",
    Name = "string",
    Required = false,
});

example, err := incident.NewAlertAttribute(ctx, "alertAttributeResource", &incident.AlertAttributeArgs{
	Array:    pulumi.Bool(false),
	Type:     pulumi.String("string"),
	Emoji:    pulumi.String("string"),
	Name:     pulumi.String("string"),
	Required: pulumi.Bool(false),
})

resource "incident_alert_attribute" "alertAttributeResource" {
  lifecycle {
    create_before_destroy = true
  }
  array    = false
  type     = "string"
  emoji    = "string"
  name     = "string"
  required = false
}

var alertAttributeResource = new AlertAttribute("alertAttributeResource", AlertAttributeArgs.builder()
    .array(false)
    .type("string")
    .emoji("string")
    .name("string")
    .required(false)
    .build());

alert_attribute_resource = incident.AlertAttribute("alertAttributeResource",
    array=False,
    type="string",
    emoji="string",
    name="string",
    required=False)

const alertAttributeResource = new incident.AlertAttribute("alertAttributeResource", {
    array: false,
    type: "string",
    emoji: "string",
    name: "string",
    required: false,
});

type: incident:AlertAttribute
properties:
    array: false
    emoji: string
    name: string
    required: false
    type: string