1. Packages
  2. Opsgenie Provider
  3. API Docs
  4. IntegrationAction
Opsgenie v1.3.14 published on Wednesday, Feb 12, 2025 by Pulumi

opsgenie.IntegrationAction

Explore with Pulumi AI

Manages advanced actions for Integrations within Opsgenie. This applies for the following resources:

  • opsgenie.ApiIntegration
  • opsgenie.EmailIntegration

The actions that are supported are:

  • create
  • close
  • acknowledge
  • add_note
  • ignore

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as opsgenie from "@pulumi/opsgenie";
import * as std from "@pulumi/std";

const testAction = new opsgenie.IntegrationAction("test_action", {
    integrationId: testOpsgenieApiIntegration.id,
    creates: [
        {
            name: "create action",
            tags: [
                "CRITICAL",
                "SEV-0",
            ],
            user: "Example-service",
            note: "{{note}}",
            alias: "{{alias}}",
            source: "{{source}}",
            message: "{{message}}",
            description: "{{description}}",
            entity: "{{entity}}",
            alertActions: ["Runbook ID#342"],
            filters: [{
                type: "match-all-conditions",
                conditions: [{
                    field: "priority",
                    operation: "equals",
                    expectedValue: "P1",
                }],
            }],
            responders: [{
                id: test.id,
                type: "team",
            }],
        },
        {
            name: "create action with multiline description",
            message: "{{message}}",
            description: std.chomp({
                input: `This
is a multiline
description.
`,
            }).then(invoke => invoke.result),
            filters: [{
                type: "match-all-conditions",
                conditions: [{
                    field: "priority",
                    operation: "equals",
                    expectedValue: "P1",
                }],
            }],
        },
        {
            name: "Create medium priority alerts",
            tags: [
                "SEVERE",
                "SEV-1",
            ],
            priority: "P3",
            filters: [{
                type: "match-all-conditions",
                conditions: [{
                    field: "priority",
                    operation: "equals",
                    expectedValue: "P2",
                }],
            }],
        },
        {
            name: "Create alert with priority from message",
            customPriority: "{{message.substringAfter(\"[custom]\")}}",
            filters: [{
                type: "match-all-conditions",
                conditions: [
                    {
                        field: "tags",
                        operation: "contains",
                        expectedValue: "P5",
                    },
                    {
                        field: "message",
                        operation: "starts-with",
                        expectedValue: "[custom]",
                    },
                ],
            }],
        },
    ],
    closes: [{
        name: "Low priority alerts",
        filters: [{
            type: "match-any-condition",
            conditions: [
                {
                    field: "priority",
                    operation: "equals",
                    expectedValue: "P5",
                },
                {
                    field: "message",
                    operation: "contains",
                    expectedValue: "DEBUG",
                },
            ],
        }],
    }],
    acknowledges: [{
        name: "Auto-ack test alerts",
        filters: [{
            type: "match-all-conditions",
            conditions: [
                {
                    field: "message",
                    not: true,
                    operation: "contains",
                    expectedValue: "TEST",
                },
                {
                    field: "priority",
                    operation: "equals",
                    expectedValue: "P5",
                },
            ],
        }],
    }],
    addNotes: [{
        name: "Add note to all alerts",
        note: "Created from test integration",
        filters: [{
            type: "match-all",
        }],
    }],
    ignores: [{
        name: "Ignore alerts with ignore tag",
        filters: [{
            type: "match-all-conditions",
            conditions: [{
                field: "tags",
                operation: "contains",
                expectedValue: "ignore",
            }],
        }],
    }],
});
Copy
import pulumi
import pulumi_opsgenie as opsgenie
import pulumi_std as std

test_action = opsgenie.IntegrationAction("test_action",
    integration_id=test_opsgenie_api_integration["id"],
    creates=[
        {
            "name": "create action",
            "tags": [
                "CRITICAL",
                "SEV-0",
            ],
            "user": "Example-service",
            "note": "{{note}}",
            "alias": "{{alias}}",
            "source": "{{source}}",
            "message": "{{message}}",
            "description": "{{description}}",
            "entity": "{{entity}}",
            "alert_actions": ["Runbook ID#342"],
            "filters": [{
                "type": "match-all-conditions",
                "conditions": [{
                    "field": "priority",
                    "operation": "equals",
                    "expected_value": "P1",
                }],
            }],
            "responders": [{
                "id": test["id"],
                "type": "team",
            }],
        },
        {
            "name": "create action with multiline description",
            "message": "{{message}}",
            "description": std.chomp(input="""This
is a multiline
description.
""").result,
            "filters": [{
                "type": "match-all-conditions",
                "conditions": [{
                    "field": "priority",
                    "operation": "equals",
                    "expected_value": "P1",
                }],
            }],
        },
        {
            "name": "Create medium priority alerts",
            "tags": [
                "SEVERE",
                "SEV-1",
            ],
            "priority": "P3",
            "filters": [{
                "type": "match-all-conditions",
                "conditions": [{
                    "field": "priority",
                    "operation": "equals",
                    "expected_value": "P2",
                }],
            }],
        },
        {
            "name": "Create alert with priority from message",
            "custom_priority": "{{message.substringAfter(\"[custom]\")}}",
            "filters": [{
                "type": "match-all-conditions",
                "conditions": [
                    {
                        "field": "tags",
                        "operation": "contains",
                        "expected_value": "P5",
                    },
                    {
                        "field": "message",
                        "operation": "starts-with",
                        "expected_value": "[custom]",
                    },
                ],
            }],
        },
    ],
    closes=[{
        "name": "Low priority alerts",
        "filters": [{
            "type": "match-any-condition",
            "conditions": [
                {
                    "field": "priority",
                    "operation": "equals",
                    "expected_value": "P5",
                },
                {
                    "field": "message",
                    "operation": "contains",
                    "expected_value": "DEBUG",
                },
            ],
        }],
    }],
    acknowledges=[{
        "name": "Auto-ack test alerts",
        "filters": [{
            "type": "match-all-conditions",
            "conditions": [
                {
                    "field": "message",
                    "not_": True,
                    "operation": "contains",
                    "expected_value": "TEST",
                },
                {
                    "field": "priority",
                    "operation": "equals",
                    "expected_value": "P5",
                },
            ],
        }],
    }],
    add_notes=[{
        "name": "Add note to all alerts",
        "note": "Created from test integration",
        "filters": [{
            "type": "match-all",
        }],
    }],
    ignores=[{
        "name": "Ignore alerts with ignore tag",
        "filters": [{
            "type": "match-all-conditions",
            "conditions": [{
                "field": "tags",
                "operation": "contains",
                "expected_value": "ignore",
            }],
        }],
    }])
Copy
package main

