1. Packages
  2. Datadog Provider
  3. API Docs
  4. MonitorNotificationRule
Viewing docs for Datadog v4.68.0
published on Wednesday, Feb 25, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-datadog

datadog.MonitorNotificationRule

datadog logo
Viewing docs for Datadog v4.68.0
published on Wednesday, Feb 25, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-datadog

    Provides a Datadog MonitorNotificationRule resource.

    Example Usage

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

const teamCheckoutNotificationRule = new datadog.MonitorNotificationRule("team_checkout_notification_rule", {
    name: "Route alerts from checkout team",
    recipients: [
        "slack-checkout-ops",
        "jira-checkout",
    ],
    filter: [{
        tags: ["team:payment"],
    }],
});
const teamPaymentNotificationRule = new datadog.MonitorNotificationRule("team_payment_notification_rule", {
    name: "Routing logic for team payment",
    filter: [{
        scope: "team:payment AND NOT env:dev AND service:(payment-processing OR payment-gateway)",
    }],
    conditionalRecipients: [{
        conditions: [
            {
                scope: "priority:p1",
                recipients: [
                    "oncall-payment",
                    "slack-payment",
                ],
            },
            {
                scope: "priority:p5",
                recipients: ["slack-payment"],
            },
        ],
        fallbackRecipients: ["slack-payment"],
    }],
});

    import pulumi
import pulumi_datadog as datadog

team_checkout_notification_rule = datadog.MonitorNotificationRule("team_checkout_notification_rule",
    name="Route alerts from checkout team",
    recipients=[
        "slack-checkout-ops",
        "jira-checkout",
    ],
    filter=[{
        "tags": ["team:payment"],
    }])
