pagerduty.EventOrchestrationService

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

const engineering = new pagerduty.Team("engineering", {name: "Engineering"});
const example = new pagerduty.User("example", {
    name: "Earline Greenholt",
    email: "125.greenholt.earline@graham.name",
});
const foo = new pagerduty.TeamMembership("foo", {
    userId: example.id,
    teamId: engineering.id,
    role: "manager",
});
const exampleEscalationPolicy = new pagerduty.EscalationPolicy("example", {
    name: "Engineering Escalation Policy",
    numLoops: 2,
    rules: [{
        escalationDelayInMinutes: 10,
        targets: [{
            type: "user_reference",
            id: example.id,
        }],
    }],
});
const exampleService = new pagerduty.Service("example", {
    name: "My Web App",
    autoResolveTimeout: "14400",
    acknowledgementTimeout: "600",
    escalationPolicy: exampleEscalationPolicy.id,
    alertCreation: "create_alerts_and_incidents",
});
const csImpact = new pagerduty.IncidentCustomField("cs_impact", {
    name: "impact",
    dataType: "string",
    fieldType: "single_value",
});
const p1 = pagerduty.getPriority({
    name: "P1",
});
const sreEscPolicy = pagerduty.getEscalationPolicy({
    name: "SRE Escalation Policy",
});
const www = new pagerduty.EventOrchestrationService("www", {
    service: exampleService.id,
    enableEventOrchestrationForService: true,
    sets: [
        {
            id: "start",
            rules: [{
                label: "Always apply some consistent event transformations to all events",
                actions: {
                    variables: [{
                        name: "hostname",
                        path: "event.component",
                        value: "hostname: (.*)",
                        type: "regex",
                    }],
                    extractions: [
                        {
                            template: "{{variables.hostname}}",
                            target: "event.custom_details.hostname",
                        },
                        {
                            source: "event.source",
                            regex: "www (.*) service",
                            target: "event.source",
                        },
                    ],
                    routeTo: "step-two",
                },
            }],
        },
        {
            id: "step-two",
            rules: [
                {
                    label: "All critical alerts should be treated as P1 incident",
                    conditions: [{
                        expression: "event.severity matches 'critical'",
                    }],
                    actions: {
                        annotate: "Please use our P1 runbook: https://docs.test/p1-runbook",
                        priority: p1.then(p1 => p1.id),
                        incidentCustomFieldUpdates: [{
                            id: csImpact.id,
                            value: "High Impact",
                        }],
                    },
                },
                {
                    label: "If any of the API apps are unavailable, page the SRE team",
                    conditions: [{
                        expression: "event.custom_details.service_name matches part '-api' and event.custom_details.status_code matches '502'",
                    }],
                    actions: {
                        escalationPolicy: sreEscPolicy.then(sreEscPolicy => sreEscPolicy.id),
                    },
                },
                {
                    label: "If there's something wrong on the canary let the team know about it in our deployments Slack channel",
                    conditions: [{
                        expression: "event.custom_details.hostname matches part 'canary'",
                    }],
                    actions: {
                        automationAction: {
                            name: "Canary Slack Notification",
                            url: "https://our-slack-listerner.test/canary-notification",
                            autoSend: true,
                            triggerTypes: "alert_triggered",
                            parameters: [
                                {
                                    key: "channel",
                                    value: "#my-team-channel",
                                },
                                {
                                    key: "message",
                                    value: "something is wrong with the canary deployment",
                                },
                            ],
                            headers: [{
                                key: "X-Notification-Source",
                                value: "PagerDuty Incident Webhook",
                            }],
                        },
                    },
                },
                {
                    label: "Never bother the on-call for info-level events outside of work hours, and let an Automation Action fix it instead",
                    conditions: [{
                        expression: "event.severity matches 'info' and not (now in Mon,Tue,Wed,Thu,Fri 09:00:00 to 17:00:00 America/Los_Angeles)",
                    }],
                    actions: {
                        suppress: true,
                        pagerdutyAutomationAction: {
                            actionId: "01FJV5A8OA5MKHOYFHV35SM2Z0",
                            triggerTypes: "alert_suppressed",
                        },
                    },
                },
            ],
        },
    ],
    catchAll: {
        actions: {},
    },
});

import pulumi
import pulumi_pagerduty as pagerduty

engineering = pagerduty.Team("engineering", name="Engineering")
example = pagerduty.User("example",
    name="Earline Greenholt",
    email="125.greenholt.earline@graham.name")
foo = pagerduty.TeamMembership("foo",
    user_id=example.id,
    team_id=engineering.id,
    role="manager")
example_escalation_policy = pagerduty.EscalationPolicy("example",
    name="Engineering Escalation Policy",
    num_loops=2,
    rules=[{
        "escalation_delay_in_minutes": 10,
        "targets": [{
            "type": "user_reference",
            "id": example.id,
        }],
    }])
example_service = pagerduty.Service("example",
    name="My Web App",
    auto_resolve_timeout="14400",
    acknowledgement_timeout="600",
    escalation_policy=example_escalation_policy.id,
    alert_creation="create_alerts_and_incidents")
cs_impact = pagerduty.IncidentCustomField("cs_impact",
    name="impact",
    data_type="string",
    field_type="single_value")
