import * as pulumi from "@pulumi/pulumi"; import * as inputs from "./types/input"; import * as outputs from "./types/output"; /** * A [Global Orchestration](https://support.pagerduty.com/docs/event-orchestration#global-orchestrations) allows you to create a set of Event Rules. The Global Orchestration evaluates Events sent to it against each of its rules, beginning with the rules in the "start" set. When a matching rule is found, it can modify and enhance the event and can route the event to another set of rules within this Global Orchestration for further processing. * * ## Example of configuring a Global Orchestration * * This example shows creating `Team`, and `Event Orchestration` resources followed by creating a Global Orchestration to handle Events sent to that Event Orchestration. * * This example also shows using the pagerduty.getPriority and pagerduty.EscalationPolicy data sources to configure `priority` and `escalationPolicy` actions for a rule. * * This example shows a Global Orchestration that has nested sets: a rule in the "start" set has a `routeTo` action pointing at the "step-two" set. * * The `catchAll` actions will be applied if an Event reaches the end of any set without matching any rules in that set. In this example the `catchAll` doesn't have any `actions` so it'll leave events as-is. * * ```typescript * import * as pulumi from "@pulumi/pulumi"; * import * as pagerduty from "@pulumi/pagerduty"; * * const databaseTeam = new pagerduty.Team("database_team", {name: "Database Team"}); * const eventOrchestration = new pagerduty.EventOrchestration("event_orchestration", { * name: "Example Orchestration", * team: databaseTeam.id, * }); * const p1 = pagerduty.getPriority({ * name: "P1", * }); * const sreEscPolicy = pagerduty.getEscalationPolicy({ * name: "SRE Escalation Policy", * }); * const global = new pagerduty.EventOrchestrationGlobal("global", { * eventOrchestration: eventOrchestration.id, * sets: [ * { * id: "start", * rules: [{ * label: "Always annotate a note to all events", * actions: { * annotate: "This incident was created by the Database Team via a Global Orchestration", * routeTo: "step-two", * }, * }], * }, * { * id: "step-two", * rules: [ * { * label: "Drop events that are marked as no-op", * conditions: [{ * expression: "event.summary matches 'no-op'", * }], * actions: { * dropEvent: true, * }, * }, * { * label: "If the DB host is running out of space, then page the SRE team", * conditions: [{ * expression: "event.summary matches part 'running out of space'", * }], * actions: { * escalationPolicy: sreEscPolicy.then(sreEscPolicy => sreEscPolicy.id), * }, * }, * { * label: "If there's something wrong on the replica, then mark the alert as a warning", * conditions: [{ * expression: "event.custom_details.hostname matches part 'replica'", * }], * actions: { * severity: "warning", * }, * }, * { * label: "Otherwise, set the incident to P1, pause for 10 mins and run a diagnostic once the alert is suspended", * actions: { * priority: p1.then(p1 => p1.id), * suspend: 600, * automationAction: { * name: "db-diagnostic", * url: "https://example.com/run-diagnostic", * autoSend: true, * triggerTypes: "alert_suspended", * }, * }, * }, * ], * }, * ], * catchAll: { * actions: {}, * }, * }); * ``` * * ## Import * * Global Orchestration can be imported using the `id` of the Event Orchestration, e.g. * * ```sh * $ pulumi import pagerduty:index/eventOrchestrationGlobal:EventOrchestrationGlobal global 1b49abe7-26db-4439-a715-c6d883acfb3e * ``` */ export declare class EventOrchestrationGlobal extends pulumi.CustomResource { /** * Get an existing EventOrchestrationGlobal resource's state with the given name, ID, and optional extra * properties used to qualify the lookup. * * @param name The _unique_ name of the resulting resource. * @param id The _unique_ provider ID of the resource to lookup. * @param state Any extra arguments used during the lookup. * @param opts Optional settings to control the behavior of the CustomResource. */ static get(name: string, id: pulumi.Input, state?: EventOrchestrationGlobalState, opts?: pulumi.CustomResourceOptions): EventOrchestrationGlobal; /** * Returns true if the given object is an instance of EventOrchestrationGlobal. This is designed to work even * when multiple copies of the Pulumi SDK have been loaded into the same process. */ static isInstance(obj: any): obj is EventOrchestrationGlobal; /** * the `catchAll` actions will be applied if an Event reaches the end of any set without matching any rules in that set. */ readonly catchAll: pulumi.Output; /** * ID of the Event Orchestration to which this Global Orchestration belongs to. */ readonly eventOrchestration: pulumi.Output; /** * A Global Orchestration must contain at least a "start" set, but can contain any number of additional sets that are routed to by other rules to form a directional graph. */ readonly sets: pulumi.Output; /** * Create a EventOrchestrationGlobal resource with the given unique name, arguments, and options. * * @param name The _unique_ name of the resource. * @param args The arguments to use to populate this resource's properties. * @param opts A bag of options that control this resource's behavior. */ constructor(name: string, args: EventOrchestrationGlobalArgs, opts?: pulumi.CustomResourceOptions); } /** * Input properties used for looking up and filtering EventOrchestrationGlobal resources. */ export interface EventOrchestrationGlobalState { /** * the `catchAll` actions will be applied if an Event reaches the end of any set without matching any rules in that set. */ catchAll?: pulumi.Input; /** * ID of the Event Orchestration to which this Global Orchestration belongs to. */ eventOrchestration?: pulumi.Input; /** * A Global Orchestration must contain at least a "start" set, but can contain any number of additional sets that are routed to by other rules to form a directional graph. */ sets?: pulumi.Input[] | undefined>; } /** * The set of arguments for constructing a EventOrchestrationGlobal resource. */ export interface EventOrchestrationGlobalArgs { /** * the `catchAll` actions will be applied if an Event reaches the end of any set without matching any rules in that set. */ catchAll: pulumi.Input; /** * ID of the Event Orchestration to which this Global Orchestration belongs to. */ eventOrchestration: pulumi.Input; /** * A Global Orchestration must contain at least a "start" set, but can contain any number of additional sets that are routed to by other rules to form a directional graph. */ sets: pulumi.Input[]>; } //# sourceMappingURL=eventOrchestrationGlobal.d.ts.map