import (
	"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		invokeChomp, err := std.Chomp(ctx, &std.ChompArgs{
			Input: "This\nis a multiline\ndescription.\n",
		}, nil)
		if err != nil {
			return err
		}
		_, err = opsgenie.NewIntegrationAction(ctx, "test_action", &opsgenie.IntegrationActionArgs{
			IntegrationId: pulumi.Any(testOpsgenieApiIntegration.Id),
			Creates: opsgenie.IntegrationActionCreateArray{
				&opsgenie.IntegrationActionCreateArgs{
					Name: pulumi.String("create action"),
					Tags: pulumi.StringArray{
						pulumi.String("CRITICAL"),
						pulumi.String("SEV-0"),
					},
					User:        pulumi.String("Example-service"),
					Note:        pulumi.String("{{note}}"),
					Alias:       pulumi.String("{{alias}}"),
					Source:      pulumi.String("{{source}}"),
					Message:     pulumi.String("{{message}}"),
					Description: pulumi.String("{{description}}"),
					Entity:      pulumi.String("{{entity}}"),
					AlertActions: pulumi.StringArray{
						pulumi.String("Runbook ID#342"),
					},
					Filters: opsgenie.IntegrationActionCreateFilterArray{
						&opsgenie.IntegrationActionCreateFilterArgs{
							Type: pulumi.String("match-all-conditions"),
							Conditions: opsgenie.IntegrationActionCreateFilterConditionArray{
								&opsgenie.IntegrationActionCreateFilterConditionArgs{
									Field:         pulumi.String("priority"),
									Operation:     pulumi.String("equals"),
									ExpectedValue: pulumi.String("P1"),
								},
							},
						},
					},
					Responders: opsgenie.IntegrationActionCreateResponderArray{
						&opsgenie.IntegrationActionCreateResponderArgs{
							Id:   pulumi.Any(test.Id),
							Type: pulumi.String("team"),
						},
					},
				},
				&opsgenie.IntegrationActionCreateArgs{
					Name:        pulumi.String("create action with multiline description"),
					Message:     pulumi.String("{{message}}"),
					Description: pulumi.String(invokeChomp.Result),
					Filters: opsgenie.IntegrationActionCreateFilterArray{
						&opsgenie.IntegrationActionCreateFilterArgs{
							Type: pulumi.String("match-all-conditions"),
							Conditions: opsgenie.IntegrationActionCreateFilterConditionArray{
								&opsgenie.IntegrationActionCreateFilterConditionArgs{
									Field:         pulumi.String("priority"),
									Operation:     pulumi.String("equals"),
									ExpectedValue: pulumi.String("P1"),
								},
							},
						},
					},
				},
				&opsgenie.IntegrationActionCreateArgs{
					Name: pulumi.String("Create medium priority alerts"),
					Tags: pulumi.StringArray{
						pulumi.String("SEVERE"),
						pulumi.String("SEV-1"),
					},
					Priority: pulumi.String("P3"),
					Filters: opsgenie.IntegrationActionCreateFilterArray{
						&opsgenie.IntegrationActionCreateFilterArgs{
							Type: pulumi.String("match-all-conditions"),
							Conditions: opsgenie.IntegrationActionCreateFilterConditionArray{
								&opsgenie.IntegrationActionCreateFilterConditionArgs{
									Field:         pulumi.String("priority"),
									Operation:     pulumi.String("equals"),
									ExpectedValue: pulumi.String("P2"),
								},
							},
						},
					},
				},
				&opsgenie.IntegrationActionCreateArgs{
					Name:           pulumi.String("Create alert with priority from message"),
					CustomPriority: pulumi.String("{{message.substringAfter(\"[custom]\")}}"),
					Filters: opsgenie.IntegrationActionCreateFilterArray{
						&opsgenie.IntegrationActionCreateFilterArgs{
							Type: pulumi.String("match-all-conditions"),
							Conditions: opsgenie.IntegrationActionCreateFilterConditionArray{
								&opsgenie.IntegrationActionCreateFilterConditionArgs{
									Field:         pulumi.String("tags"),
									Operation:     pulumi.String("contains"),
									ExpectedValue: pulumi.String("P5"),
								},
								&opsgenie.IntegrationActionCreateFilterConditionArgs{
									Field:         pulumi.String("message"),
									Operation:     pulumi.String("starts-with"),
									ExpectedValue: pulumi.String("[custom]"),
								},
							},
						},
					},
				},
			},
			Closes: opsgenie.IntegrationActionCloseArray{
				&opsgenie.IntegrationActionCloseArgs{
					Name: pulumi.String("Low priority alerts"),
					Filters: opsgenie.IntegrationActionCloseFilterArray{
						&opsgenie.IntegrationActionCloseFilterArgs{
							Type: pulumi.String("match-any-condition"),
							Conditions: opsgenie.IntegrationActionCloseFilterConditionArray{
								&opsgenie.IntegrationActionCloseFilterConditionArgs{
									Field:         pulumi.String("priority"),
									Operation:     pulumi.String("equals"),
									ExpectedValue: pulumi.String("P5"),
								},
								&opsgenie.IntegrationActionCloseFilterConditionArgs{
									Field:         pulumi.String("message"),
									Operation:     pulumi.String("contains"),
									ExpectedValue: pulumi.String("DEBUG"),
								},
							},
						},
					},
				},
			},
			Acknowledges: opsgenie.IntegrationActionAcknowledgeArray{
				&opsgenie.IntegrationActionAcknowledgeArgs{
					Name: pulumi.String("Auto-ack test alerts"),
					Filters: opsgenie.IntegrationActionAcknowledgeFilterArray{
						&opsgenie.IntegrationActionAcknowledgeFilterArgs{
							Type: pulumi.String("match-all-conditions"),
							Conditions: opsgenie.IntegrationActionAcknowledgeFilterConditionArray{
								&opsgenie.IntegrationActionAcknowledgeFilterConditionArgs{
									Field:         pulumi.String("message"),
									Not:           pulumi.Bool(true),
									Operation:     pulumi.String("contains"),
									ExpectedValue: pulumi.String("TEST"),
								},
								&opsgenie.IntegrationActionAcknowledgeFilterConditionArgs{
									Field:         pulumi.String("priority"),
									Operation:     pulumi.String("equals"),
									ExpectedValue: pulumi.String("P5"),
								},
							},
						},
					},
				},
			},
			AddNotes: opsgenie.IntegrationActionAddNoteArray{
				&opsgenie.IntegrationActionAddNoteArgs{
					Name: pulumi.String("Add note to all alerts"),
					Note: pulumi.String("Created from test integration"),
					Filters: opsgenie.IntegrationActionAddNoteFilterArray{
						&opsgenie.IntegrationActionAddNoteFilterArgs{
							Type: pulumi.String("match-all"),
						},
					},
				},
			},
			Ignores: opsgenie.IntegrationActionIgnoreArray{
				&opsgenie.IntegrationActionIgnoreArgs{
					Name: pulumi.String("Ignore alerts with ignore tag"),
					Filters: opsgenie.IntegrationActionIgnoreFilterArray{
						&opsgenie.IntegrationActionIgnoreFilterArgs{
							Type: pulumi.String("match-all-conditions"),
							Conditions: opsgenie.IntegrationActionIgnoreFilterConditionArray{
								&opsgenie.IntegrationActionIgnoreFilterConditionArgs{
									Field:         pulumi.String("tags"),
									Operation:     pulumi.String("contains"),
									ExpectedValue: pulumi.String("ignore"),
								},
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Opsgenie = Pulumi.Opsgenie;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    var testAction = new Opsgenie.IntegrationAction("test_action", new()
    {
        IntegrationId = testOpsgenieApiIntegration.Id,
        Creates = new[]
        {
            new Opsgenie.Inputs.IntegrationActionCreateArgs
            {
                Name = "create action",
                Tags = new[]
                {
                    "CRITICAL",
                    "SEV-0",
                },
                User = "Example-service",
                Note = "{{note}}",
                Alias = "{{alias}}",
                Source = "{{source}}",
                Message = "{{message}}",
                Description = "{{description}}",
                Entity = "{{entity}}",
                AlertActions = new[]
                {
                    "Runbook ID#342",
                },
                Filters = new[]
                {
                    new Opsgenie.Inputs.IntegrationActionCreateFilterArgs
                    {
                        Type = "match-all-conditions",
                        Conditions = new[]
                        {
                            new Opsgenie.Inputs.IntegrationActionCreateFilterConditionArgs
                            {
                                Field = "priority",
                                Operation = "equals",
                                ExpectedValue = "P1",
                            },
                        },
                    },
                },
                Responders = new[]
                {
                    new Opsgenie.Inputs.IntegrationActionCreateResponderArgs
                    {
                        Id = test.Id,
                        Type = "team",
                    },
                },
            },
            new Opsgenie.Inputs.IntegrationActionCreateArgs
            {
                Name = "create action with multiline description",
                Message = "{{message}}",
                Description = Std.Chomp.Invoke(new()
                {
                    Input = @"This
is a multiline
description.
",
                }).Apply(invoke => invoke.Result),
                Filters = new[]
                {
                    new Opsgenie.Inputs.IntegrationActionCreateFilterArgs
                    {
                        Type = "match-all-conditions",
                        Conditions = new[]
                        {
                            new Opsgenie.Inputs.IntegrationActionCreateFilterConditionArgs
                            {
                                Field = "priority",
                                Operation = "equals",
                                ExpectedValue = "P1",
                            },
                        },
                    },
                },
            },
            new Opsgenie.Inputs.IntegrationActionCreateArgs
            {
                Name = "Create medium priority alerts",
                Tags = new[]
                {
                    "SEVERE",
                    "SEV-1",
                },
                Priority = "P3",
                Filters = new[]
                {
                    new Opsgenie.Inputs.IntegrationActionCreateFilterArgs
                    {
                        Type = "match-all-conditions",
                        Conditions = new[]
                        {
                            new Opsgenie.Inputs.IntegrationActionCreateFilterConditionArgs
                            {
                                Field = "priority",
                                Operation = "equals",
                                ExpectedValue = "P2",
                            },
                        },
                    },
                },
            },
            new Opsgenie.Inputs.IntegrationActionCreateArgs
            {
                Name = "Create alert with priority from message",
                CustomPriority = "{{message.substringAfter(\"[custom]\")}}",
                Filters = new[]
                {
                    new Opsgenie.Inputs.IntegrationActionCreateFilterArgs
                    {
                        Type = "match-all-conditions",
                        Conditions = new[]
                        {
                            new Opsgenie.Inputs.IntegrationActionCreateFilterConditionArgs
                            {
                                Field = "tags",
                                Operation = "contains",
                                ExpectedValue = "P5",
                            },
                            new Opsgenie.Inputs.IntegrationActionCreateFilterConditionArgs
                            {
                                Field = "message",
                                Operation = "starts-with",
                                ExpectedValue = "[custom]",
                            },
                        },
                    },
                },
            },
        },
        Closes = new[]
        {
            new Opsgenie.Inputs.IntegrationActionCloseArgs
            {
                Name = "Low priority alerts",
                Filters = new[]
                {
                    new Opsgenie.Inputs.IntegrationActionCloseFilterArgs
                    {
                        Type = "match-any-condition",
                        Conditions = new[]
                        {
                            new Opsgenie.Inputs.IntegrationActionCloseFilterConditionArgs
                            {
                                Field = "priority",
                                Operation = "equals",
                                ExpectedValue = "P5",
                            },
                            new Opsgenie.Inputs.IntegrationActionCloseFilterConditionArgs
                            {
                                Field = "message",
                                Operation = "contains",
                                ExpectedValue = "DEBUG",
                            },
                        },
                    },
                },
            },
        },
        Acknowledges = new[]
        {
            new Opsgenie.Inputs.IntegrationActionAcknowledgeArgs
            {
                Name = "Auto-ack test alerts",
                Filters = new[]
                {
                    new Opsgenie.Inputs.IntegrationActionAcknowledgeFilterArgs
                    {
                        Type = "match-all-conditions",
                        Conditions = new[]
                        {
                            new Opsgenie.Inputs.IntegrationActionAcknowledgeFilterConditionArgs
                            {
                                Field = "message",
                                Not = true,
                                Operation = "contains",
                                ExpectedValue = "TEST",
                            },
                            new Opsgenie.Inputs.IntegrationActionAcknowledgeFilterConditionArgs
                            {
                                Field = "priority",
                                Operation = "equals",
                                ExpectedValue = "P5",
                            },
                        },
                    },
                },
            },
        },
        AddNotes = new[]
        {
            new Opsgenie.Inputs.IntegrationActionAddNoteArgs
            {
                Name = "Add note to all alerts",
                Note = "Created from test integration",
                Filters = new[]
                {
                    new Opsgenie.Inputs.IntegrationActionAddNoteFilterArgs
                    {
                        Type = "match-all",
                    },
                },
            },
        },
        Ignores = new[]
        {
            new Opsgenie.Inputs.IntegrationActionIgnoreArgs
            {
                Name = "Ignore alerts with ignore tag",
                Filters = new[]
                {
                    new Opsgenie.Inputs.IntegrationActionIgnoreFilterArgs
                    {
                        Type = "match-all-conditions",
                        Conditions = new[]
                        {
                            new Opsgenie.Inputs.IntegrationActionIgnoreFilterConditionArgs
                            {
                                Field = "tags",
                                Operation = "contains",
                                ExpectedValue = "ignore",
                            },
                        },
                    },
                },
            },
        },
    });

});
Copy
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.opsgenie.IntegrationAction;
import com.pulumi.opsgenie.IntegrationActionArgs;
import com.pulumi.opsgenie.inputs.IntegrationActionCreateArgs;
import com.pulumi.opsgenie.inputs.IntegrationActionCloseArgs;
import com.pulumi.opsgenie.inputs.IntegrationActionAcknowledgeArgs;
import com.pulumi.opsgenie.inputs.IntegrationActionAddNoteArgs;
import com.pulumi.opsgenie.inputs.IntegrationActionIgnoreArgs;
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 testAction = new IntegrationAction("testAction", IntegrationActionArgs.builder()
            .integrationId(testOpsgenieApiIntegration.id())
            .creates(            
                IntegrationActionCreateArgs.builder()
                    .name("create action")
                    .tags(                    
                        "CRITICAL",
                        "SEV-0")
                    .user("Example-service")
                    .note("{{note}}")
                    .alias("{{alias}}")
                    .source("{{source}}")
                    .message("{{message}}")
                    .description("{{description}}")
                    .entity("{{entity}}")
                    .alertActions("Runbook ID#342")
                    .filters(IntegrationActionCreateFilterArgs.builder()
                        .type("match-all-conditions")
                        .conditions(IntegrationActionCreateFilterConditionArgs.builder()
                            .field("priority")
                            .operation("equals")
                            .expectedValue("P1")
                            .build())
                        .build())
                    .responders(IntegrationActionCreateResponderArgs.builder()
                        .id(test.id())
                        .type("team")
                        .build())
                    .build(),
                IntegrationActionCreateArgs.builder()
                    .name("create action with multiline description")
                    .message("{{message}}")
                    .description(StdFunctions.chomp(ChompArgs.builder()
                        .input("""
This
is a multiline
description.
                        """)
                        .build()).result())
                    .filters(IntegrationActionCreateFilterArgs.builder()
                        .type("match-all-conditions")
                        .conditions(IntegrationActionCreateFilterConditionArgs.builder()
                            .field("priority")
                            .operation("equals")
                            .expectedValue("P1")
                            .build())
                        .build())
                    .build(),
                IntegrationActionCreateArgs.builder()
                    .name("Create medium priority alerts")
                    .tags(                    
                        "SEVERE",
                        "SEV-1")
                    .priority("P3")
                    .filters(IntegrationActionCreateFilterArgs.builder()
                        .type("match-all-conditions")
                        .conditions(IntegrationActionCreateFilterConditionArgs.builder()
                            .field("priority")
                            .operation("equals")
                            .expectedValue("P2")
                            .build())
                        .build())
                    .build(),
                IntegrationActionCreateArgs.builder()
                    .name("Create alert with priority from message")
                    .customPriority("{{message.substringAfter(\"[custom]\")}}")
                    .filters(IntegrationActionCreateFilterArgs.builder()
                        .type("match-all-conditions")
                        .conditions(                        
                            IntegrationActionCreateFilterConditionArgs.builder()
                                .field("tags")
                                .operation("contains")
                                .expectedValue("P5")
                                .build(),
                            IntegrationActionCreateFilterConditionArgs.builder()
                                .field("message")
                                .operation("starts-with")
                                .expectedValue("[custom]")
                                .build())
                        .build())
                    .build())
            .closes(IntegrationActionCloseArgs.builder()
                .name("Low priority alerts")
                .filters(IntegrationActionCloseFilterArgs.builder()
                    .type("match-any-condition")
                    .conditions(                    
                        IntegrationActionCloseFilterConditionArgs.builder()
                            .field("priority")
                            .operation("equals")
                            .expectedValue("P5")
                            .build(),
                        IntegrationActionCloseFilterConditionArgs.builder()
                            .field("message")
                            .operation("contains")
                            .expectedValue("DEBUG")
                            .build())
                    .build())
                .build())
            .acknowledges(IntegrationActionAcknowledgeArgs.builder()
                .name("Auto-ack test alerts")
                .filters(IntegrationActionAcknowledgeFilterArgs.builder()
                    .type("match-all-conditions")
                    .conditions(                    
                        IntegrationActionAcknowledgeFilterConditionArgs.builder()
                            .field("message")
                            .not(true)
                            .operation("contains")
                            .expectedValue("TEST")
                            .build(),
                        IntegrationActionAcknowledgeFilterConditionArgs.builder()
                            .field("priority")
                            .operation("equals")
                            .expectedValue("P5")
                            .build())
                    .build())
                .build())
            .addNotes(IntegrationActionAddNoteArgs.builder()
                .name("Add note to all alerts")
                .note("Created from test integration")
                .filters(IntegrationActionAddNoteFilterArgs.builder()
                    .type("match-all")
                    .build())
                .build())
            .ignores(IntegrationActionIgnoreArgs.builder()
                .name("Ignore alerts with ignore tag")
                .filters(IntegrationActionIgnoreFilterArgs.builder()
                    .type("match-all-conditions")
                    .conditions(IntegrationActionIgnoreFilterConditionArgs.builder()
                        .field("tags")
                        .operation("contains")
                        .expectedValue("ignore")
                        .build())
                    .build())
                .build())
            .build());

    }
}
Copy
resources:
  testAction:
    type: opsgenie:IntegrationAction
    name: test_action
    properties:
      integrationId: ${testOpsgenieApiIntegration.id}
      creates:
        - name: create action
          tags:
            - CRITICAL
            - SEV-0
          user: Example-service
          note: '{{note}}'
          alias: '{{alias}}'
          source: '{{source}}'
          message: '{{message}}'
          description: '{{description}}'
          entity: '{{entity}}'
          alertActions:
            - Runbook ID#342
          filters:
            - type: match-all-conditions
              conditions:
                - field: priority
                  operation: equals
                  expectedValue: P1
          responders:
            - id: ${test.id}
              type: team
        - name: create action with multiline description
          message: '{{message}}'
          description:
            fn::invoke:
              function: std:chomp
              arguments:
                input: |
                  This
                  is a multiline
                  description.                  
              return: result
          filters:
            - type: match-all-conditions
              conditions:
                - field: priority
                  operation: equals
                  expectedValue: P1
        - name: Create medium priority alerts
          tags:
            - SEVERE
            - SEV-1
          priority: P3
          filters:
            - type: match-all-conditions
              conditions:
                - field: priority
                  operation: equals
                  expectedValue: P2
        - name: Create alert with priority from message
          customPriority: '{{message.substringAfter("[custom]")}}'
          filters:
            - type: match-all-conditions
              conditions:
                - field: tags
                  operation: contains
                  expectedValue: P5
                - field: message
                  operation: starts-with
                  expectedValue: '[custom]'
      closes:
        - name: Low priority alerts
          filters:
            - type: match-any-condition
              conditions:
                - field: priority
                  operation: equals
                  expectedValue: P5
                - field: message
                  operation: contains
                  expectedValue: DEBUG
      acknowledges:
        - name: Auto-ack test alerts
          filters:
            - type: match-all-conditions
              conditions:
                - field: message
                  not: true
                  operation: contains
                  expectedValue: TEST
                - field: priority
                  operation: equals
                  expectedValue: P5
      addNotes:
        - name: Add note to all alerts
          note: Created from test integration
          filters:
            - type: match-all
      ignores:
        - name: Ignore alerts with ignore tag
          filters:
            - type: match-all-conditions
              conditions:
                - field: tags
                  operation: contains
                  expectedValue: ignore
Copy

Create IntegrationAction Resource

Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

Constructor syntax

new IntegrationAction(name: string, args: IntegrationActionArgs, opts?: CustomResourceOptions);
@overload
def IntegrationAction(resource_name: str,
                      args: IntegrationActionArgs,
                      opts: Optional[ResourceOptions] = None)

@overload
def IntegrationAction(resource_name: str,
                      opts: Optional[ResourceOptions] = None,
                      integration_id: Optional[str] = None,
                      acknowledges: Optional[Sequence[IntegrationActionAcknowledgeArgs]] = None,
                      add_notes: Optional[Sequence[IntegrationActionAddNoteArgs]] = None,
                      closes: Optional[Sequence[IntegrationActionCloseArgs]] = None,
                      creates: Optional[Sequence[IntegrationActionCreateArgs]] = None,
                      ignores: Optional[Sequence[IntegrationActionIgnoreArgs]] = None)
func NewIntegrationAction(ctx *Context, name string, args IntegrationActionArgs, opts ...ResourceOption) (*IntegrationAction, error)
public IntegrationAction(string name, IntegrationActionArgs args, CustomResourceOptions? opts = null)
public IntegrationAction(String name, IntegrationActionArgs args)
public IntegrationAction(String name, IntegrationActionArgs args, CustomResourceOptions options)
type: opsgenie:IntegrationAction
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

Parameters

name This property is required. string
The unique name of the resource.
args This property is required. IntegrationActionArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
resource_name This property is required. str
The unique name of the resource.
args This property is required. IntegrationActionArgs
The arguments to resource properties.
opts ResourceOptions
Bag of options to control resource's behavior.
ctx Context
Context object for the current deployment.
name This property is required. string
The unique name of the resource.
args This property is required. IntegrationActionArgs
The arguments to resource properties.
opts ResourceOption
Bag of options to control resource's behavior.
name This property is required. string
The unique name of the resource.
args This property is required. IntegrationActionArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
name This property is required. String
The unique name of the resource.
args This property is required. IntegrationActionArgs
The arguments to resource properties.
options CustomResourceOptions
Bag of options to control resource's behavior.

Constructor example

The following reference example uses placeholder values for all input properties.

var integrationActionResource = new Opsgenie.IntegrationAction("integrationActionResource", new()
{
    IntegrationId = "string",
    Acknowledges = new[]
    {
        new Opsgenie.Inputs.IntegrationActionAcknowledgeArgs
        {
            Name = "string",
            Alias = "string",
            Filters = new[]
            {
                new Opsgenie.Inputs.IntegrationActionAcknowledgeFilterArgs
                {
                    Type = "string",
                    Conditions = new[]
                    {
                        new Opsgenie.Inputs.IntegrationActionAcknowledgeFilterConditionArgs
                        {
                            Field = "string",
                            Operation = "string",
                            ExpectedValue = "string",
                            Key = "string",
                            Not = false,
                            Order = 0,
                        },
                    },
                },
            },
            Note = "string",
            Order = 0,
            Type = "string",
            User = "string",
        },
    },
    AddNotes = new[]
    {
        new Opsgenie.Inputs.IntegrationActionAddNoteArgs
        {
            Name = "string",
            Alias = "string",
            Filters = new[]
            {
                new Opsgenie.Inputs.IntegrationActionAddNoteFilterArgs
                {
                    Type = "string",
                    Conditions = new[]
                    {
                        new Opsgenie.Inputs.IntegrationActionAddNoteFilterConditionArgs
                        {
                            Field = "string",
                            Operation = "string",
                            ExpectedValue = "string",
                            Key = "string",
                            Not = false,
                            Order = 0,
                        },
                    },
                },
            },
            Note = "string",
            Order = 0,
            Type = "string",
            User = "string",
        },
    },
    Closes = new[]
    {
        new Opsgenie.Inputs.IntegrationActionCloseArgs
        {
            Name = "string",
            Alias = "string",
            Filters = new[]
            {
                new Opsgenie.Inputs.IntegrationActionCloseFilterArgs
                {
                    Type = "string",
                    Conditions = new[]
                    {
                        new Opsgenie.Inputs.IntegrationActionCloseFilterConditionArgs
                        {
                            Field = "string",
                            Operation = "string",
                            ExpectedValue = "string",
                            Key = "string",
                            Not = false,
                            Order = 0,
                        },
                    },
                },
            },
            Note = "string",
            Order = 0,
            Type = "string",
            User = "string",
        },
    },
    Creates = new[]
    {
        new Opsgenie.Inputs.IntegrationActionCreateArgs
        {
            Name = "string",
            IgnoreRespondersFromPayload = false,
            IgnoreTeamsFromPayload = false,
            CustomPriority = "string",
            Description = "string",
            Entity = "string",
            ExtraProperties = 
            {
                { "string", "string" },
            },
            Filters = new[]
            {
                new Opsgenie.Inputs.IntegrationActionCreateFilterArgs
                {
                    Type = "string",
                    Conditions = new[]
                    {
                        new Opsgenie.Inputs.IntegrationActionCreateFilterConditionArgs
                        {
                            Field = "string",
                            Operation = "string",
                            ExpectedValue = "string",
                            Key = "string",
                            Not = false,
                            Order = 0,
                        },
                    },
                },
            },
            IgnoreAlertActionsFromPayload = false,
            IgnoreExtraPropertiesFromPayload = false,
            Message = "string",
            AppendAttachments = false,
            IgnoreTagsFromPayload = false,
            AlertActions = new[]
            {
                "string",
            },
            Alias = "string",
            Note = "string",
            Order = 0,
            Priority = "string",
            Responders = new[]
            {
                new Opsgenie.Inputs.IntegrationActionCreateResponderArgs
                {
                    Id = "string",
                    Type = "string",
                },
            },
            Source = "string",
            Tags = new[]
            {
                "string",
            },
            Type = "string",
            User = "string",
        },
    },
    Ignores = new[]
    {
        new Opsgenie.Inputs.IntegrationActionIgnoreArgs
        {
            Name = "string",
            Filters = new[]
            {
                new Opsgenie.Inputs.IntegrationActionIgnoreFilterArgs
                {
                    Type = "string",
                    Conditions = new[]
                    {
                        new Opsgenie.Inputs.IntegrationActionIgnoreFilterConditionArgs
                        {
                            Field = "string",
                            Operation = "string",
                            ExpectedValue = "string",
                            Key = "string",
                            Not = false,
                            Order = 0,
                        },
                    },
                },
            },
            Order = 0,
            Type = "string",
        },
    },
});
Copy
example, err := opsgenie.NewIntegrationAction(ctx, "integrationActionResource", &opsgenie.IntegrationActionArgs{
	IntegrationId: pulumi.String("string"),
	Acknowledges: opsgenie.IntegrationActionAcknowledgeArray{
		&opsgenie.IntegrationActionAcknowledgeArgs{
			Name:  pulumi.String("string"),
			Alias: pulumi.String("string"),
			Filters: opsgenie.IntegrationActionAcknowledgeFilterArray{
				&opsgenie.IntegrationActionAcknowledgeFilterArgs{
					Type: pulumi.String("string"),
					Conditions: opsgenie.IntegrationActionAcknowledgeFilterConditionArray{
						&opsgenie.IntegrationActionAcknowledgeFilterConditionArgs{
							Field:         pulumi.String("string"),
							Operation:     pulumi.String("string"),
							ExpectedValue: pulumi.String("string"),
							Key:           pulumi.String("string"),
							Not:           pulumi.Bool(false),
							Order:         pulumi.Int(0),
						},
					},
				},
			},
			Note:  pulumi.String("string"),
			Order: pulumi.Int(0),
			Type:  pulumi.String("string"),
			User:  pulumi.String("string"),
		},
	},
	AddNotes: opsgenie.IntegrationActionAddNoteArray{
		&opsgenie.IntegrationActionAddNoteArgs{
			Name:  pulumi.String("string"),
			Alias: pulumi.String("string"),
			Filters: opsgenie.IntegrationActionAddNoteFilterArray{
				&opsgenie.IntegrationActionAddNoteFilterArgs{
					Type: pulumi.String("string"),
					Conditions: opsgenie.IntegrationActionAddNoteFilterConditionArray{
						&opsgenie.IntegrationActionAddNoteFilterConditionArgs{
							Field:         pulumi.String("string"),
							Operation:     pulumi.String("string"),
							ExpectedValue: pulumi.String("string"),
							Key:           pulumi.String("string"),
							Not:           pulumi.Bool(false),
							Order:         pulumi.Int(0),
						},
					},
				},
			},
			Note:  pulumi.String("string"),
			Order: pulumi.Int(0),
			Type:  pulumi.String("string"),
			User:  pulumi.String("string"),
		},
	},
	Closes: opsgenie.IntegrationActionCloseArray{
		&opsgenie.IntegrationActionCloseArgs{
			Name:  pulumi.String("string"),
			Alias: pulumi.String("string"),
			Filters: opsgenie.IntegrationActionCloseFilterArray{
				&opsgenie.IntegrationActionCloseFilterArgs{
					Type: pulumi.String("string"),
					Conditions: opsgenie.IntegrationActionCloseFilterConditionArray{
						&opsgenie.IntegrationActionCloseFilterConditionArgs{
							Field:         pulumi.String("string"),
							Operation:     pulumi.String("string"),
							ExpectedValue: pulumi.String("string"),
							Key:           pulumi.String("string"),
							Not:           pulumi.Bool(false),
							Order:         pulumi.Int(0),
						},
					},
				},
			},
			Note:  pulumi.String("string"),
			Order: pulumi.Int(0),
			Type:  pulumi.String("string"),
			User:  pulumi.String("string"),
		},
	},
	Creates: opsgenie.IntegrationActionCreateArray{
		&opsgenie.IntegrationActionCreateArgs{
			Name:                        pulumi.String("string"),
			IgnoreRespondersFromPayload: pulumi.Bool(false),
			IgnoreTeamsFromPayload:      pulumi.Bool(false),
			CustomPriority:              pulumi.String("string"),
			Description:                 pulumi.String("string"),
			Entity:                      pulumi.String("string"),
			ExtraProperties: pulumi.StringMap{
				"string": pulumi.String("string"),
			},
			Filters: opsgenie.IntegrationActionCreateFilterArray{
				&opsgenie.IntegrationActionCreateFilterArgs{
					Type: pulumi.String("string"),
					Conditions: opsgenie.IntegrationActionCreateFilterConditionArray{
						&opsgenie.IntegrationActionCreateFilterConditionArgs{
							Field:         pulumi.String("string"),
							Operation:     pulumi.String("string"),
							ExpectedValue: pulumi.String("string"),
							Key:           pulumi.String("string"),
							Not:           pulumi.Bool(false),
							Order:         pulumi.Int(0),
						},
					},
				},
			},
			IgnoreAlertActionsFromPayload:    pulumi.Bool(false),
			IgnoreExtraPropertiesFromPayload: pulumi.Bool(false),
			Message:                          pulumi.String("string"),
			AppendAttachments:                pulumi.Bool(false),
			IgnoreTagsFromPayload:            pulumi.Bool(false),
			AlertActions: pulumi.StringArray{
				pulumi.String("string"),
			},
			Alias:    pulumi.String("string"),
			Note:     pulumi.String("string"),
			Order:    pulumi.Int(0),
			Priority: pulumi.String("string"),
			Responders: opsgenie.IntegrationActionCreateResponderArray{
				&opsgenie.IntegrationActionCreateResponderArgs{
					Id:   pulumi.String("string"),
					Type: pulumi.String("string"),
				},
			},
			Source: pulumi.String("string"),
			Tags: pulumi.StringArray{
				pulumi.String("string"),
			},
			Type: pulumi.String("string"),
			User: pulumi.String("string"),
		},
	},
	Ignores: opsgenie.IntegrationActionIgnoreArray{
		&opsgenie.IntegrationActionIgnoreArgs{
			Name: pulumi.String("string"),
			Filters: opsgenie.IntegrationActionIgnoreFilterArray{
				&opsgenie.IntegrationActionIgnoreFilterArgs{
					Type: pulumi.String("string"),
					Conditions: opsgenie.IntegrationActionIgnoreFilterConditionArray{
						&opsgenie.IntegrationActionIgnoreFilterConditionArgs{
							Field:         pulumi.String("string"),
							Operation:     pulumi.String("string"),
							ExpectedValue: pulumi.String("string"),
							Key:           pulumi.String("string"),
							Not:           pulumi.Bool(false),
							Order:         pulumi.Int(0),
						},
					},
				},
			},
			Order: pulumi.Int(0),
			Type:  pulumi.String("string"),
		},
	},
})
Copy
var integrationActionResource = new IntegrationAction("integrationActionResource", IntegrationActionArgs.builder()
    .integrationId("string")
    .acknowledges(IntegrationActionAcknowledgeArgs.builder()
        .name("string")
        .alias("string")
        .filters(IntegrationActionAcknowledgeFilterArgs.builder()
            .type("string")
            .conditions(IntegrationActionAcknowledgeFilterConditionArgs.builder()
                .field("string")
                .operation("string")
                .expectedValue("string")
                .key("string")
                .not(false)
                .order(0)
                .build())
            .build())
        .note("string")
        .order(0)
        .type("string")
        .user("string")
        .build())
    .addNotes(IntegrationActionAddNoteArgs.builder()
        .name("string")
        .alias("string")
        .filters(IntegrationActionAddNoteFilterArgs.builder()
            .type("string")
            .conditions(IntegrationActionAddNoteFilterConditionArgs.builder()
                .field("string")
                .operation("string")
                .expectedValue("string")
                .key("string")
                .not(false)
                .order(0)
                .build())
            .build())
        .note("string")
        .order(0)
        .type("string")
        .user("string")
        .build())
    .closes(IntegrationActionCloseArgs.builder()
        .name("string")
        .alias("string")
        .filters(IntegrationActionCloseFilterArgs.builder()
            .type("string")
            .conditions(IntegrationActionCloseFilterConditionArgs.builder()
                .field("string")
                .operation("string")
                .expectedValue("string")
                .key("string")
                .not(false)
                .order(0)
                .build())
            .build())
        .note("string")
        .order(0)
        .type("string")
        .user("string")
        .build())
    .creates(IntegrationActionCreateArgs.builder()
        .name("string")
        .ignoreRespondersFromPayload(false)
        .ignoreTeamsFromPayload(false)
        .customPriority("string")
        .description("string")
        .entity("string")
        .extraProperties(Map.of("string", "string"))
        .filters(IntegrationActionCreateFilterArgs.builder()
            .type("string")
            .conditions(IntegrationActionCreateFilterConditionArgs.builder()
                .field("string")
                .operation("string")
                .expectedValue("string")
                .key("string")
                .not(false)
                .order(0)
                .build())
            .build())
        .ignoreAlertActionsFromPayload(false)
        .ignoreExtraPropertiesFromPayload(false)
        .message("string")
        .appendAttachments(false)
        .ignoreTagsFromPayload(false)
        .alertActions("string")
        .alias("string")
        .note("string")
        .order(0)
        .priority("string")
        .responders(IntegrationActionCreateResponderArgs.builder()
            .id("string")
            .type("string")
            .build())
        .source("string")
        .tags("string")
        .type("string")
        .user("string")
        .build())
    .ignores(IntegrationActionIgnoreArgs.builder()
        .name("string")
        .filters(IntegrationActionIgnoreFilterArgs.builder()
            .type("string")
            .conditions(IntegrationActionIgnoreFilterConditionArgs.builder()
                .field("string")
                .operation("string")
                .expectedValue("string")
                .key("string")
                .not(false)
                .order(0)
                .build())
            .build())
        .order(0)
        .type("string")
        .build())
    .build());
Copy
integration_action_resource = opsgenie.IntegrationAction("integrationActionResource",
    integration_id="string",
    acknowledges=[{
        "name": "string",
        "alias": "string",
        "filters": [{
            "type": "string",
            "conditions": [{
                "field": "string",
                "operation": "string",
                "expected_value": "string",
                "key": "string",
                "not_": False,
                "order": 0,
            }],
        }],
        "note": "string",
        "order": 0,
        "type": "string",
        "user": "string",
    }],
    add_notes=[{
        "name": "string",
        "alias": "string",
        "filters": [{
            "type": "string",
            "conditions": [{
                "field": "string",
                "operation": "string",
                "expected_value": "string",
                "key": "string",
                "not_": False,
                "order": 0,
            }],
        }],
        "note": "string",
        "order": 0,
        "type": "string",
        "user": "string",
    }],
    closes=[{
        "name": "string",
        "alias": "string",
        "filters": [{
            "type": "string",
            "conditions": [{
                "field": "string",
                "operation": "string",
                "expected_value": "string",
                "key": "string",
                "not_": False,
                "order": 0,
            }],
        }],
        "note": "string",
        "order": 0,
        "type": "string",
        "user": "string",
    }],
    creates=[{
        "name": "string",
        "ignore_responders_from_payload": False,
        "ignore_teams_from_payload": False,
        "custom_priority": "string",
        "description": "string",
        "entity": "string",
        "extra_properties": {
            "string": "string",
        },
        "filters": [{
            "type": "string",
            "conditions": [{
                "field": "string",
                "operation": "string",
                "expected_value": "string",
                "key": "string",
                "not_": False,
                "order": 0,
            }],
        }],
        "ignore_alert_actions_from_payload": False,
        "ignore_extra_properties_from_payload": False,
        "message": "string",
        "append_attachments": False,
        "ignore_tags_from_payload": False,
        "alert_actions": ["string"],
        "alias": "string",
        "note": "string",
        "order": 0,
        "priority": "string",
        "responders": [{
            "id": "string",
            "type": "string",
        }],
        "source": "string",
        "tags": ["string"],
        "type": "string",
        "user": "string",
    }],
    ignores=[{
        "name": "string",
        "filters": [{
            "type": "string",
            "conditions": [{
                "field": "string",
                "operation": "string",
                "expected_value": "string",
                "key": "string",
                "not_": False,
                "order": 0,
            }],
        }],
        "order": 0,
        "type": "string",
    }])
Copy
const integrationActionResource = new opsgenie.IntegrationAction("integrationActionResource", {
    integrationId: "string",
    acknowledges: [{
        name: "string",
        alias: "string",
        filters: [{
            type: "string",
            conditions: [{
                field: "string",
                operation: "string",
                expectedValue: "string",
                key: "string",
                not: false,
                order: 0,
            }],
        }],
        note: "string",
        order: 0,
        type: "string",
        user: "string",
    }],
    addNotes: [{
        name: "string",
        alias: "string",
        filters: [{
            type: "string",
            conditions: [{
                field: "string",
                operation: "string",
                expectedValue: "string",
                key: "string",
                not: false,
                order: 0,
            }],
        }],
        note: "string",
        order: 0,
        type: "string",
        user: "string",
    }],
    closes: [{
        name: "string",
        alias: "string",
        filters: [{
            type: "string",
            conditions: [{
                field: "string",
                operation: "string",
                expectedValue: "string",
                key: "string",
                not: false,
                order: 0,
            }],
        }],
        note: "string",
        order: 0,
        type: "string",
        user: "string",
    }],
    creates: [{
        name: "string",
        ignoreRespondersFromPayload: false,
        ignoreTeamsFromPayload: false,
        customPriority: "string",
        description: "string",
        entity: "string",
        extraProperties: {
            string: "string",
        },
        filters: [{
            type: "string",
            conditions: [{
                field: "string",
                operation: "string",
                expectedValue: "string",
                key: "string",
                not: false,
                order: 0,
            }],
        }],
        ignoreAlertActionsFromPayload: false,
        ignoreExtraPropertiesFromPayload: false,
        message: "string",
        appendAttachments: false,
        ignoreTagsFromPayload: false,
        alertActions: ["string"],
        alias: "string",
        note: "string",
        order: 0,
        priority: "string",
        responders: [{
            id: "string",
            type: "string",
        }],
        source: "string",
        tags: ["string"],
        type: "string",
        user: "string",
    }],
    ignores: [{
        name: "string",
        filters: [{
            type: "string",
            conditions: [{
                field: "string",
                operation: "string",
                expectedValue: "string",
                key: "string",
                not: false,
                order: 0,
            }],
        }],
        order: 0,
        type: "string",
    }],
});
Copy
type: opsgenie:IntegrationAction
properties:
    acknowledges:
        - alias: string
          filters:
            - conditions:
                - expectedValue: string
                  field: string
                  key: string
                  not: false
                  operation: string
                  order: 0
              type: string
          name: string
          note: string
          order: 0
          type: string
          user: string
    addNotes:
        - alias: string
          filters:
            - conditions:
                - expectedValue: string
                  field: string
                  key: string
                  not: false
                  operation: string
                  order: 0
              type: string
          name: string
          note: string
          order: 0
          type: string
          user: string
    closes:
        - alias: string
          filters:
            - conditions:
                - expectedValue: string
                  field: string
                  key: string
                  not: false
                  operation: string
                  order: 0
              type: string
          name: string
          note: string
          order: 0
          type: string
          user: string
    creates:
        - alertActions:
            - string
          alias: string
          appendAttachments: false
          customPriority: string
          description: string
          entity: string
          extraProperties:
            string: string
          filters:
            - conditions:
                - expectedValue: string
                  field: string
                  key: string
                  not: false
                  operation: string
                  order: 0
              type: string
          ignoreAlertActionsFromPayload: false
          ignoreExtraPropertiesFromPayload: false
          ignoreRespondersFromPayload: false
          ignoreTagsFromPayload: false
          ignoreTeamsFromPayload: false
          message: string
          name: string
          note: string
          order: 0
          priority: string
          responders:
            - id: string
              type: string
          source: string
          tags:
            - string
          type: string
          user: string
    ignores:
        - filters:
            - conditions:
                - expectedValue: string
                  field: string
                  key: string
                  not: false
                  operation: string
                  order: 0
              type: string
          name: string
          order: 0
          type: string
    integrationId: string
Copy

IntegrationAction Resource Properties

To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

Inputs

In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

The IntegrationAction resource accepts the following input properties:

Outputs

All input properties are implicitly available as output properties. Additionally, the IntegrationAction resource produces the following output properties:

Id string
The provider-assigned unique ID for this managed resource.
Id string
The provider-assigned unique ID for this managed resource.
id String
The provider-assigned unique ID for this managed resource.
id string
The provider-assigned unique ID for this managed resource.
id str
The provider-assigned unique ID for this managed resource.
id String
The provider-assigned unique ID for this managed resource.

Look up Existing IntegrationAction Resource

Get an existing IntegrationAction resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

public static get(name: string, id: Input<ID>, state?: IntegrationActionState, opts?: CustomResourceOptions): IntegrationAction
@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        acknowledges: Optional[Sequence[IntegrationActionAcknowledgeArgs]] = None,
        add_notes: Optional[Sequence[IntegrationActionAddNoteArgs]] = None,
        closes: Optional[Sequence[IntegrationActionCloseArgs]] = None,
        creates: Optional[Sequence[IntegrationActionCreateArgs]] = None,
        ignores: Optional[Sequence[IntegrationActionIgnoreArgs]] = None,
        integration_id: Optional[str] = None) -> IntegrationAction
func GetIntegrationAction(ctx *Context, name string, id IDInput, state *IntegrationActionState, opts ...ResourceOption) (*IntegrationAction, error)
public static IntegrationAction Get(string name, Input<string> id, IntegrationActionState? state, CustomResourceOptions? opts = null)
public static IntegrationAction get(String name, Output<String> id, IntegrationActionState state, CustomResourceOptions options)
resources:  _:    type: opsgenie:IntegrationAction    get:      id: ${id}
name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
resource_name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
The following state arguments are supported:

Supporting Types

IntegrationActionAcknowledge
, IntegrationActionAcknowledgeArgs

Name This property is required. string
Name of the integration action.
Alias string
An identifier that is used for alert deduplication. Default: {{alias}}.
Filters List<IntegrationActionAcknowledgeFilter>
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
Note string
Additional alert action note.
Order int
Integer value that defines in which order the action will be performed. Default: 1.
Type string
The responder type - can be escalation, team or user.
User string
Owner of the execution for integration action.
Name This property is required. string
Name of the integration action.
Alias string
An identifier that is used for alert deduplication. Default: {{alias}}.
Filters []IntegrationActionAcknowledgeFilter
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
Note string
Additional alert action note.
Order int
Integer value that defines in which order the action will be performed. Default: 1.
Type string
The responder type - can be escalation, team or user.
User string
Owner of the execution for integration action.
name This property is required. String
Name of the integration action.
alias String
An identifier that is used for alert deduplication. Default: {{alias}}.
filters List<IntegrationActionAcknowledgeFilter>
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
note String
Additional alert action note.
order Integer
Integer value that defines in which order the action will be performed. Default: 1.
type String
The responder type - can be escalation, team or user.
user String
Owner of the execution for integration action.
name This property is required. string
Name of the integration action.
alias string
An identifier that is used for alert deduplication. Default: {{alias}}.
filters IntegrationActionAcknowledgeFilter[]
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
note string
Additional alert action note.
order number
Integer value that defines in which order the action will be performed. Default: 1.
type string
The responder type - can be escalation, team or user.
user string
Owner of the execution for integration action.
name This property is required. str
Name of the integration action.
alias str
An identifier that is used for alert deduplication. Default: {{alias}}.
filters Sequence[IntegrationActionAcknowledgeFilter]
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
note str
Additional alert action note.
order int
Integer value that defines in which order the action will be performed. Default: 1.
type str
The responder type - can be escalation, team or user.
user str
Owner of the execution for integration action.
name This property is required. String
Name of the integration action.
alias String
An identifier that is used for alert deduplication. Default: {{alias}}.
filters List<Property Map>
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
note String
Additional alert action note.
order Number
Integer value that defines in which order the action will be performed. Default: 1.
type String
The responder type - can be escalation, team or user.
user String
Owner of the execution for integration action.

IntegrationActionAcknowledgeFilter
, IntegrationActionAcknowledgeFilterArgs

Type This property is required. string
The responder type - can be escalation, team or user.
Conditions List<IntegrationActionAcknowledgeFilterCondition>
Type This property is required. string
The responder type - can be escalation, team or user.
Conditions []IntegrationActionAcknowledgeFilterCondition
type This property is required. String
The responder type - can be escalation, team or user.
conditions List<IntegrationActionAcknowledgeFilterCondition>
type This property is required. string
The responder type - can be escalation, team or user.
conditions IntegrationActionAcknowledgeFilterCondition[]
type This property is required. str
The responder type - can be escalation, team or user.
conditions Sequence[IntegrationActionAcknowledgeFilterCondition]
type This property is required. String
The responder type - can be escalation, team or user.
conditions List<Property Map>

IntegrationActionAcknowledgeFilterCondition
, IntegrationActionAcknowledgeFilterConditionArgs

Field This property is required. string
Operation This property is required. string
ExpectedValue string
Key string
Not bool
Order int
Integer value that defines in which order the action will be performed. Default: 1.
Field This property is required. string
Operation This property is required. string
ExpectedValue string
Key string
Not bool
Order int
Integer value that defines in which order the action will be performed. Default: 1.
field This property is required. String
operation This property is required. String
expectedValue String
key String
not Boolean
order Integer
Integer value that defines in which order the action will be performed. Default: 1.
field This property is required. string
operation This property is required. string
expectedValue string
key string
not boolean
order number
Integer value that defines in which order the action will be performed. Default: 1.
field This property is required. str
operation This property is required. str
expected_value str
key str
not_ bool
order int
Integer value that defines in which order the action will be performed. Default: 1.
field This property is required. String
operation This property is required. String
expectedValue String
key String
not Boolean
order Number
Integer value that defines in which order the action will be performed. Default: 1.

IntegrationActionAddNote
, IntegrationActionAddNoteArgs

Name This property is required. string
Name of the integration action.
Alias string
An identifier that is used for alert deduplication. Default: {{alias}}.
Filters List<IntegrationActionAddNoteFilter>
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
Note string
Additional alert action note.
Order int
Integer value that defines in which order the action will be performed. Default: 1.
Type string
The responder type - can be escalation, team or user.
User string
Owner of the execution for integration action.
Name This property is required. string
Name of the integration action.
Alias string
An identifier that is used for alert deduplication. Default: {{alias}}.
Filters []IntegrationActionAddNoteFilter
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
Note string
Additional alert action note.
Order int
Integer value that defines in which order the action will be performed. Default: 1.
Type string
The responder type - can be escalation, team or user.
User string
Owner of the execution for integration action.
name This property is required. String
Name of the integration action.
alias String
An identifier that is used for alert deduplication. Default: {{alias}}.
filters List<IntegrationActionAddNoteFilter>
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
note String
Additional alert action note.
order Integer
Integer value that defines in which order the action will be performed. Default: 1.
type String
The responder type - can be escalation, team or user.
user String
Owner of the execution for integration action.
name This property is required. string
Name of the integration action.
alias string
An identifier that is used for alert deduplication. Default: {{alias}}.
filters IntegrationActionAddNoteFilter[]
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
note string
Additional alert action note.
order number
Integer value that defines in which order the action will be performed. Default: 1.
type string
The responder type - can be escalation, team or user.
user string
Owner of the execution for integration action.
name This property is required. str
Name of the integration action.
alias str
An identifier that is used for alert deduplication. Default: {{alias}}.
filters Sequence[IntegrationActionAddNoteFilter]
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
note str
Additional alert action note.
order int
Integer value that defines in which order the action will be performed. Default: 1.
type str
The responder type - can be escalation, team or user.
user str
Owner of the execution for integration action.
name This property is required. String
Name of the integration action.
alias String
An identifier that is used for alert deduplication. Default: {{alias}}.
filters List<Property Map>
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
note String
Additional alert action note.
order Number
Integer value that defines in which order the action will be performed. Default: 1.
type String
The responder type - can be escalation, team or user.
user String
Owner of the execution for integration action.

IntegrationActionAddNoteFilter
, IntegrationActionAddNoteFilterArgs

Type This property is required. string
The responder type - can be escalation, team or user.
Conditions List<IntegrationActionAddNoteFilterCondition>
Type This property is required. string
The responder type - can be escalation, team or user.
Conditions []IntegrationActionAddNoteFilterCondition
type This property is required. String
The responder type - can be escalation, team or user.
conditions List<IntegrationActionAddNoteFilterCondition>
type This property is required. string
The responder type - can be escalation, team or user.
conditions IntegrationActionAddNoteFilterCondition[]
type This property is required. str
The responder type - can be escalation, team or user.
conditions Sequence[IntegrationActionAddNoteFilterCondition]
type This property is required. String
The responder type - can be escalation, team or user.
conditions List<Property Map>

IntegrationActionAddNoteFilterCondition
, IntegrationActionAddNoteFilterConditionArgs

Field This property is required. string
Operation This property is required. string
ExpectedValue string
Key string
Not bool
Order int
Integer value that defines in which order the action will be performed. Default: 1.
Field This property is required. string
Operation This property is required. string
ExpectedValue string
Key string
Not bool
Order int
Integer value that defines in which order the action will be performed. Default: 1.
field This property is required. String
operation This property is required. String
expectedValue String
key String
not Boolean
order Integer
Integer value that defines in which order the action will be performed. Default: 1.
field This property is required. string
operation This property is required. string
expectedValue string
key string
not boolean
order number
Integer value that defines in which order the action will be performed. Default: 1.
field This property is required. str
operation This property is required. str
expected_value str
key str
not_ bool
order int
Integer value that defines in which order the action will be performed. Default: 1.
field This property is required. String
operation This property is required. String
expectedValue String
key String
not Boolean
order Number
Integer value that defines in which order the action will be performed. Default: 1.

IntegrationActionClose
, IntegrationActionCloseArgs

Name This property is required. string
Name of the integration action.
Alias string
An identifier that is used for alert deduplication. Default: {{alias}}.
Filters List<IntegrationActionCloseFilter>
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
Note string
Additional alert action note.
Order int
Integer value that defines in which order the action will be performed. Default: 1.
Type string
The responder type - can be escalation, team or user.
User string
Owner of the execution for integration action.
Name This property is required. string
Name of the integration action.
Alias string
An identifier that is used for alert deduplication. Default: {{alias}}.
Filters []IntegrationActionCloseFilter
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
Note string
Additional alert action note.
Order int
Integer value that defines in which order the action will be performed. Default: 1.
Type string
The responder type - can be escalation, team or user.
User string
Owner of the execution for integration action.
name This property is required. String
Name of the integration action.
alias String
An identifier that is used for alert deduplication. Default: {{alias}}.
filters List<IntegrationActionCloseFilter>
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
note String
Additional alert action note.
order Integer
Integer value that defines in which order the action will be performed. Default: 1.
type String
The responder type - can be escalation, team or user.
user String
Owner of the execution for integration action.
name This property is required. string
Name of the integration action.
alias string
An identifier that is used for alert deduplication. Default: {{alias}}.
filters IntegrationActionCloseFilter[]
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
note string
Additional alert action note.
order number
Integer value that defines in which order the action will be performed. Default: 1.
type string
The responder type - can be escalation, team or user.
user string
Owner of the execution for integration action.
name This property is required. str
Name of the integration action.
alias str
An identifier that is used for alert deduplication. Default: {{alias}}.
filters Sequence[IntegrationActionCloseFilter]
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
note str
Additional alert action note.
order int
Integer value that defines in which order the action will be performed. Default: 1.
type str
The responder type - can be escalation, team or user.
user str
Owner of the execution for integration action.
name This property is required. String
Name of the integration action.
alias String
An identifier that is used for alert deduplication. Default: {{alias}}.
filters List<Property Map>
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
note String
Additional alert action note.
order Number
Integer value that defines in which order the action will be performed. Default: 1.
type String
The responder type - can be escalation, team or user.
user String
Owner of the execution for integration action.

IntegrationActionCloseFilter
, IntegrationActionCloseFilterArgs

Type This property is required. string
The responder type - can be escalation, team or user.
Conditions List<IntegrationActionCloseFilterCondition>
Type This property is required. string
The responder type - can be escalation, team or user.
Conditions []IntegrationActionCloseFilterCondition
type This property is required. String
The responder type - can be escalation, team or user.
conditions List<IntegrationActionCloseFilterCondition>
type This property is required. string
The responder type - can be escalation, team or user.
conditions IntegrationActionCloseFilterCondition[]
type This property is required. str
The responder type - can be escalation, team or user.
conditions Sequence[IntegrationActionCloseFilterCondition]
type This property is required. String
The responder type - can be escalation, team or user.
conditions List<Property Map>

IntegrationActionCloseFilterCondition
, IntegrationActionCloseFilterConditionArgs

Field This property is required. string
Operation This property is required. string
ExpectedValue string
Key string
Not bool
Order int
Integer value that defines in which order the action will be performed. Default: 1.
Field This property is required. string
Operation This property is required. string
ExpectedValue string
Key string
Not bool
Order int
Integer value that defines in which order the action will be performed. Default: 1.
field This property is required. String
operation This property is required. String
expectedValue String
key String
not Boolean
order Integer
Integer value that defines in which order the action will be performed. Default: 1.
field This property is required. string
operation This property is required. string
expectedValue string
key string
not boolean
order number
Integer value that defines in which order the action will be performed. Default: 1.
field This property is required. str
operation This property is required. str
expected_value str
key str
not_ bool
order int
Integer value that defines in which order the action will be performed. Default: 1.
field This property is required. String
operation This property is required. String
expectedValue String
key String
not Boolean
order Number
Integer value that defines in which order the action will be performed. Default: 1.

IntegrationActionCreate
, IntegrationActionCreateArgs

Name This property is required. string
Name of the integration action.
AlertActions List<string>
Alias string
An identifier that is used for alert deduplication. Default: {{alias}}.
AppendAttachments bool
CustomPriority string
Custom alert priority. e.g. {{message.substring(0,2)}}
Description string
Detailed description of the alert, anything that may not have fit in the message field.
Entity string
The entity the alert is related to.
ExtraProperties Dictionary<string, string>
Set of user defined properties specified as a map.
Filters List<IntegrationActionCreateFilter>
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
IgnoreAlertActionsFromPayload bool
IgnoreExtraPropertiesFromPayload bool
IgnoreRespondersFromPayload bool
If enabled, the integration will ignore responders sent in request payloads.
IgnoreTagsFromPayload bool
IgnoreTeamsFromPayload bool
If enabled, the integration will ignore teams sent in request payloads.
Message string
Alert text limited to 130 characters.
Note string
Additional alert action note.
Order int
Integer value that defines in which order the action will be performed. Default: 1.
Priority string
Alert priority.
Responders List<IntegrationActionCreateResponder>
User, schedule, teams or escalation names to calculate which users will receive notifications of the alert.
Source string
User defined field to specify source of action.
Tags List<string>
Comma separated list of labels to be attached to the alert.
Type string
The responder type - can be escalation, team or user.
User string
Owner of the execution for integration action.
Name This property is required. string
Name of the integration action.
AlertActions []string
Alias string
An identifier that is used for alert deduplication. Default: {{alias}}.
AppendAttachments bool
CustomPriority string
Custom alert priority. e.g. {{message.substring(0,2)}}
Description string
Detailed description of the alert, anything that may not have fit in the message field.
Entity string
The entity the alert is related to.
ExtraProperties map[string]string
Set of user defined properties specified as a map.
Filters []IntegrationActionCreateFilter
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
IgnoreAlertActionsFromPayload bool
IgnoreExtraPropertiesFromPayload bool
IgnoreRespondersFromPayload bool
If enabled, the integration will ignore responders sent in request payloads.
IgnoreTagsFromPayload bool
IgnoreTeamsFromPayload bool
If enabled, the integration will ignore teams sent in request payloads.
Message string
Alert text limited to 130 characters.
Note string
Additional alert action note.
Order int
Integer value that defines in which order the action will be performed. Default: 1.
Priority string
Alert priority.
Responders []IntegrationActionCreateResponder
User, schedule, teams or escalation names to calculate which users will receive notifications of the alert.
Source string
User defined field to specify source of action.
Tags []string
Comma separated list of labels to be attached to the alert.
Type string
The responder type - can be escalation, team or user.
User string
Owner of the execution for integration action.
name This property is required. String
Name of the integration action.
alertActions List<String>
alias String
An identifier that is used for alert deduplication. Default: {{alias}}.
appendAttachments Boolean
customPriority String
Custom alert priority. e.g. {{message.substring(0,2)}}
description String
Detailed description of the alert, anything that may not have fit in the message field.
entity String
The entity the alert is related to.
extraProperties Map<String,String>
Set of user defined properties specified as a map.
filters List<IntegrationActionCreateFilter>
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
ignoreAlertActionsFromPayload Boolean
ignoreExtraPropertiesFromPayload Boolean
ignoreRespondersFromPayload Boolean
If enabled, the integration will ignore responders sent in request payloads.
ignoreTagsFromPayload Boolean
ignoreTeamsFromPayload Boolean
If enabled, the integration will ignore teams sent in request payloads.
message String
Alert text limited to 130 characters.
note String
Additional alert action note.
order Integer
Integer value that defines in which order the action will be performed. Default: 1.
priority String
Alert priority.
responders List<IntegrationActionCreateResponder>
User, schedule, teams or escalation names to calculate which users will receive notifications of the alert.
source String
User defined field to specify source of action.
tags List<String>
Comma separated list of labels to be attached to the alert.
type String
The responder type - can be escalation, team or user.
user String
Owner of the execution for integration action.
name This property is required. string
Name of the integration action.
alertActions string[]
alias string
An identifier that is used for alert deduplication. Default: {{alias}}.
appendAttachments boolean
customPriority string
Custom alert priority. e.g. {{message.substring(0,2)}}
description string
Detailed description of the alert, anything that may not have fit in the message field.
entity string
The entity the alert is related to.
extraProperties {[key: string]: string}
Set of user defined properties specified as a map.
filters IntegrationActionCreateFilter[]
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
ignoreAlertActionsFromPayload boolean
ignoreExtraPropertiesFromPayload boolean
ignoreRespondersFromPayload boolean
If enabled, the integration will ignore responders sent in request payloads.
ignoreTagsFromPayload boolean
ignoreTeamsFromPayload boolean
If enabled, the integration will ignore teams sent in request payloads.
message string
Alert text limited to 130 characters.
note string
Additional alert action note.
order number
Integer value that defines in which order the action will be performed. Default: 1.
priority string
Alert priority.
responders IntegrationActionCreateResponder[]
User, schedule, teams or escalation names to calculate which users will receive notifications of the alert.
source string
User defined field to specify source of action.
tags string[]
Comma separated list of labels to be attached to the alert.
type string
The responder type - can be escalation, team or user.
user string
Owner of the execution for integration action.
name This property is required. str
Name of the integration action.
alert_actions Sequence[str]
alias str
An identifier that is used for alert deduplication. Default: {{alias}}.
append_attachments bool
custom_priority str
Custom alert priority. e.g. {{message.substring(0,2)}}
description str
Detailed description of the alert, anything that may not have fit in the message field.
entity str
The entity the alert is related to.
extra_properties Mapping[str, str]
Set of user defined properties specified as a map.
filters Sequence[IntegrationActionCreateFilter]
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
ignore_alert_actions_from_payload bool
ignore_extra_properties_from_payload bool
ignore_responders_from_payload bool
If enabled, the integration will ignore responders sent in request payloads.
ignore_tags_from_payload bool
ignore_teams_from_payload bool
If enabled, the integration will ignore teams sent in request payloads.
message str
Alert text limited to 130 characters.
note str
Additional alert action note.
order int
Integer value that defines in which order the action will be performed. Default: 1.
priority str
Alert priority.
responders Sequence[IntegrationActionCreateResponder]
User, schedule, teams or escalation names to calculate which users will receive notifications of the alert.
source str
User defined field to specify source of action.
tags Sequence[str]
Comma separated list of labels to be attached to the alert.
type str
The responder type - can be escalation, team or user.
user str
Owner of the execution for integration action.
name This property is required. String
Name of the integration action.
alertActions List<String>
alias String
An identifier that is used for alert deduplication. Default: {{alias}}.
appendAttachments Boolean
customPriority String
Custom alert priority. e.g. {{message.substring(0,2)}}
description String
Detailed description of the alert, anything that may not have fit in the message field.
entity String
The entity the alert is related to.
extraProperties Map<String>
Set of user defined properties specified as a map.
filters List<Property Map>
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
ignoreAlertActionsFromPayload Boolean
ignoreExtraPropertiesFromPayload Boolean
ignoreRespondersFromPayload Boolean
If enabled, the integration will ignore responders sent in request payloads.
ignoreTagsFromPayload Boolean
ignoreTeamsFromPayload Boolean
If enabled, the integration will ignore teams sent in request payloads.
message String
Alert text limited to 130 characters.
note String
Additional alert action note.
order Number
Integer value that defines in which order the action will be performed. Default: 1.
priority String
Alert priority.
responders List<Property Map>
User, schedule, teams or escalation names to calculate which users will receive notifications of the alert.
source String
User defined field to specify source of action.
tags List<String>
Comma separated list of labels to be attached to the alert.
type String
The responder type - can be escalation, team or user.
user String
Owner of the execution for integration action.

IntegrationActionCreateFilter
, IntegrationActionCreateFilterArgs

Type This property is required. string
The responder type - can be escalation, team or user.
Conditions List<IntegrationActionCreateFilterCondition>
Type This property is required. string
The responder type - can be escalation, team or user.
Conditions []IntegrationActionCreateFilterCondition
type This property is required. String
The responder type - can be escalation, team or user.
conditions List<IntegrationActionCreateFilterCondition>
type This property is required. string
The responder type - can be escalation, team or user.
conditions IntegrationActionCreateFilterCondition[]
type This property is required. str
The responder type - can be escalation, team or user.
conditions Sequence[IntegrationActionCreateFilterCondition]
type This property is required. String
The responder type - can be escalation, team or user.
conditions List<Property Map>

IntegrationActionCreateFilterCondition
, IntegrationActionCreateFilterConditionArgs

Field This property is required. string
Operation This property is required. string
ExpectedValue string
Key string
Not bool
Order int
Integer value that defines in which order the action will be performed. Default: 1.
Field This property is required. string
Operation This property is required. string
ExpectedValue string
Key string
Not bool
Order int
Integer value that defines in which order the action will be performed. Default: 1.
field This property is required. String
operation This property is required. String
expectedValue String
key String
not Boolean
order Integer
Integer value that defines in which order the action will be performed. Default: 1.
field This property is required. string
operation This property is required. string
expectedValue string
key string
not boolean
order number
Integer value that defines in which order the action will be performed. Default: 1.
field This property is required. str
operation This property is required. str
expected_value str
key str
not_ bool
order int
Integer value that defines in which order the action will be performed. Default: 1.
field This property is required. String
operation This property is required. String
expectedValue String
key String
not Boolean
order Number
Integer value that defines in which order the action will be performed. Default: 1.

IntegrationActionCreateResponder
, IntegrationActionCreateResponderArgs

Id This property is required. string
The id of the responder.
Type This property is required. string
The responder type - can be escalation, team or user.
Id This property is required. string
The id of the responder.
Type This property is required. string
The responder type - can be escalation, team or user.
id This property is required. String
The id of the responder.
type This property is required. String
The responder type - can be escalation, team or user.
id This property is required. string
The id of the responder.
type This property is required. string
The responder type - can be escalation, team or user.
id This property is required. str
The id of the responder.
type This property is required. str
The responder type - can be escalation, team or user.
id This property is required. String
The id of the responder.
type This property is required. String
The responder type - can be escalation, team or user.

IntegrationActionIgnore
, IntegrationActionIgnoreArgs

Name This property is required. string
Name of the integration action.
Filters List<IntegrationActionIgnoreFilter>
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
Order int
Integer value that defines in which order the action will be performed. Default: 1.
Type string
The responder type - can be escalation, team or user.
Name This property is required. string
Name of the integration action.
Filters []IntegrationActionIgnoreFilter
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
Order int
Integer value that defines in which order the action will be performed. Default: 1.
Type string
The responder type - can be escalation, team or user.
name This property is required. String
Name of the integration action.
filters List<IntegrationActionIgnoreFilter>
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
order Integer
Integer value that defines in which order the action will be performed. Default: 1.
type String
The responder type - can be escalation, team or user.
name This property is required. string
Name of the integration action.
filters IntegrationActionIgnoreFilter[]
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
order number
Integer value that defines in which order the action will be performed. Default: 1.
type string
The responder type - can be escalation, team or user.
name This property is required. str
Name of the integration action.
filters Sequence[IntegrationActionIgnoreFilter]
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
order int
Integer value that defines in which order the action will be performed. Default: 1.
type str
The responder type - can be escalation, team or user.
name This property is required. String
Name of the integration action.
filters List<Property Map>
Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

  • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
  • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
  • For Email integration: from_address, from_name, conversationSubject, subject
order Number
Integer value that defines in which order the action will be performed. Default: 1.
type String
The responder type - can be escalation, team or user.

IntegrationActionIgnoreFilter
, IntegrationActionIgnoreFilterArgs

Type This property is required. string
The responder type - can be escalation, team or user.
Conditions List<IntegrationActionIgnoreFilterCondition>
Type This property is required. string
The responder type - can be escalation, team or user.
Conditions []IntegrationActionIgnoreFilterCondition
type This property is required. String
The responder type - can be escalation, team or user.
conditions List<IntegrationActionIgnoreFilterCondition>
type This property is required. string
The responder type - can be escalation, team or user.
conditions IntegrationActionIgnoreFilterCondition[]
type This property is required. str
The responder type - can be escalation, team or user.
conditions Sequence[IntegrationActionIgnoreFilterCondition]
type This property is required. String
The responder type - can be escalation, team or user.
conditions List<Property Map>

IntegrationActionIgnoreFilterCondition
, IntegrationActionIgnoreFilterConditionArgs

Field This property is required. string
Operation This property is required. string
ExpectedValue string
Key string
Not bool
Order int
Integer value that defines in which order the action will be performed. Default: 1.
Field This property is required. string
Operation This property is required. string
ExpectedValue string
Key string
Not bool
Order int
Integer value that defines in which order the action will be performed. Default: 1.
field This property is required. String
operation This property is required. String
expectedValue String
key String
not Boolean
order Integer
Integer value that defines in which order the action will be performed. Default: 1.
field This property is required. string
operation This property is required. string
expectedValue string
key string
not boolean
order number
Integer value that defines in which order the action will be performed. Default: 1.
field This property is required. str
operation This property is required. str
expected_value str
key str
not_ bool
order int
Integer value that defines in which order the action will be performed. Default: 1.
field This property is required. String
operation This property is required. String
expectedValue String
key String
not Boolean
order Number
Integer value that defines in which order the action will be performed. Default: 1.

Package Details

Repository
Opsgenie pulumi/pulumi-opsgenie
License
Apache-2.0
Notes
This Pulumi package is based on the opsgenie Terraform Provider.