p1 = pagerduty.get_priority(name="P1")
sre_esc_policy = pagerduty.get_escalation_policy(name="SRE Escalation Policy")
www = pagerduty.EventOrchestrationService("www",
    service=example_service.id,
    enable_event_orchestration_for_service=True,
    sets=[
        {
            "id": "start",
            "rules": [{
                "label": "Always apply some consistent event transformations to all events",
                "actions": {
                    "variables": [{
                        "name": "hostname",
                        "path": "event.component",
                        "value": "hostname: (.*)",
                        "type": "regex",
                    }],
                    "extractions": [
                        {
                            "template": "{{variables.hostname}}",
                            "target": "event.custom_details.hostname",
                        },
                        {
                            "source": "event.source",
                            "regex": "www (.*) service",
                            "target": "event.source",
                        },
                    ],
                    "route_to": "step-two",
                },
            }],
        },
        {
            "id": "step-two",
            "rules": [
                {
                    "label": "All critical alerts should be treated as P1 incident",
                    "conditions": [{
                        "expression": "event.severity matches 'critical'",
                    }],
                    "actions": {
                        "annotate": "Please use our P1 runbook: https://docs.test/p1-runbook",
                        "priority": p1.id,
                        "incident_custom_field_updates": [{
                            "id": cs_impact.id,
                            "value": "High Impact",
                        }],
                    },
                },
                {
                    "label": "If any of the API apps are unavailable, page the SRE team",
                    "conditions": [{
                        "expression": "event.custom_details.service_name matches part '-api' and event.custom_details.status_code matches '502'",
                    }],
                    "actions": {
                        "escalation_policy": sre_esc_policy.id,
                    },
                },
                {
                    "label": "If there's something wrong on the canary let the team know about it in our deployments Slack channel",
                    "conditions": [{
                        "expression": "event.custom_details.hostname matches part 'canary'",
                    }],
                    "actions": {
                        "automation_action": {
                            "name": "Canary Slack Notification",
                            "url": "https://our-slack-listerner.test/canary-notification",
                            "auto_send": True,
                            "trigger_types": "alert_triggered",
                            "parameters": [
                                {
                                    "key": "channel",
                                    "value": "#my-team-channel",
                                },
                                {
                                    "key": "message",
                                    "value": "something is wrong with the canary deployment",
                                },
                            ],
                            "headers": [{
                                "key": "X-Notification-Source",
                                "value": "PagerDuty Incident Webhook",
                            }],
                        },
                    },
                },
                {
                    "label": "Never bother the on-call for info-level events outside of work hours, and let an Automation Action fix it instead",
                    "conditions": [{
                        "expression": "event.severity matches 'info' and not (now in Mon,Tue,Wed,Thu,Fri 09:00:00 to 17:00:00 America/Los_Angeles)",
                    }],
                    "actions": {
                        "suppress": True,
                        "pagerduty_automation_action": {
                            "action_id": "01FJV5A8OA5MKHOYFHV35SM2Z0",
                            "trigger_types": "alert_suppressed",
                        },
                    },
                },
            ],
        },
    ],
    catch_all={
        "actions": {},
    })

package main