team_payment_notification_rule = datadog.MonitorNotificationRule("team_payment_notification_rule",
    name="Routing logic for team payment",
    filter=[{
        "scope": "team:payment AND NOT env:dev AND service:(payment-processing OR payment-gateway)",
    }],
    conditional_recipients=[{
        "conditions": [
            {
                "scope": "priority:p1",
                "recipients": [
                    "oncall-payment",
                    "slack-payment",
                ],
            },
            {
                "scope": "priority:p5",
                "recipients": ["slack-payment"],
            },
        ],
        "fallbackRecipients": ["slack-payment"],
    }])

    package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := datadog.NewMonitorNotificationRule(ctx, "team_checkout_notification_rule", &datadog.MonitorNotificationRuleArgs{
			Name: pulumi.String("Route alerts from checkout team"),
			Recipients: pulumi.StringArray{
				pulumi.String("slack-checkout-ops"),
				pulumi.String("jira-checkout"),
			},
			Filter: datadog.MonitorNotificationRuleFilterArgs{
				map[string]interface{}{
					"tags": []string{
						"team:payment",
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = datadog.NewMonitorNotificationRule(ctx, "team_payment_notification_rule", &datadog.MonitorNotificationRuleArgs{
			Name: pulumi.String("Routing logic for team payment"),
			Filter: datadog.MonitorNotificationRuleFilterArgs{
				map[string]interface{}{
					"scope": "team:payment AND NOT env:dev AND service:(payment-processing OR payment-gateway)",
				},
			},
			ConditionalRecipients: datadog.MonitorNotificationRuleConditionalRecipientsArgs{
				map[string]interface{}{
					"conditions": []interface{}{
						map[string]interface{}{
							"scope": "priority:p1",
							"recipients": []string{
								"oncall-payment",
								"slack-payment",
							},
						},
						map[string]interface{}{
							"scope": "priority:p5",
							"recipients": []string{
								"slack-payment",
							},
						},
					},
					"fallbackRecipients": []string{
						"slack-payment",
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var teamCheckoutNotificationRule = new Datadog.MonitorNotificationRule("team_checkout_notification_rule", new()
    {
        Name = "Route alerts from checkout team",
        Recipients = new[]
        {
            "slack-checkout-ops",
            "jira-checkout",
        },
        Filter = new[]
        {
            
            {
                { "tags", new[]
                {
                    "team:payment",
                } },
            },
        },
    });

    var teamPaymentNotificationRule = new Datadog.MonitorNotificationRule("team_payment_notification_rule", new()
    {
        Name = "Routing logic for team payment",
        Filter = new[]
        {
            
            {
                { "scope", "team:payment AND NOT env:dev AND service:(payment-processing OR payment-gateway)" },
            },
        },
        ConditionalRecipients = new[]
        {
            
            {
                { "conditions", new[]
                {
                    
                    {
                        { "scope", "priority:p1" },
                        { "recipients", new[]
                        {
                            "oncall-payment",
                            "slack-payment",
                        } },
                    },
                    
                    {
                        { "scope", "priority:p5" },
                        { "recipients", new[]
                        {
                            "slack-payment",
                        } },
                    },
                } },
                { "fallbackRecipients", new[]
                {
                    "slack-payment",
                } },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.datadog.MonitorNotificationRule;
import com.pulumi.datadog.MonitorNotificationRuleArgs;
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 teamCheckoutNotificationRule = new MonitorNotificationRule("teamCheckoutNotificationRule", MonitorNotificationRuleArgs.builder()
            .name("Route alerts from checkout team")
            .recipients(            
                "slack-checkout-ops",
                "jira-checkout")
            .filter(MonitorNotificationRuleFilterArgs.builder()
                .tags("team:payment")
                .build())
            .build());

        var teamPaymentNotificationRule = new MonitorNotificationRule("teamPaymentNotificationRule", MonitorNotificationRuleArgs.builder()
            .name("Routing logic for team payment")
            .filter(MonitorNotificationRuleFilterArgs.builder()
                .scope("team:payment AND NOT env:dev AND service:(payment-processing OR payment-gateway)")
                .build())
            .conditionalRecipients(MonitorNotificationRuleConditionalRecipientsArgs.builder()
                .conditions(                
                    MonitorNotificationRuleConditionalRecipientsConditionArgs.builder()
                        .scope("priority:p1")
                        .recipients(                        
                            "oncall-payment",
                            "slack-payment")
                        .build(),
                    MonitorNotificationRuleConditionalRecipientsConditionArgs.builder()
                        .scope("priority:p5")
                        .recipients("slack-payment")
                        .build())
                .fallbackRecipients("slack-payment")
                .build())
            .build());

    }
}

    resources:
  teamCheckoutNotificationRule:
    type: datadog:MonitorNotificationRule
    name: team_checkout_notification_rule
    properties:
      name: Route alerts from checkout team
      recipients:
        - slack-checkout-ops
        - jira-checkout
      filter:
        - tags:
            - team:payment
  teamPaymentNotificationRule:
    type: datadog:MonitorNotificationRule
    name: team_payment_notification_rule
    properties:
      name: Routing logic for team payment
      filter:
        - scope: team:payment AND NOT env:dev AND service:(payment-processing OR payment-gateway)
      conditionalRecipients:
        - conditions:
            - scope: priority:p1
              recipients:
                - oncall-payment
                - slack-payment
            - scope: priority:p5
              recipients:
                - slack-payment
          fallbackRecipients:
            - slack-payment

    Create MonitorNotificationRule Resource

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

    Constructor syntax

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

@overload
def MonitorNotificationRule(resource_name: str,
                            opts: Optional[ResourceOptions] = None,
                            filter: Optional[MonitorNotificationRuleFilterArgs] = None,
                            name: Optional[str] = None,
                            conditional_recipients: Optional[MonitorNotificationRuleConditionalRecipientsArgs] = None,
                            recipients: Optional[Sequence[str]] = None)
    func NewMonitorNotificationRule(ctx *Context, name string, args MonitorNotificationRuleArgs, opts ...ResourceOption) (*MonitorNotificationRule, error)
    public MonitorNotificationRule(string name, MonitorNotificationRuleArgs args, CustomResourceOptions? opts = null)
    public MonitorNotificationRule(String name, MonitorNotificationRuleArgs args)
public MonitorNotificationRule(String name, MonitorNotificationRuleArgs args, CustomResourceOptions options)

    type: datadog:MonitorNotificationRule
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args MonitorNotificationRuleArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args MonitorNotificationRuleArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args MonitorNotificationRuleArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args MonitorNotificationRuleArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args MonitorNotificationRuleArgs
    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 monitorNotificationRuleResource = new Datadog.MonitorNotificationRule("monitorNotificationRuleResource", new()
{
    Filter = new Datadog.Inputs.MonitorNotificationRuleFilterArgs
    {
        Scope = "string",
        Tags = new[]
        {
            "string",
        },
    },
    Name = "string",
    ConditionalRecipients = new Datadog.Inputs.MonitorNotificationRuleConditionalRecipientsArgs
    {
        Conditions = new[]
        {
            new Datadog.Inputs.MonitorNotificationRuleConditionalRecipientsConditionArgs
            {
                Recipients = new[]
                {
                    "string",
                },
                Scope = "string",
            },
        },
        FallbackRecipients = new[]
        {
            "string",
        },
    },
    Recipients = new[]
    {
        "string",
    },
});

    example, err := datadog.NewMonitorNotificationRule(ctx, "monitorNotificationRuleResource", &datadog.MonitorNotificationRuleArgs{
	Filter: &datadog.MonitorNotificationRuleFilterArgs{
		Scope: pulumi.String("string"),
		Tags: pulumi.StringArray{
			pulumi.String("string"),
		},
	},
	Name: pulumi.String("string"),
	ConditionalRecipients: &datadog.MonitorNotificationRuleConditionalRecipientsArgs{
		Conditions: datadog.MonitorNotificationRuleConditionalRecipientsConditionArray{
			&datadog.MonitorNotificationRuleConditionalRecipientsConditionArgs{
				Recipients: pulumi.StringArray{
					pulumi.String("string"),
				},
				Scope: pulumi.String("string"),
			},
		},
		FallbackRecipients: pulumi.StringArray{
			pulumi.String("string"),
		},
	},
	Recipients: pulumi.StringArray{
		pulumi.String("string"),
	},
})

    var monitorNotificationRuleResource = new MonitorNotificationRule("monitorNotificationRuleResource", MonitorNotificationRuleArgs.builder()
    .filter(MonitorNotificationRuleFilterArgs.builder()
        .scope("string")
        .tags("string")
        .build())
    .name("string")
    .conditionalRecipients(MonitorNotificationRuleConditionalRecipientsArgs.builder()
        .conditions(MonitorNotificationRuleConditionalRecipientsConditionArgs.builder()
            .recipients("string")
            .scope("string")
            .build())
        .fallbackRecipients("string")
        .build())
    .recipients("string")
    .build());

    monitor_notification_rule_resource = datadog.MonitorNotificationRule("monitorNotificationRuleResource",
    filter={
        "scope": "string",
        "tags": ["string"],
    },
    name="string",
    conditional_recipients={
        "conditions": [{
            "recipients": ["string"],
            "scope": "string",
        }],
        "fallback_recipients": ["string"],
    },
    recipients=["string"])

    const monitorNotificationRuleResource = new datadog.MonitorNotificationRule("monitorNotificationRuleResource", {
    filter: {
        scope: "string",
        tags: ["string"],
    },
    name: "string",
    conditionalRecipients: {
        conditions: [{
            recipients: ["string"],
            scope: "string",
        }],
        fallbackRecipients: ["string"],
    },
    recipients: ["string"],
});

    type: datadog:MonitorNotificationRule
properties:
    conditionalRecipients:
        conditions:
            - recipients:
                - string
              scope: string
        fallbackRecipients:
            - string
    filter:
        scope: string
        tags:
            - string
    name: string
    recipients:
        - string

    MonitorNotificationRule 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 MonitorNotificationRule resource accepts the following input properties:

    Filter MonitorNotificationRuleFilter
    Specifies the matching criteria for monitor notifications.
    Name string
    The name of the monitor notification rule.
    ConditionalRecipients MonitorNotificationRuleConditionalRecipients
    Use conditional recipients to define different recipients for different situations. Cannot be used with recipients.
    Recipients List<string>
    List of recipients to notify. Cannot be used with conditional_recipients.
    Filter MonitorNotificationRuleFilterArgs
    Specifies the matching criteria for monitor notifications.
    Name string
    The name of the monitor notification rule.
    ConditionalRecipients MonitorNotificationRuleConditionalRecipientsArgs
    Use conditional recipients to define different recipients for different situations. Cannot be used with recipients.
    Recipients []string
    List of recipients to notify. Cannot be used with conditional_recipients.
    filter MonitorNotificationRuleFilter
    Specifies the matching criteria for monitor notifications.
    name String
    The name of the monitor notification rule.
    conditionalRecipients MonitorNotificationRuleConditionalRecipients
    Use conditional recipients to define different recipients for different situations. Cannot be used with recipients.
    recipients List<String>
    List of recipients to notify. Cannot be used with conditional_recipients.
    filter MonitorNotificationRuleFilter
    Specifies the matching criteria for monitor notifications.
    name string
    The name of the monitor notification rule.
    conditionalRecipients MonitorNotificationRuleConditionalRecipients
    Use conditional recipients to define different recipients for different situations. Cannot be used with recipients.
    recipients string[]
    List of recipients to notify. Cannot be used with conditional_recipients.
    filter MonitorNotificationRuleFilterArgs
    Specifies the matching criteria for monitor notifications.
    name str
    The name of the monitor notification rule.
    conditional_recipients MonitorNotificationRuleConditionalRecipientsArgs
    Use conditional recipients to define different recipients for different situations. Cannot be used with recipients.
    recipients Sequence[str]
    List of recipients to notify. Cannot be used with conditional_recipients.
    filter Property Map
    Specifies the matching criteria for monitor notifications.
    name String
    The name of the monitor notification rule.
    conditionalRecipients Property Map
    Use conditional recipients to define different recipients for different situations. Cannot be used with recipients.
    recipients List<String>
    List of recipients to notify. Cannot be used with conditional_recipients.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the MonitorNotificationRule 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 MonitorNotificationRule Resource

    Get an existing MonitorNotificationRule 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?: MonitorNotificationRuleState, opts?: CustomResourceOptions): MonitorNotificationRule
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        conditional_recipients: Optional[MonitorNotificationRuleConditionalRecipientsArgs] = None,
        filter: Optional[MonitorNotificationRuleFilterArgs] = None,
        name: Optional[str] = None,
        recipients: Optional[Sequence[str]] = None) -> MonitorNotificationRule
    func GetMonitorNotificationRule(ctx *Context, name string, id IDInput, state *MonitorNotificationRuleState, opts ...ResourceOption) (*MonitorNotificationRule, error)
    public static MonitorNotificationRule Get(string name, Input<string> id, MonitorNotificationRuleState? state, CustomResourceOptions? opts = null)
    public static MonitorNotificationRule get(String name, Output<String> id, MonitorNotificationRuleState state, CustomResourceOptions options)
    resources:  _:    type: datadog:MonitorNotificationRule    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    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
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    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
    The unique name of the resulting resource.
    id
    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
    The unique name of the resulting resource.
    id
    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:
    ConditionalRecipients MonitorNotificationRuleConditionalRecipients
    Use conditional recipients to define different recipients for different situations. Cannot be used with recipients.
    Filter MonitorNotificationRuleFilter
    Specifies the matching criteria for monitor notifications.
    Name string
    The name of the monitor notification rule.
    Recipients List<string>
    List of recipients to notify. Cannot be used with conditional_recipients.
    ConditionalRecipients MonitorNotificationRuleConditionalRecipientsArgs
    Use conditional recipients to define different recipients for different situations. Cannot be used with recipients.
    Filter MonitorNotificationRuleFilterArgs
    Specifies the matching criteria for monitor notifications.
    Name string
    The name of the monitor notification rule.
    Recipients []string
    List of recipients to notify. Cannot be used with conditional_recipients.
    conditionalRecipients MonitorNotificationRuleConditionalRecipients
    Use conditional recipients to define different recipients for different situations. Cannot be used with recipients.
    filter MonitorNotificationRuleFilter
    Specifies the matching criteria for monitor notifications.
    name String
    The name of the monitor notification rule.
    recipients List<String>
    List of recipients to notify. Cannot be used with conditional_recipients.
    conditionalRecipients MonitorNotificationRuleConditionalRecipients
    Use conditional recipients to define different recipients for different situations. Cannot be used with recipients.
    filter MonitorNotificationRuleFilter
    Specifies the matching criteria for monitor notifications.
    name string
    The name of the monitor notification rule.
    recipients string[]
    List of recipients to notify. Cannot be used with conditional_recipients.
    conditional_recipients MonitorNotificationRuleConditionalRecipientsArgs
    Use conditional recipients to define different recipients for different situations. Cannot be used with recipients.
    filter MonitorNotificationRuleFilterArgs
    Specifies the matching criteria for monitor notifications.
    name str
    The name of the monitor notification rule.
    recipients Sequence[str]
    List of recipients to notify. Cannot be used with conditional_recipients.
    conditionalRecipients Property Map
    Use conditional recipients to define different recipients for different situations. Cannot be used with recipients.
    filter Property Map
    Specifies the matching criteria for monitor notifications.
    name String
    The name of the monitor notification rule.
    recipients List<String>
    List of recipients to notify. Cannot be used with conditional_recipients.

    Supporting Types

    MonitorNotificationRuleConditionalRecipients, MonitorNotificationRuleConditionalRecipientsArgs

    Conditions List<MonitorNotificationRuleConditionalRecipientsCondition>
    Conditions of the notification rule.
    FallbackRecipients List<string>
    If none of the conditions applied, fallback_recipients will get notified.
    Conditions []MonitorNotificationRuleConditionalRecipientsCondition
    Conditions of the notification rule.
    FallbackRecipients []string
    If none of the conditions applied, fallback_recipients will get notified.
    conditions List<MonitorNotificationRuleConditionalRecipientsCondition>
    Conditions of the notification rule.
    fallbackRecipients List<String>
    If none of the conditions applied, fallback_recipients will get notified.
    conditions MonitorNotificationRuleConditionalRecipientsCondition[]
    Conditions of the notification rule.
    fallbackRecipients string[]
    If none of the conditions applied, fallback_recipients will get notified.
    conditions Sequence[MonitorNotificationRuleConditionalRecipientsCondition]
    Conditions of the notification rule.
    fallback_recipients Sequence[str]
    If none of the conditions applied, fallback_recipients will get notified.
    conditions List<Property Map>
    Conditions of the notification rule.
    fallbackRecipients List<String>
    If none of the conditions applied, fallback_recipients will get notified.

    MonitorNotificationRuleConditionalRecipientsCondition, MonitorNotificationRuleConditionalRecipientsConditionArgs

    Recipients List<string>
    A list of recipients to notify. Uses the same format as the monitor message field. Must not start with an '@'.
    Scope string
    Defines the condition under which the recipients are notified. Supported formats: Monitor status condition using transition_type:<status> (for example transition_type:is_alert) or a single tag key:value pair (for example env:prod).
    Recipients []string
    A list of recipients to notify. Uses the same format as the monitor message field. Must not start with an '@'.
    Scope string
    Defines the condition under which the recipients are notified. Supported formats: Monitor status condition using transition_type:<status> (for example transition_type:is_alert) or a single tag key:value pair (for example env:prod).
    recipients List<String>
    A list of recipients to notify. Uses the same format as the monitor message field. Must not start with an '@'.
    scope String
    Defines the condition under which the recipients are notified. Supported formats: Monitor status condition using transition_type:<status> (for example transition_type:is_alert) or a single tag key:value pair (for example env:prod).
    recipients string[]
    A list of recipients to notify. Uses the same format as the monitor message field. Must not start with an '@'.
    scope string
    Defines the condition under which the recipients are notified. Supported formats: Monitor status condition using transition_type:<status> (for example transition_type:is_alert) or a single tag key:value pair (for example env:prod).
    recipients Sequence[str]
    A list of recipients to notify. Uses the same format as the monitor message field. Must not start with an '@'.
    scope str
    Defines the condition under which the recipients are notified. Supported formats: Monitor status condition using transition_type:<status> (for example transition_type:is_alert) or a single tag key:value pair (for example env:prod).
    recipients List<String>
    A list of recipients to notify. Uses the same format as the monitor message field. Must not start with an '@'.
    scope String
    Defines the condition under which the recipients are notified. Supported formats: Monitor status condition using transition_type:<status> (for example transition_type:is_alert) or a single tag key:value pair (for example env:prod).

    MonitorNotificationRuleFilter, MonitorNotificationRuleFilterArgs

    Scope string
    A scope expression composed of key:value pairs (such as env:prod) with boolean operators (AND, OR, NOT) and parentheses for grouping.
    Tags List<string>
    A list of tag key:value pairs (e.g. team:product). All tags must match (AND semantics).
    Scope string
    A scope expression composed of key:value pairs (such as env:prod) with boolean operators (AND, OR, NOT) and parentheses for grouping.
    Tags []string
    A list of tag key:value pairs (e.g. team:product). All tags must match (AND semantics).
    scope String
    A scope expression composed of key:value pairs (such as env:prod) with boolean operators (AND, OR, NOT) and parentheses for grouping.
    tags List<String>
    A list of tag key:value pairs (e.g. team:product). All tags must match (AND semantics).
    scope string
    A scope expression composed of key:value pairs (such as env:prod) with boolean operators (AND, OR, NOT) and parentheses for grouping.
    tags string[]
    A list of tag key:value pairs (e.g. team:product). All tags must match (AND semantics).
    scope str
    A scope expression composed of key:value pairs (such as env:prod) with boolean operators (AND, OR, NOT) and parentheses for grouping.
    tags Sequence[str]
    A list of tag key:value pairs (e.g. team:product). All tags must match (AND semantics).
    scope String
    A scope expression composed of key:value pairs (such as env:prod) with boolean operators (AND, OR, NOT) and parentheses for grouping.
    tags List<String>
    A list of tag key:value pairs (e.g. team:product). All tags must match (AND semantics).

    Import

    The pulumi import command can be used, for example:

    $ pulumi import datadog:index/monitorNotificationRule:MonitorNotificationRule new_list "00e000000-0000-1234-0000-000000000000"

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    Datadog pulumi/pulumi-datadog
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the datadog Terraform Provider.
    datadog logo
    Viewing docs for Datadog v4.68.0
    published on Wednesday, Feb 25, 2026 by Pulumi
    Schema (JSON)
    pulumi/pulumi-datadog
      Try Pulumi Cloud free. Your team will thank you.