import (
	"github.com/pulumi/pulumi-pagerduty/sdk/v4/go/pagerduty"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		engineering, err := pagerduty.NewTeam(ctx, "engineering", &pagerduty.TeamArgs{
			Name: pulumi.String("Engineering"),
		})
		if err != nil {
			return err
		}
		example, err := pagerduty.NewUser(ctx, "example", &pagerduty.UserArgs{
			Name:  pulumi.String("Earline Greenholt"),
			Email: pulumi.String("125.greenholt.earline@graham.name"),
		})
		if err != nil {
			return err
		}
		_, err = pagerduty.NewTeamMembership(ctx, "foo", &pagerduty.TeamMembershipArgs{
			UserId: example.ID(),
			TeamId: engineering.ID(),
			Role:   pulumi.String("manager"),
		})
		if err != nil {
			return err
		}
		exampleEscalationPolicy, err := pagerduty.NewEscalationPolicy(ctx, "example", &pagerduty.EscalationPolicyArgs{
			Name:     pulumi.String("Engineering Escalation Policy"),
			NumLoops: pulumi.Int(2),
			Rules: pagerduty.EscalationPolicyRuleArray{
				&pagerduty.EscalationPolicyRuleArgs{
					EscalationDelayInMinutes: pulumi.Int(10),
					Targets: pagerduty.EscalationPolicyRuleTargetArray{
						&pagerduty.EscalationPolicyRuleTargetArgs{
							Type: pulumi.String("user_reference"),
							Id:   example.ID(),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		exampleService, err := pagerduty.NewService(ctx, "example", &pagerduty.ServiceArgs{
			Name:                   pulumi.String("My Web App"),
			AutoResolveTimeout:     pulumi.String("14400"),
			AcknowledgementTimeout: pulumi.String("600"),
			EscalationPolicy:       exampleEscalationPolicy.ID(),
			AlertCreation:          pulumi.String("create_alerts_and_incidents"),
		})
		if err != nil {
			return err
		}
		csImpact, err := pagerduty.NewIncidentCustomField(ctx, "cs_impact", &pagerduty.IncidentCustomFieldArgs{
			Name:      pulumi.String("impact"),
			DataType:  pulumi.String("string"),
			FieldType: pulumi.String("single_value"),
		})
		if err != nil {
			return err
		}
		p1, err := pagerduty.GetPriority(ctx, &pagerduty.GetPriorityArgs{
			Name: "P1",
		}, nil)
		if err != nil {
			return err
		}
		sreEscPolicy, err := pagerduty.LookupEscalationPolicy(ctx, &pagerduty.LookupEscalationPolicyArgs{
			Name: "SRE Escalation Policy",
		}, nil)
		if err != nil {
			return err
		}
		_, err = pagerduty.NewEventOrchestrationService(ctx, "www", &pagerduty.EventOrchestrationServiceArgs{
			Service:                            exampleService.ID(),
			EnableEventOrchestrationForService: pulumi.Bool(true),
			Sets: pagerduty.EventOrchestrationServiceSetArray{
				&pagerduty.EventOrchestrationServiceSetArgs{
					Id: pulumi.String("start"),
					Rules: pagerduty.EventOrchestrationServiceSetRuleArray{
						&pagerduty.EventOrchestrationServiceSetRuleArgs{
							Label: pulumi.String("Always apply some consistent event transformations to all events"),
							Actions: &pagerduty.EventOrchestrationServiceSetRuleActionsArgs{
								Variables: pagerduty.EventOrchestrationServiceSetRuleActionsVariableArray{
									&pagerduty.EventOrchestrationServiceSetRuleActionsVariableArgs{
										Name:  pulumi.String("hostname"),
										Path:  pulumi.String("event.component"),
										Value: pulumi.String("hostname: (.*)"),
										Type:  pulumi.String("regex"),
									},
								},
								Extractions: pagerduty.EventOrchestrationServiceSetRuleActionsExtractionArray{
									&pagerduty.EventOrchestrationServiceSetRuleActionsExtractionArgs{
										Template: pulumi.String("{{variables.hostname}}"),
										Target:   pulumi.String("event.custom_details.hostname"),
									},
									&pagerduty.EventOrchestrationServiceSetRuleActionsExtractionArgs{
										Source: pulumi.String("event.source"),
										Regex:  pulumi.String("www (.*) service"),
										Target: pulumi.String("event.source"),
									},
								},
								RouteTo: pulumi.String("step-two"),
							},
						},
					},
				},
				&pagerduty.EventOrchestrationServiceSetArgs{
					Id: pulumi.String("step-two"),
					Rules: pagerduty.EventOrchestrationServiceSetRuleArray{
						&pagerduty.EventOrchestrationServiceSetRuleArgs{
							Label: pulumi.String("All critical alerts should be treated as P1 incident"),
							Conditions: pagerduty.EventOrchestrationServiceSetRuleConditionArray{
								&pagerduty.EventOrchestrationServiceSetRuleConditionArgs{
									Expression: pulumi.String("event.severity matches 'critical'"),
								},
							},
							Actions: &pagerduty.EventOrchestrationServiceSetRuleActionsArgs{
								Annotate: pulumi.String("Please use our P1 runbook: https://docs.test/p1-runbook"),
								Priority: pulumi.String(p1.Id),
								IncidentCustomFieldUpdates: pagerduty.EventOrchestrationServiceSetRuleActionsIncidentCustomFieldUpdateArray{
									&pagerduty.EventOrchestrationServiceSetRuleActionsIncidentCustomFieldUpdateArgs{
										Id:    csImpact.ID(),
										Value: pulumi.String("High Impact"),
									},
								},
							},
						},
						&pagerduty.EventOrchestrationServiceSetRuleArgs{
							Label: pulumi.String("If any of the API apps are unavailable, page the SRE team"),
							Conditions: pagerduty.EventOrchestrationServiceSetRuleConditionArray{
								&pagerduty.EventOrchestrationServiceSetRuleConditionArgs{
									Expression: pulumi.String("event.custom_details.service_name matches part '-api' and event.custom_details.status_code matches '502'"),
								},
							},
							Actions: &pagerduty.EventOrchestrationServiceSetRuleActionsArgs{
								EscalationPolicy: pulumi.String(sreEscPolicy.Id),
							},
						},
						&pagerduty.EventOrchestrationServiceSetRuleArgs{
							Label: pulumi.String("If there's something wrong on the canary let the team know about it in our deployments Slack channel"),
							Conditions: pagerduty.EventOrchestrationServiceSetRuleConditionArray{
								&pagerduty.EventOrchestrationServiceSetRuleConditionArgs{
									Expression: pulumi.String("event.custom_details.hostname matches part 'canary'"),
								},
							},
							Actions: &pagerduty.EventOrchestrationServiceSetRuleActionsArgs{
								AutomationAction: &pagerduty.EventOrchestrationServiceSetRuleActionsAutomationActionArgs{
									Name:         pulumi.String("Canary Slack Notification"),
									Url:          pulumi.String("https://our-slack-listerner.test/canary-notification"),
									AutoSend:     pulumi.Bool(true),
									TriggerTypes: pulumi.String("alert_triggered"),
									Parameters: pagerduty.EventOrchestrationServiceSetRuleActionsAutomationActionParameterArray{
										&pagerduty.EventOrchestrationServiceSetRuleActionsAutomationActionParameterArgs{
											Key:   pulumi.String("channel"),
											Value: pulumi.String("#my-team-channel"),
										},
										&pagerduty.EventOrchestrationServiceSetRuleActionsAutomationActionParameterArgs{
											Key:   pulumi.String("message"),
											Value: pulumi.String("something is wrong with the canary deployment"),
										},
									},
									Headers: pagerduty.EventOrchestrationServiceSetRuleActionsAutomationActionHeaderArray{
										&pagerduty.EventOrchestrationServiceSetRuleActionsAutomationActionHeaderArgs{
											Key:   pulumi.String("X-Notification-Source"),
											Value: pulumi.String("PagerDuty Incident Webhook"),
										},
									},
								},
							},
						},
						&pagerduty.EventOrchestrationServiceSetRuleArgs{
							Label: pulumi.String("Never bother the on-call for info-level events outside of work hours, and let an Automation Action fix it instead"),
							Conditions: pagerduty.EventOrchestrationServiceSetRuleConditionArray{
								&pagerduty.EventOrchestrationServiceSetRuleConditionArgs{
									Expression: pulumi.String("event.severity matches 'info' and not (now in Mon,Tue,Wed,Thu,Fri 09:00:00 to 17:00:00 America/Los_Angeles)"),
								},
							},
							Actions: &pagerduty.EventOrchestrationServiceSetRuleActionsArgs{
								Suppress: pulumi.Bool(true),
								PagerdutyAutomationAction: &pagerduty.EventOrchestrationServiceSetRuleActionsPagerdutyAutomationActionArgs{
									ActionId:     pulumi.String("01FJV5A8OA5MKHOYFHV35SM2Z0"),
									TriggerTypes: pulumi.String("alert_suppressed"),
								},
							},
						},
					},
				},
			},
			CatchAll: &pagerduty.EventOrchestrationServiceCatchAllArgs{
				Actions: &pagerduty.EventOrchestrationServiceCatchAllActionsArgs{},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var engineering = new Pagerduty.Team("engineering", new()
    {
        Name = "Engineering",
    });

    var example = new Pagerduty.User("example", new()
    {
        Name = "Earline Greenholt",
        Email = "125.greenholt.earline@graham.name",
    });

    var foo = new Pagerduty.TeamMembership("foo", new()
    {
        UserId = example.Id,
        TeamId = engineering.Id,
        Role = "manager",
    });

    var exampleEscalationPolicy = new Pagerduty.EscalationPolicy("example", new()
    {
        Name = "Engineering Escalation Policy",
        NumLoops = 2,
        Rules = new[]
        {
            new Pagerduty.Inputs.EscalationPolicyRuleArgs
            {
                EscalationDelayInMinutes = 10,
                Targets = new[]
                {
                    new Pagerduty.Inputs.EscalationPolicyRuleTargetArgs
                    {
                        Type = "user_reference",
                        Id = example.Id,
                    },
                },
            },
        },
    });

    var exampleService = new Pagerduty.Service("example", new()
    {
        Name = "My Web App",
        AutoResolveTimeout = "14400",
        AcknowledgementTimeout = "600",
        EscalationPolicy = exampleEscalationPolicy.Id,
        AlertCreation = "create_alerts_and_incidents",
    });

    var csImpact = new Pagerduty.IncidentCustomField("cs_impact", new()
    {
        Name = "impact",
        DataType = "string",
        FieldType = "single_value",
    });

    var p1 = Pagerduty.GetPriority.Invoke(new()
    {
        Name = "P1",
    });

    var sreEscPolicy = Pagerduty.GetEscalationPolicy.Invoke(new()
    {
        Name = "SRE Escalation Policy",
    });

    var www = new Pagerduty.EventOrchestrationService("www", new()
    {
        Service = exampleService.Id,
        EnableEventOrchestrationForService = true,
        Sets = new[]
        {
            new Pagerduty.Inputs.EventOrchestrationServiceSetArgs
            {
                Id = "start",
                Rules = new[]
                {
                    new Pagerduty.Inputs.EventOrchestrationServiceSetRuleArgs
                    {
                        Label = "Always apply some consistent event transformations to all events",
                        Actions = new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsArgs
                        {
                            Variables = new[]
                            {
                                new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsVariableArgs
                                {
                                    Name = "hostname",
                                    Path = "event.component",
                                    Value = "hostname: (.*)",
                                    Type = "regex",
                                },
                            },
                            Extractions = new[]
                            {
                                new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsExtractionArgs
                                {
                                    Template = "{{variables.hostname}}",
                                    Target = "event.custom_details.hostname",
                                },
                                new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsExtractionArgs
                                {
                                    Source = "event.source",
                                    Regex = "www (.*) service",
                                    Target = "event.source",
                                },
                            },
                            RouteTo = "step-two",
                        },
                    },
                },
            },
            new Pagerduty.Inputs.EventOrchestrationServiceSetArgs
            {
                Id = "step-two",
                Rules = new[]
                {
                    new Pagerduty.Inputs.EventOrchestrationServiceSetRuleArgs
                    {
                        Label = "All critical alerts should be treated as P1 incident",
                        Conditions = new[]
                        {
                            new Pagerduty.Inputs.EventOrchestrationServiceSetRuleConditionArgs
                            {
                                Expression = "event.severity matches 'critical'",
                            },
                        },
                        Actions = new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsArgs
                        {
                            Annotate = "Please use our P1 runbook: https://docs.test/p1-runbook",
                            Priority = p1.Apply(getPriorityResult => getPriorityResult.Id),
                            IncidentCustomFieldUpdates = new[]
                            {
                                new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsIncidentCustomFieldUpdateArgs
                                {
                                    Id = csImpact.Id,
                                    Value = "High Impact",
                                },
                            },
                        },
                    },
                    new Pagerduty.Inputs.EventOrchestrationServiceSetRuleArgs
                    {
                        Label = "If any of the API apps are unavailable, page the SRE team",
                        Conditions = new[]
                        {
                            new Pagerduty.Inputs.EventOrchestrationServiceSetRuleConditionArgs
                            {
                                Expression = "event.custom_details.service_name matches part '-api' and event.custom_details.status_code matches '502'",
                            },
                        },
                        Actions = new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsArgs
                        {
                            EscalationPolicy = sreEscPolicy.Apply(getEscalationPolicyResult => getEscalationPolicyResult.Id),
                        },
                    },
                    new Pagerduty.Inputs.EventOrchestrationServiceSetRuleArgs
                    {
                        Label = "If there's something wrong on the canary let the team know about it in our deployments Slack channel",
                        Conditions = new[]
                        {
                            new Pagerduty.Inputs.EventOrchestrationServiceSetRuleConditionArgs
                            {
                                Expression = "event.custom_details.hostname matches part 'canary'",
                            },
                        },
                        Actions = new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsArgs
                        {
                            AutomationAction = new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsAutomationActionArgs
                            {
                                Name = "Canary Slack Notification",
                                Url = "https://our-slack-listerner.test/canary-notification",
                                AutoSend = true,
                                TriggerTypes = "alert_triggered",
                                Parameters = new[]
                                {
                                    new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsAutomationActionParameterArgs
                                    {
                                        Key = "channel",
                                        Value = "#my-team-channel",
                                    },
                                    new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsAutomationActionParameterArgs
                                    {
                                        Key = "message",
                                        Value = "something is wrong with the canary deployment",
                                    },
                                },
                                Headers = new[]
                                {
                                    new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsAutomationActionHeaderArgs
                                    {
                                        Key = "X-Notification-Source",
                                        Value = "PagerDuty Incident Webhook",
                                    },
                                },
                            },
                        },
                    },
                    new Pagerduty.Inputs.EventOrchestrationServiceSetRuleArgs
                    {
                        Label = "Never bother the on-call for info-level events outside of work hours, and let an Automation Action fix it instead",
                        Conditions = new[]
                        {
                            new Pagerduty.Inputs.EventOrchestrationServiceSetRuleConditionArgs
                            {
                                Expression = "event.severity matches 'info' and not (now in Mon,Tue,Wed,Thu,Fri 09:00:00 to 17:00:00 America/Los_Angeles)",
                            },
                        },
                        Actions = new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsArgs
                        {
                            Suppress = true,
                            PagerdutyAutomationAction = new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsPagerdutyAutomationActionArgs
                            {
                                ActionId = "01FJV5A8OA5MKHOYFHV35SM2Z0",
                                TriggerTypes = "alert_suppressed",
                            },
                        },
                    },
                },
            },
        },
        CatchAll = new Pagerduty.Inputs.EventOrchestrationServiceCatchAllArgs
        {
            Actions = null,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.pagerduty.Team;
import com.pulumi.pagerduty.TeamArgs;
import com.pulumi.pagerduty.User;
import com.pulumi.pagerduty.UserArgs;
import com.pulumi.pagerduty.TeamMembership;
import com.pulumi.pagerduty.TeamMembershipArgs;
import com.pulumi.pagerduty.EscalationPolicy;
import com.pulumi.pagerduty.EscalationPolicyArgs;
import com.pulumi.pagerduty.inputs.EscalationPolicyRuleArgs;
import com.pulumi.pagerduty.Service;
import com.pulumi.pagerduty.ServiceArgs;
import com.pulumi.pagerduty.IncidentCustomField;
import com.pulumi.pagerduty.IncidentCustomFieldArgs;
import com.pulumi.pagerduty.PagerdutyFunctions;
import com.pulumi.pagerduty.inputs.GetPriorityArgs;
import com.pulumi.pagerduty.inputs.GetEscalationPolicyArgs;
import com.pulumi.pagerduty.EventOrchestrationService;
import com.pulumi.pagerduty.EventOrchestrationServiceArgs;
import com.pulumi.pagerduty.inputs.EventOrchestrationServiceSetArgs;
import com.pulumi.pagerduty.inputs.EventOrchestrationServiceCatchAllArgs;
import com.pulumi.pagerduty.inputs.EventOrchestrationServiceCatchAllActionsArgs;
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) {
        var engineering = new Team("engineering", TeamArgs.builder()
            .name("Engineering")
            .build());

        var example = new User("example", UserArgs.builder()
            .name("Earline Greenholt")
            .email("125.greenholt.earline@graham.name")
            .build());

        var foo = new TeamMembership("foo", TeamMembershipArgs.builder()
            .userId(example.id())
            .teamId(engineering.id())
            .role("manager")
            .build());

        var exampleEscalationPolicy = new EscalationPolicy("exampleEscalationPolicy", EscalationPolicyArgs.builder()
            .name("Engineering Escalation Policy")
            .numLoops(2)
            .rules(EscalationPolicyRuleArgs.builder()
                .escalationDelayInMinutes(10)
                .targets(EscalationPolicyRuleTargetArgs.builder()
                    .type("user_reference")
                    .id(example.id())
                    .build())
                .build())
            .build());

        var exampleService = new Service("exampleService", ServiceArgs.builder()
            .name("My Web App")
            .autoResolveTimeout("14400")
            .acknowledgementTimeout("600")
            .escalationPolicy(exampleEscalationPolicy.id())
            .alertCreation("create_alerts_and_incidents")
            .build());

        var csImpact = new IncidentCustomField("csImpact", IncidentCustomFieldArgs.builder()
            .name("impact")
            .dataType("string")
            .fieldType("single_value")
            .build());

        final var p1 = PagerdutyFunctions.getPriority(GetPriorityArgs.builder()
            .name("P1")
            .build());

        final var sreEscPolicy = PagerdutyFunctions.getEscalationPolicy(GetEscalationPolicyArgs.builder()
            .name("SRE Escalation Policy")
            .build());

        var www = new EventOrchestrationService("www", EventOrchestrationServiceArgs.builder()
            .service(exampleService.id())
            .enableEventOrchestrationForService(true)
            .sets(            
                EventOrchestrationServiceSetArgs.builder()
                    .id("start")
                    .rules(EventOrchestrationServiceSetRuleArgs.builder()
                        .label("Always apply some consistent event transformations to all events")
                        .actions(EventOrchestrationServiceSetRuleActionsArgs.builder()
                            .variables(EventOrchestrationServiceSetRuleActionsVariableArgs.builder()
                                .name("hostname")
                                .path("event.component")
                                .value("hostname: (.*)")
                                .type("regex")
                                .build())
                            .extractions(                            
                                EventOrchestrationServiceSetRuleActionsExtractionArgs.builder()
                                    .template("{{variables.hostname}}")
                                    .target("event.custom_details.hostname")
                                    .build(),
                                EventOrchestrationServiceSetRuleActionsExtractionArgs.builder()
                                    .source("event.source")
                                    .regex("www (.*) service")
                                    .target("event.source")
                                    .build())
                            .routeTo("step-two")
                            .build())
                        .build())
                    .build(),
                EventOrchestrationServiceSetArgs.builder()
                    .id("step-two")
                    .rules(                    
                        EventOrchestrationServiceSetRuleArgs.builder()
                            .label("All critical alerts should be treated as P1 incident")
                            .conditions(EventOrchestrationServiceSetRuleConditionArgs.builder()
                                .expression("event.severity matches 'critical'")
                                .build())
                            .actions(EventOrchestrationServiceSetRuleActionsArgs.builder()
                                .annotate("Please use our P1 runbook: https://docs.test/p1-runbook")
                                .priority(p1.id())
                                .incidentCustomFieldUpdates(EventOrchestrationServiceSetRuleActionsIncidentCustomFieldUpdateArgs.builder()
                                    .id(csImpact.id())
                                    .value("High Impact")
                                    .build())
                                .build())
                            .build(),
                        EventOrchestrationServiceSetRuleArgs.builder()
                            .label("If any of the API apps are unavailable, page the SRE team")
                            .conditions(EventOrchestrationServiceSetRuleConditionArgs.builder()
                                .expression("event.custom_details.service_name matches part '-api' and event.custom_details.status_code matches '502'")
                                .build())
                            .actions(EventOrchestrationServiceSetRuleActionsArgs.builder()
                                .escalationPolicy(sreEscPolicy.id())
                                .build())
                            .build(),
                        EventOrchestrationServiceSetRuleArgs.builder()
                            .label("If there's something wrong on the canary let the team know about it in our deployments Slack channel")
                            .conditions(EventOrchestrationServiceSetRuleConditionArgs.builder()
                                .expression("event.custom_details.hostname matches part 'canary'")
                                .build())
                            .actions(EventOrchestrationServiceSetRuleActionsArgs.builder()
                                .automationAction(EventOrchestrationServiceSetRuleActionsAutomationActionArgs.builder()
                                    .name("Canary Slack Notification")
                                    .url("https://our-slack-listerner.test/canary-notification")
                                    .autoSend(true)
                                    .triggerTypes("alert_triggered")
                                    .parameters(                                    
                                        EventOrchestrationServiceSetRuleActionsAutomationActionParameterArgs.builder()
                                            .key("channel")
                                            .value("#my-team-channel")
                                            .build(),
                                        EventOrchestrationServiceSetRuleActionsAutomationActionParameterArgs.builder()
                                            .key("message")
                                            .value("something is wrong with the canary deployment")
                                            .build())
                                    .headers(EventOrchestrationServiceSetRuleActionsAutomationActionHeaderArgs.builder()
                                        .key("X-Notification-Source")
                                        .value("PagerDuty Incident Webhook")
                                        .build())
                                    .build())
                                .build())
                            .build(),
                        EventOrchestrationServiceSetRuleArgs.builder()
                            .label("Never bother the on-call for info-level events outside of work hours, and let an Automation Action fix it instead")
                            .conditions(EventOrchestrationServiceSetRuleConditionArgs.builder()
                                .expression("event.severity matches 'info' and not (now in Mon,Tue,Wed,Thu,Fri 09:00:00 to 17:00:00 America/Los_Angeles)")
                                .build())
                            .actions(EventOrchestrationServiceSetRuleActionsArgs.builder()
                                .suppress(true)
                                .pagerdutyAutomationAction(EventOrchestrationServiceSetRuleActionsPagerdutyAutomationActionArgs.builder()
                                    .actionId("01FJV5A8OA5MKHOYFHV35SM2Z0")
                                    .triggerTypes("alert_suppressed")
                                    .build())
                                .build())
                            .build())
                    .build())
            .catchAll(EventOrchestrationServiceCatchAllArgs.builder()
                .actions(EventOrchestrationServiceCatchAllActionsArgs.builder()
                    .build())
                .build())
            .build());

    }
}

resources:
  engineering:
    type: pagerduty:Team
    properties:
      name: Engineering
  example:
    type: pagerduty:User
    properties:
      name: Earline Greenholt
      email: 125.greenholt.earline@graham.name
  foo:
    type: pagerduty:TeamMembership
    properties:
      userId: ${example.id}
      teamId: ${engineering.id}
      role: manager
  exampleEscalationPolicy:
    type: pagerduty:EscalationPolicy
    name: example
    properties:
      name: Engineering Escalation Policy
      numLoops: 2
      rules:
        - escalationDelayInMinutes: 10
          targets:
            - type: user_reference
              id: ${example.id}
  exampleService:
    type: pagerduty:Service
    name: example
    properties:
      name: My Web App
      autoResolveTimeout: 14400
      acknowledgementTimeout: 600
      escalationPolicy: ${exampleEscalationPolicy.id}
      alertCreation: create_alerts_and_incidents
  csImpact:
    type: pagerduty:IncidentCustomField
    name: cs_impact
    properties:
      name: impact
      dataType: string
      fieldType: single_value
  www:
    type: pagerduty:EventOrchestrationService
    properties:
      service: ${exampleService.id}
      enableEventOrchestrationForService: true
      sets:
        - id: start
          rules:
            - label: Always apply some consistent event transformations to all events
              actions:
                variables:
                  - name: hostname
                    path: event.component
                    value: 'hostname: (.*)'
                    type: regex
                extractions:
                  - template: '{{variables.hostname}}'
                    target: event.custom_details.hostname
                  - source: event.source
                    regex: www (.*) service
                    target: event.source
                routeTo: step-two
        - id: step-two
          rules:
            - label: All critical alerts should be treated as P1 incident
              conditions:
                - expression: event.severity matches 'critical'
              actions:
                annotate: 'Please use our P1 runbook: https://docs.test/p1-runbook'
                priority: ${p1.id}
                incidentCustomFieldUpdates:
                  - id: ${csImpact.id}
                    value: High Impact
            - label: If any of the API apps are unavailable, page the SRE team
              conditions:
                - expression: event.custom_details.service_name matches part '-api' and event.custom_details.status_code matches '502'
              actions:
                escalationPolicy: ${sreEscPolicy.id}
            - label: If there's something wrong on the canary let the team know about it in our deployments Slack channel
              conditions:
                - expression: event.custom_details.hostname matches part 'canary'
              actions:
                automationAction:
                  name: Canary Slack Notification
                  url: https://our-slack-listerner.test/canary-notification
                  autoSend: true
                  triggerTypes: alert_triggered
                  parameters:
                    - key: channel
                      value: '#my-team-channel'
                    - key: message
                      value: something is wrong with the canary deployment
                  headers:
                    - key: X-Notification-Source
                      value: PagerDuty Incident Webhook
            - label: Never bother the on-call for info-level events outside of work hours, and let an Automation Action fix it instead
              conditions:
                - expression: event.severity matches 'info' and not (now in Mon,Tue,Wed,Thu,Fri 09:00:00 to 17:00:00 America/Los_Angeles)
              actions:
                suppress: true
                pagerdutyAutomationAction:
                  actionId: 01FJV5A8OA5MKHOYFHV35SM2Z0
                  triggerTypes: alert_suppressed
      catchAll:
        actions: {}
variables:
  p1:
    fn::invoke:
      function: pagerduty:getPriority
      arguments:
        name: P1
  sreEscPolicy:
    fn::invoke:
      function: pagerduty:getEscalationPolicy
      arguments:
        name: SRE Escalation Policy

var eventOrchestrationServiceResource = new Pagerduty.EventOrchestrationService("eventOrchestrationServiceResource", new()
{
    CatchAll = new Pagerduty.Inputs.EventOrchestrationServiceCatchAllArgs
    {
        Actions = new Pagerduty.Inputs.EventOrchestrationServiceCatchAllActionsArgs
        {
            Annotate = "string",
            AutomationAction = new Pagerduty.Inputs.EventOrchestrationServiceCatchAllActionsAutomationActionArgs
            {
                Name = "string",
                Url = "string",
                AutoSend = false,
                Headers = new[]
                {
                    new Pagerduty.Inputs.EventOrchestrationServiceCatchAllActionsAutomationActionHeaderArgs
                    {
                        Key = "string",
                        Value = "string",
                    },
                },
                Parameters = new[]
                {
                    new Pagerduty.Inputs.EventOrchestrationServiceCatchAllActionsAutomationActionParameterArgs
                    {
                        Key = "string",
                        Value = "string",
                    },
                },
                TriggerTypes = "string",
            },
            EscalationPolicy = "string",
            EventAction = "string",
            Extractions = new[]
            {
                new Pagerduty.Inputs.EventOrchestrationServiceCatchAllActionsExtractionArgs
                {
                    Target = "string",
                    Regex = "string",
                    Source = "string",
                    Template = "string",
                },
            },
            IncidentCustomFieldUpdates = new[]
            {
                new Pagerduty.Inputs.EventOrchestrationServiceCatchAllActionsIncidentCustomFieldUpdateArgs
                {
                    Id = "string",
                    Value = "string",
                },
            },
            PagerdutyAutomationAction = new Pagerduty.Inputs.EventOrchestrationServiceCatchAllActionsPagerdutyAutomationActionArgs
            {
                ActionId = "string",
                TriggerTypes = "string",
            },
            Priority = "string",
            Severity = "string",
            Suppress = false,
            Suspend = 0,
            Variables = new[]
            {
                new Pagerduty.Inputs.EventOrchestrationServiceCatchAllActionsVariableArgs
                {
                    Name = "string",
                    Path = "string",
                    Type = "string",
                    Value = "string",
                },
            },
        },
    },
    Service = "string",
    Sets = new[]
    {
        new Pagerduty.Inputs.EventOrchestrationServiceSetArgs
        {
            Id = "string",
            Rules = new[]
            {
                new Pagerduty.Inputs.EventOrchestrationServiceSetRuleArgs
                {
                    Actions = new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsArgs
                    {
                        Annotate = "string",
                        AutomationAction = new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsAutomationActionArgs
                        {
                            Name = "string",
                            Url = "string",
                            AutoSend = false,
                            Headers = new[]
                            {
                                new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsAutomationActionHeaderArgs
                                {
                                    Key = "string",
                                    Value = "string",
                                },
                            },
                            Parameters = new[]
                            {
                                new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsAutomationActionParameterArgs
                                {
                                    Key = "string",
                                    Value = "string",
                                },
                            },
                            TriggerTypes = "string",
                        },
                        EscalationPolicy = "string",
                        EventAction = "string",
                        Extractions = new[]
                        {
                            new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsExtractionArgs
                            {
                                Target = "string",
                                Regex = "string",
                                Source = "string",
                                Template = "string",
                            },
                        },
                        IncidentCustomFieldUpdates = new[]
                        {
                            new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsIncidentCustomFieldUpdateArgs
                            {
                                Id = "string",
                                Value = "string",
                            },
                        },
                        PagerdutyAutomationAction = new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsPagerdutyAutomationActionArgs
                        {
                            ActionId = "string",
                            TriggerTypes = "string",
                        },
                        Priority = "string",
                        RouteTo = "string",
                        Severity = "string",
                        Suppress = false,
                        Suspend = 0,
                        Variables = new[]
                        {
                            new Pagerduty.Inputs.EventOrchestrationServiceSetRuleActionsVariableArgs
                            {
                                Name = "string",
                                Path = "string",
                                Type = "string",
                                Value = "string",
                            },
                        },
                    },
                    Conditions = new[]
                    {
                        new Pagerduty.Inputs.EventOrchestrationServiceSetRuleConditionArgs
                        {
                            Expression = "string",
                        },
                    },
                    Disabled = false,
                    Id = "string",
                    Label = "string",
                },
            },
        },
    },
    EnableEventOrchestrationForService = false,
});

example, err := pagerduty.NewEventOrchestrationService(ctx, "eventOrchestrationServiceResource", &pagerduty.EventOrchestrationServiceArgs{
	CatchAll: &pagerduty.EventOrchestrationServiceCatchAllArgs{
		Actions: &pagerduty.EventOrchestrationServiceCatchAllActionsArgs{
			Annotate: pulumi.String("string"),
			AutomationAction: &pagerduty.EventOrchestrationServiceCatchAllActionsAutomationActionArgs{
				Name:     pulumi.String("string"),
				Url:      pulumi.String("string"),
				AutoSend: pulumi.Bool(false),
				Headers: pagerduty.EventOrchestrationServiceCatchAllActionsAutomationActionHeaderArray{
					&pagerduty.EventOrchestrationServiceCatchAllActionsAutomationActionHeaderArgs{
						Key:   pulumi.String("string"),
						Value: pulumi.String("string"),
					},
				},
				Parameters: pagerduty.EventOrchestrationServiceCatchAllActionsAutomationActionParameterArray{
					&pagerduty.EventOrchestrationServiceCatchAllActionsAutomationActionParameterArgs{
						Key:   pulumi.String("string"),
						Value: pulumi.String("string"),
					},
				},
				TriggerTypes: pulumi.String("string"),
			},
			EscalationPolicy: pulumi.String("string"),
			EventAction:      pulumi.String("string"),
			Extractions: pagerduty.EventOrchestrationServiceCatchAllActionsExtractionArray{
				&pagerduty.EventOrchestrationServiceCatchAllActionsExtractionArgs{
					Target:   pulumi.String("string"),
					Regex:    pulumi.String("string"),
					Source:   pulumi.String("string"),
					Template: pulumi.String("string"),
				},
			},
			IncidentCustomFieldUpdates: pagerduty.EventOrchestrationServiceCatchAllActionsIncidentCustomFieldUpdateArray{
				&pagerduty.EventOrchestrationServiceCatchAllActionsIncidentCustomFieldUpdateArgs{
					Id:    pulumi.String("string"),
					Value: pulumi.String("string"),
				},
			},
			PagerdutyAutomationAction: &pagerduty.EventOrchestrationServiceCatchAllActionsPagerdutyAutomationActionArgs{
				ActionId:     pulumi.String("string"),
				TriggerTypes: pulumi.String("string"),
			},
			Priority: pulumi.String("string"),
			Severity: pulumi.String("string"),
			Suppress: pulumi.Bool(false),
			Suspend:  pulumi.Int(0),
			Variables: pagerduty.EventOrchestrationServiceCatchAllActionsVariableArray{
				&pagerduty.EventOrchestrationServiceCatchAllActionsVariableArgs{
					Name:  pulumi.String("string"),
					Path:  pulumi.String("string"),
					Type:  pulumi.String("string"),
					Value: pulumi.String("string"),
				},
			},
		},
	},
	Service: pulumi.String("string"),
	Sets: pagerduty.EventOrchestrationServiceSetArray{
		&pagerduty.EventOrchestrationServiceSetArgs{
			Id: pulumi.String("string"),
			Rules: pagerduty.EventOrchestrationServiceSetRuleArray{
				&pagerduty.EventOrchestrationServiceSetRuleArgs{
					Actions: &pagerduty.EventOrchestrationServiceSetRuleActionsArgs{
						Annotate: pulumi.String("string"),
						AutomationAction: &pagerduty.EventOrchestrationServiceSetRuleActionsAutomationActionArgs{
							Name:     pulumi.String("string"),
							Url:      pulumi.String("string"),
							AutoSend: pulumi.Bool(false),
							Headers: pagerduty.EventOrchestrationServiceSetRuleActionsAutomationActionHeaderArray{
								&pagerduty.EventOrchestrationServiceSetRuleActionsAutomationActionHeaderArgs{
									Key:   pulumi.String("string"),
									Value: pulumi.String("string"),
								},
							},
							Parameters: pagerduty.EventOrchestrationServiceSetRuleActionsAutomationActionParameterArray{
								&pagerduty.EventOrchestrationServiceSetRuleActionsAutomationActionParameterArgs{
									Key:   pulumi.String("string"),
									Value: pulumi.String("string"),
								},
							},
							TriggerTypes: pulumi.String("string"),
						},
						EscalationPolicy: pulumi.String("string"),
						EventAction:      pulumi.String("string"),
						Extractions: pagerduty.EventOrchestrationServiceSetRuleActionsExtractionArray{
							&pagerduty.EventOrchestrationServiceSetRuleActionsExtractionArgs{
								Target:   pulumi.String("string"),
								Regex:    pulumi.String("string"),
								Source:   pulumi.String("string"),
								Template: pulumi.String("string"),
							},
						},
						IncidentCustomFieldUpdates: pagerduty.EventOrchestrationServiceSetRuleActionsIncidentCustomFieldUpdateArray{
							&pagerduty.EventOrchestrationServiceSetRuleActionsIncidentCustomFieldUpdateArgs{
								Id:    pulumi.String("string"),
								Value: pulumi.String("string"),
							},
						},
						PagerdutyAutomationAction: &pagerduty.EventOrchestrationServiceSetRuleActionsPagerdutyAutomationActionArgs{
							ActionId:     pulumi.String("string"),
							TriggerTypes: pulumi.String("string"),
						},
						Priority: pulumi.String("string"),
						RouteTo:  pulumi.String("string"),
						Severity: pulumi.String("string"),
						Suppress: pulumi.Bool(false),
						Suspend:  pulumi.Int(0),
						Variables: pagerduty.EventOrchestrationServiceSetRuleActionsVariableArray{
							&pagerduty.EventOrchestrationServiceSetRuleActionsVariableArgs{
								Name:  pulumi.String("string"),
								Path:  pulumi.String("string"),
								Type:  pulumi.String("string"),
								Value: pulumi.String("string"),
							},
						},
					},
					Conditions: pagerduty.EventOrchestrationServiceSetRuleConditionArray{
						&pagerduty.EventOrchestrationServiceSetRuleConditionArgs{
							Expression: pulumi.String("string"),
						},
					},
					Disabled: pulumi.Bool(false),
					Id:       pulumi.String("string"),
					Label:    pulumi.String("string"),
				},
			},
		},
	},
	EnableEventOrchestrationForService: pulumi.Bool(false),
})