Language

English Français 日本語 한국어 Español

Datadog Site

Site help
US1 US3 US5 EU AP1 AP2 US1-FED US2-FED

Update a monitor notification rule

PATCH https://api.ap1.datadoghq.com/api/v2/monitor/notification_rule/{rule_id}https://api.ap2.datadoghq.com/api/v2/monitor/notification_rule/{rule_id}https://api.datadoghq.eu/api/v2/monitor/notification_rule/{rule_id}https://api.ddog-gov.com/api/v2/monitor/notification_rule/{rule_id}https://api.us2.ddog-gov.com/api/v2/monitor/notification_rule/{rule_id}https://api.datadoghq.com/api/v2/monitor/notification_rule/{rule_id}https://api.us3.datadoghq.com/api/v2/monitor/notification_rule/{rule_id}https://api.us5.datadoghq.com/api/v2/monitor/notification_rule/{rule_id}

Overview

Updates a monitor notification rule by rule_id. This endpoint requires the monitor_config_policy_write permission.

Arguments

Path Parameters

Name

Type

Description

rule_id [required]

string

ID of the monitor notification rule to update.

Request

Body Data (required)

Request body to update the monitor notification rule.

Expand All

Field

Type

Description

data [required]

object

Object to update a monitor notification rule.

attributes [required]

object

Attributes of the monitor notification rule.

conditional_recipients

object

Use conditional recipients to define different recipients for different situations. Cannot be used with recipients.

conditions [required]

[object]

Conditions of the notification rule.

recipients [required]

[string]

A list of recipients to notify. Uses the same format as the monitor message field. Must not start with an '@'.

scope [required]

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.
  • A single tag key:value pair, for example env:prod.

fallback_recipients

[string]

If none of the conditions applied, fallback_recipients will get notified.

filter

 <oneOf>

Specifies the matching criteria for monitor notifications.

Option 1

object

Filters monitor notifications by a list of tag key:value pairs.

tags [required]

[string]

A list of tag key:value pairs (e.g. team:product). All tags must match (AND semantics).

Option 2

object

Filters monitor notifications using a scope expression over key:value pairs with boolean logic (AND, OR, NOT).

scope [required]

string

A scope expression composed by key:value pairs (e.g. service:foo) with boolean operators (AND, OR, NOT) and parentheses for grouping.

name [required]

string

The name of the monitor notification rule.

recipients

[string]

A list of recipients to notify. Uses the same format as the monitor message field. Must not start with an '@'. Cannot be used with conditional_recipients.

id [required]

string

The ID of the monitor notification rule.

type

enum

Monitor notification rule resource type. Allowed enum values: monitor-notification-rule

default: monitor-notification-rule

{
  "data": {
    "attributes": {
      "filter": {
        "tags": [
          "test:example-monitor",
          "host:abc"
        ]
      },
      "name": "updated rule",
      "recipients": [
        "slack-test-channel"
      ]
    },
    "id": "00000000-0000-1234-0000-000000000000",
    "type": "monitor-notification-rule"
  }
}
{
  "data": {
    "attributes": {
      "filter": {
        "tags": [
          "test:example-monitor",
          "host:abc"
        ]
      },
      "name": "updated rule",
      "conditional_recipients": {
        "conditions": [
          {
            "scope": "transition_type:is_alert",
            "recipients": [
              "slack-test-channel",
              "jira-test"
            ]
          }
        ]
      }
    },
    "id": "00000000-0000-1234-0000-000000000000",
    "type": "monitor-notification-rule"
  }
}
{
  "data": {
    "attributes": {
      "filter": {
        "scope": "test:example-monitor"
      },
      "name": "updated rule",
      "recipients": [
        "slack-test-channel"
      ]
    },
    "id": "00000000-0000-1234-0000-000000000000",
    "type": "monitor-notification-rule"
  }
}

Response

OK

A monitor notification rule.

Expand All

Field

Type

Description

data

object

Monitor notification rule data.

attributes

object

Attributes of the monitor notification rule.

conditional_recipients

object

Use conditional recipients to define different recipients for different situations. Cannot be used with recipients.

conditions [required]

[object]

Conditions of the notification rule.

recipients [required]

[string]

A list of recipients to notify. Uses the same format as the monitor message field. Must not start with an '@'.

scope [required]

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.
  • A single tag key:value pair, for example env:prod.

fallback_recipients

[string]

If none of the conditions applied, fallback_recipients will get notified.

created

date-time

Creation time of the monitor notification rule.

filter

 <oneOf>

Specifies the matching criteria for monitor notifications.

Option 1

object

Filters monitor notifications by a list of tag key:value pairs.

tags [required]

[string]

A list of tag key:value pairs (e.g. team:product). All tags must match (AND semantics).

Option 2

object

Filters monitor notifications using a scope expression over key:value pairs with boolean logic (AND, OR, NOT).

scope [required]

string

A scope expression composed by key:value pairs (e.g. service:foo) with boolean operators (AND, OR, NOT) and parentheses for grouping.

modified

date-time

Time the monitor notification rule was last modified.

name

string

The name of the monitor notification rule.

recipients

[string]

A list of recipients to notify. Uses the same format as the monitor message field. Must not start with an '@'. Cannot be used with conditional_recipients.

id

string

The ID of the monitor notification rule.

relationships

object

All relationships associated with monitor notification rule.

created_by

object

The user who created the monitor notification rule.

data

object

Data for the user who created the monitor notification rule.

id

string

User ID of the monitor notification rule creator.

type

enum

Users resource type. Allowed enum values: users

default: users

type

enum

Monitor notification rule resource type. Allowed enum values: monitor-notification-rule

default: monitor-notification-rule

included

[ <oneOf>]

Array of objects related to the monitor notification rule that the user requested.

Option 1

object

User object returned by the API.

attributes

object

Attributes of user object returned by the API.

created_at

date-time

The ISO 8601 timestamp of when the user account was created.

disabled

boolean

Whether the user account is deactivated. Disabled users cannot log in.

email

string

The email address of the user, used for login and notifications.

handle

string

The unique handle (username) of the user, typically matching their email prefix.

icon

string

URL of the user's profile icon, typically a Gravatar URL derived from the email address.

last_login_time

date-time

The ISO 8601 timestamp of the user's most recent login, or null if the user has never logged in.

mfa_enabled

boolean

Whether multi-factor authentication (MFA) is enabled for the user's account.

modified_at

date-time

The ISO 8601 timestamp of when the user account was last modified.

name

string

The full display name of the user as shown in the Datadog UI.

service_account

boolean

Whether this is a service account rather than a human user. Service accounts are used for programmatic API access.

status

string

The current status of the user account (for example, Active, Pending, or Disabled).

title

string

The job title of the user (for example, "Senior Engineer" or "Product Manager").

uuid

string

The globally unique identifier (UUID) of the user.

verified

boolean

Whether the user's email address has been verified.

id

string

ID of the user.

relationships

object

Relationships of the user object returned by the API.

org

object

Relationship to an organization.

data [required]

object

Relationship to organization object.

id [required]

string

ID of the organization.

type [required]

enum

Organizations resource type. Allowed enum values: orgs

default: orgs

other_orgs

object

Relationship to organizations.

data [required]

[object]

Relationships to organization objects.

id [required]

string

ID of the organization.

type [required]

enum

Organizations resource type. Allowed enum values: orgs

default: orgs

other_users

object

Relationship to users.

data [required]

[object]

Relationships to user objects.

id [required]

string

A unique identifier that represents the user.

type [required]

enum

Users resource type. Allowed enum values: users

default: users

roles

object

Relationship to roles.

data

[object]

An array containing type and the unique identifier of a role.

id

string

The unique identifier of the role.

type

enum

Roles type. Allowed enum values: roles

default: roles

type

enum

Users resource type. Allowed enum values: users

default: users

{
  "data": {
    "attributes": {
      "conditional_recipients": {
        "conditions": [
          {
            "recipients": [
              "slack-test-channel",
              "jira-test"
            ],
            "scope": "transition_type:is_alert"
          }
        ],
        "fallback_recipients": [
          "slack-test-channel",
          "jira-test"
        ]
      },
      "created": "2020-01-02T03:04:00.000Z",
      "filter": {
        "tags": [
          "team:product",
          "host:abc"
        ]
      },
      "modified": "2020-01-02T03:04:00.000Z",
      "name": "A notification rule name",
      "recipients": [
        "slack-test-channel",
        "jira-test"
      ]
    },
    "id": "00000000-0000-1234-0000-000000000000",
    "relationships": {
      "created_by": {
        "data": {
          "id": "00000000-0000-1234-0000-000000000000",
          "type": "users"
        }
      }
    },
    "type": "monitor-notification-rule"
  },
  "included": [
    {
      "attributes": {
        "created_at": "2019-09-19T10:00:00.000Z",
        "disabled": false,
        "email": "string",
        "handle": "string",
        "icon": "string",
        "last_login_time": "2019-09-19T10:00:00.000Z",
        "mfa_enabled": false,
        "modified_at": "2019-09-19T10:00:00.000Z",
        "name": "string",
        "service_account": false,
        "status": "string",
        "title": "string",
        "uuid": "string",
        "verified": false
      },
      "id": "string",
      "relationships": {
        "org": {
          "data": {
            "id": "00000000-0000-beef-0000-000000000000",
            "type": "orgs"
          }
        },
        "other_orgs": {
          "data": [
            {
              "id": "00000000-0000-beef-0000-000000000000",
              "type": "orgs"
            }
          ]
        },
        "other_users": {
          "data": [
            {
              "id": "00000000-0000-0000-2345-000000000000",
              "type": "users"
            }
          ]
        },
        "roles": {
          "data": [
            {
              "id": "3653d3c6-0c75-11ea-ad28-fb5701eabc7d",
              "type": "roles"
            }
          ]
        }
      },
      "type": "users"
    }
  ]
}

Bad Request

API error response.

Expand All

Field

Type

Description

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Forbidden

API error response.

Expand All

Field

Type

Description

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Not Found

API error response.

Expand All

Field

Type

Description

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Too many requests

API error response.

Expand All

Field

Type

Description

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Code Example

                          ## default
# 

# Path parameters
export rule_id="CHANGE_ME"
# Curl command
curl -X PATCH "https://api.ap1.datadoghq.com"https://api.ap2.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.us2.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v2/monitor/notification_rule/${rule_id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "filter": {
        "tags": [
          "team:product",
          "host:abc"
        ]
      },
      "name": "A notification rule name",
      "recipients": [
        "slack-test-channel",
        "jira-test"
      ]
    },
    "id": "00000000-0000-1234-0000-000000000000",
    "type": "monitor-notification-rule"
  }
}
EOF

                        
                          ## default
# 

# Path parameters
export rule_id="CHANGE_ME"
# Curl command
curl -X PATCH "https://api.ap1.datadoghq.com"https://api.ap2.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.us2.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v2/monitor/notification_rule/${rule_id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "filter": {
        "tags": [
          "team:product",
          "host:abc"
        ]
      },
      "name": "A notification rule name",
      "recipients": [
        "slack-test-channel",
        "jira-test"
      ]
    },
    "id": "00000000-0000-1234-0000-000000000000",
    "type": "monitor-notification-rule"
  }
}
EOF

                        
                          ## default
# 

# Path parameters
export rule_id="CHANGE_ME"
# Curl command
curl -X PATCH "https://api.ap1.datadoghq.com"https://api.ap2.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.us2.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v2/monitor/notification_rule/${rule_id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "filter": {
        "tags": [
          "team:product",
          "host:abc"
        ]
      },
      "name": "A notification rule name",
      "recipients": [
        "slack-test-channel",
        "jira-test"
      ]
    },
    "id": "00000000-0000-1234-0000-000000000000",
    "type": "monitor-notification-rule"
  }
}
EOF

                        
// Update a monitor notification rule returns "OK" response

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"os"

	"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
	"github.com/DataDog/datadog-api-client-go/v2/api/datadogV2"
)

func main() {
	// there is a valid "monitor_notification_rule" in the system
	MonitorNotificationRuleDataID := os.Getenv("MONITOR_NOTIFICATION_RULE_DATA_ID")

	body := datadogV2.MonitorNotificationRuleUpdateRequest{
		Data: datadogV2.MonitorNotificationRuleUpdateRequestData{
			Attributes: datadogV2.MonitorNotificationRuleAttributes{
				Filter: &datadogV2.MonitorNotificationRuleFilter{
					MonitorNotificationRuleFilterTags: &datadogV2.MonitorNotificationRuleFilterTags{
						Tags: []string{
							"test:example-monitor",
							"host:abc",
						},
					}},
				Name: "updated rule",
				Recipients: []string{
					"slack-test-channel",
				},
			},
			Id:   MonitorNotificationRuleDataID,
			Type: datadogV2.MONITORNOTIFICATIONRULERESOURCETYPE_MONITOR_NOTIFICATION_RULE.Ptr(),
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	configuration := datadog.NewConfiguration()
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewMonitorsApi(apiClient)
	resp, r, err := api.UpdateMonitorNotificationRule(ctx, MonitorNotificationRuleDataID, body)

	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `MonitorsApi.UpdateMonitorNotificationRule`: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}

	responseContent, _ := json.MarshalIndent(resp, "", "  ")
	fmt.Fprintf(os.Stdout, "Response from `MonitorsApi.UpdateMonitorNotificationRule`:\n%s\n", responseContent)
}

// Update a monitor notification rule with conditional_recipients returns "OK" response

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"os"

	"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
	"github.com/DataDog/datadog-api-client-go/v2/api/datadogV2"
)

func main() {
	// there is a valid "monitor_notification_rule" in the system
	MonitorNotificationRuleDataID := os.Getenv("MONITOR_NOTIFICATION_RULE_DATA_ID")

	body := datadogV2.MonitorNotificationRuleUpdateRequest{
		Data: datadogV2.MonitorNotificationRuleUpdateRequestData{
			Attributes: datadogV2.MonitorNotificationRuleAttributes{
				Filter: &datadogV2.MonitorNotificationRuleFilter{
					MonitorNotificationRuleFilterTags: &datadogV2.MonitorNotificationRuleFilterTags{
						Tags: []string{
							"test:example-monitor",
							"host:abc",
						},
					}},
				Name: "updated rule",
				ConditionalRecipients: &datadogV2.MonitorNotificationRuleConditionalRecipients{
					Conditions: []datadogV2.MonitorNotificationRuleCondition{
						{
							Scope: "transition_type:is_alert",
							Recipients: []string{
								"slack-test-channel",
								"jira-test",
							},
						},
					},
				},
			},
			Id:   MonitorNotificationRuleDataID,
			Type: datadogV2.MONITORNOTIFICATIONRULERESOURCETYPE_MONITOR_NOTIFICATION_RULE.Ptr(),
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	configuration := datadog.NewConfiguration()
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewMonitorsApi(apiClient)
	resp, r, err := api.UpdateMonitorNotificationRule(ctx, MonitorNotificationRuleDataID, body)

	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `MonitorsApi.UpdateMonitorNotificationRule`: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}

	responseContent, _ := json.MarshalIndent(resp, "", "  ")
	fmt.Fprintf(os.Stdout, "Response from `MonitorsApi.UpdateMonitorNotificationRule`:\n%s\n", responseContent)
}

// Update a monitor notification rule with scope returns "OK" response

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"os"

	"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
	"github.com/DataDog/datadog-api-client-go/v2/api/datadogV2"
)

func main() {
	// there is a valid "monitor_notification_rule" in the system
	MonitorNotificationRuleDataID := os.Getenv("MONITOR_NOTIFICATION_RULE_DATA_ID")

	body := datadogV2.MonitorNotificationRuleUpdateRequest{
		Data: datadogV2.MonitorNotificationRuleUpdateRequestData{
			Attributes: datadogV2.MonitorNotificationRuleAttributes{
				Filter: &datadogV2.MonitorNotificationRuleFilter{
					MonitorNotificationRuleFilterScope: &datadogV2.MonitorNotificationRuleFilterScope{
						Scope: "test:example-monitor",
					}},
				Name: "updated rule",
				Recipients: []string{
					"slack-test-channel",
				},
			},
			Id:   MonitorNotificationRuleDataID,
			Type: datadogV2.MONITORNOTIFICATIONRULERESOURCETYPE_MONITOR_NOTIFICATION_RULE.Ptr(),
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	configuration := datadog.NewConfiguration()
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewMonitorsApi(apiClient)
	resp, r, err := api.UpdateMonitorNotificationRule(ctx, MonitorNotificationRuleDataID, body)

	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `MonitorsApi.UpdateMonitorNotificationRule`: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}

	responseContent, _ := json.MarshalIndent(resp, "", "  ")
	fmt.Fprintf(os.Stdout, "Response from `MonitorsApi.UpdateMonitorNotificationRule`:\n%s\n", responseContent)
}

Instructions

First install the library and its dependencies and then save the example to main.go and run following commands:

    
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" go run "main.go"
// Update a monitor notification rule returns "OK" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.MonitorsApi;
import com.datadog.api.client.v2.model.MonitorNotificationRuleAttributes;
import com.datadog.api.client.v2.model.MonitorNotificationRuleFilter;
import com.datadog.api.client.v2.model.MonitorNotificationRuleFilterTags;
import com.datadog.api.client.v2.model.MonitorNotificationRuleResourceType;
import com.datadog.api.client.v2.model.MonitorNotificationRuleResponse;
import com.datadog.api.client.v2.model.MonitorNotificationRuleUpdateRequest;
import com.datadog.api.client.v2.model.MonitorNotificationRuleUpdateRequestData;
import java.util.Arrays;
import java.util.Collections;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = ApiClient.getDefaultApiClient();
    MonitorsApi apiInstance = new MonitorsApi(defaultClient);

    // there is a valid "monitor_notification_rule" in the system
    String MONITOR_NOTIFICATION_RULE_DATA_ID = System.getenv("MONITOR_NOTIFICATION_RULE_DATA_ID");

    MonitorNotificationRuleUpdateRequest body =
        new MonitorNotificationRuleUpdateRequest()
            .data(
                new MonitorNotificationRuleUpdateRequestData()
                    .attributes(
                        new MonitorNotificationRuleAttributes()
                            .filter(
                                new MonitorNotificationRuleFilter(
                                    new MonitorNotificationRuleFilterTags()
                                        .tags(Arrays.asList("test:example-monitor", "host:abc"))))
                            .name("updated rule")
                            .recipients(Collections.singletonList("slack-test-channel")))
                    .id(MONITOR_NOTIFICATION_RULE_DATA_ID)
                    .type(MonitorNotificationRuleResourceType.MONITOR_NOTIFICATION_RULE));

    try {
      MonitorNotificationRuleResponse result =
          apiInstance.updateMonitorNotificationRule(MONITOR_NOTIFICATION_RULE_DATA_ID, body);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling MonitorsApi#updateMonitorNotificationRule");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}

// Update a monitor notification rule with conditional_recipients returns "OK" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.MonitorsApi;
import com.datadog.api.client.v2.model.MonitorNotificationRuleAttributes;
import com.datadog.api.client.v2.model.MonitorNotificationRuleCondition;
import com.datadog.api.client.v2.model.MonitorNotificationRuleConditionalRecipients;
import com.datadog.api.client.v2.model.MonitorNotificationRuleFilter;
import com.datadog.api.client.v2.model.MonitorNotificationRuleFilterTags;
import com.datadog.api.client.v2.model.MonitorNotificationRuleResourceType;
import com.datadog.api.client.v2.model.MonitorNotificationRuleResponse;
import com.datadog.api.client.v2.model.MonitorNotificationRuleUpdateRequest;
import com.datadog.api.client.v2.model.MonitorNotificationRuleUpdateRequestData;
import java.util.Arrays;
import java.util.Collections;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = ApiClient.getDefaultApiClient();
    MonitorsApi apiInstance = new MonitorsApi(defaultClient);

    // there is a valid "monitor_notification_rule" in the system
    String MONITOR_NOTIFICATION_RULE_DATA_ID = System.getenv("MONITOR_NOTIFICATION_RULE_DATA_ID");

    MonitorNotificationRuleUpdateRequest body =
        new MonitorNotificationRuleUpdateRequest()
            .data(
                new MonitorNotificationRuleUpdateRequestData()
                    .attributes(
                        new MonitorNotificationRuleAttributes()
                            .filter(
                                new MonitorNotificationRuleFilter(
                                    new MonitorNotificationRuleFilterTags()
                                        .tags(Arrays.asList("test:example-monitor", "host:abc"))))
                            .name("updated rule")
                            .conditionalRecipients(
                                new MonitorNotificationRuleConditionalRecipients()
                                    .conditions(
                                        Collections.singletonList(
                                            new MonitorNotificationRuleCondition()
                                                .scope("transition_type:is_alert")
                                                .recipients(
                                                    Arrays.asList(
                                                        "slack-test-channel", "jira-test"))))))
                    .id(MONITOR_NOTIFICATION_RULE_DATA_ID)
                    .type(MonitorNotificationRuleResourceType.MONITOR_NOTIFICATION_RULE));

    try {
      MonitorNotificationRuleResponse result =
          apiInstance.updateMonitorNotificationRule(MONITOR_NOTIFICATION_RULE_DATA_ID, body);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling MonitorsApi#updateMonitorNotificationRule");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}

// Update a monitor notification rule with scope returns "OK" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.MonitorsApi;
import com.datadog.api.client.v2.model.MonitorNotificationRuleAttributes;
import com.datadog.api.client.v2.model.MonitorNotificationRuleFilter;
import com.datadog.api.client.v2.model.MonitorNotificationRuleFilterScope;
import com.datadog.api.client.v2.model.MonitorNotificationRuleResourceType;
import com.datadog.api.client.v2.model.MonitorNotificationRuleResponse;
import com.datadog.api.client.v2.model.MonitorNotificationRuleUpdateRequest;
import com.datadog.api.client.v2.model.MonitorNotificationRuleUpdateRequestData;
import java.util.Collections;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = ApiClient.getDefaultApiClient();
    MonitorsApi apiInstance = new MonitorsApi(defaultClient);

    // there is a valid "monitor_notification_rule" in the system
    String MONITOR_NOTIFICATION_RULE_DATA_ID = System.getenv("MONITOR_NOTIFICATION_RULE_DATA_ID");

    MonitorNotificationRuleUpdateRequest body =
        new MonitorNotificationRuleUpdateRequest()
            .data(
                new MonitorNotificationRuleUpdateRequestData()
                    .attributes(
                        new MonitorNotificationRuleAttributes()
                            .filter(
                                new MonitorNotificationRuleFilter(
                                    new MonitorNotificationRuleFilterScope()
                                        .scope("test:example-monitor")))
                            .name("updated rule")
                            .recipients(Collections.singletonList("slack-test-channel")))
                    .id(MONITOR_NOTIFICATION_RULE_DATA_ID)
                    .type(MonitorNotificationRuleResourceType.MONITOR_NOTIFICATION_RULE));

    try {
      MonitorNotificationRuleResponse result =
          apiInstance.updateMonitorNotificationRule(MONITOR_NOTIFICATION_RULE_DATA_ID, body);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling MonitorsApi#updateMonitorNotificationRule");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}

Instructions

First install the library and its dependencies and then save the example to Example.java and run following commands:

    
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" java "Example.java"
"""
Update a monitor notification rule returns "OK" response
"""

from os import environ
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.monitors_api import MonitorsApi
from datadog_api_client.v2.model.monitor_notification_rule_attributes import MonitorNotificationRuleAttributes
from datadog_api_client.v2.model.monitor_notification_rule_filter_tags import MonitorNotificationRuleFilterTags
from datadog_api_client.v2.model.monitor_notification_rule_resource_type import MonitorNotificationRuleResourceType
from datadog_api_client.v2.model.monitor_notification_rule_update_request import MonitorNotificationRuleUpdateRequest
from datadog_api_client.v2.model.monitor_notification_rule_update_request_data import (
    MonitorNotificationRuleUpdateRequestData,
)

# there is a valid "monitor_notification_rule" in the system
MONITOR_NOTIFICATION_RULE_DATA_ID = environ["MONITOR_NOTIFICATION_RULE_DATA_ID"]

body = MonitorNotificationRuleUpdateRequest(
    data=MonitorNotificationRuleUpdateRequestData(
        attributes=MonitorNotificationRuleAttributes(
            filter=MonitorNotificationRuleFilterTags(
                tags=[
                    "test:example-monitor",
                    "host:abc",
                ],
            ),
            name="updated rule",
            recipients=[
                "slack-test-channel",
            ],
        ),
        id=MONITOR_NOTIFICATION_RULE_DATA_ID,
        type=MonitorNotificationRuleResourceType.MONITOR_NOTIFICATION_RULE,
    ),
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = MonitorsApi(api_client)
    response = api_instance.update_monitor_notification_rule(rule_id=MONITOR_NOTIFICATION_RULE_DATA_ID, body=body)

    print(response)

"""
Update a monitor notification rule with conditional_recipients returns "OK" response
"""

from os import environ
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.monitors_api import MonitorsApi
from datadog_api_client.v2.model.monitor_notification_rule_attributes import MonitorNotificationRuleAttributes
from datadog_api_client.v2.model.monitor_notification_rule_condition import MonitorNotificationRuleCondition
from datadog_api_client.v2.model.monitor_notification_rule_conditional_recipients import (
    MonitorNotificationRuleConditionalRecipients,
)
from datadog_api_client.v2.model.monitor_notification_rule_filter_tags import MonitorNotificationRuleFilterTags
from datadog_api_client.v2.model.monitor_notification_rule_resource_type import MonitorNotificationRuleResourceType
from datadog_api_client.v2.model.monitor_notification_rule_update_request import MonitorNotificationRuleUpdateRequest
from datadog_api_client.v2.model.monitor_notification_rule_update_request_data import (
    MonitorNotificationRuleUpdateRequestData,
)

# there is a valid "monitor_notification_rule" in the system
MONITOR_NOTIFICATION_RULE_DATA_ID = environ["MONITOR_NOTIFICATION_RULE_DATA_ID"]

body = MonitorNotificationRuleUpdateRequest(
    data=MonitorNotificationRuleUpdateRequestData(
        attributes=MonitorNotificationRuleAttributes(
            filter=MonitorNotificationRuleFilterTags(
                tags=[
                    "test:example-monitor",
                    "host:abc",
                ],
            ),
            name="updated rule",
            conditional_recipients=MonitorNotificationRuleConditionalRecipients(
                conditions=[
                    MonitorNotificationRuleCondition(
                        scope="transition_type:is_alert",
                        recipients=[
                            "slack-test-channel",
                            "jira-test",
                        ],
                    ),
                ],
            ),
        ),
        id=MONITOR_NOTIFICATION_RULE_DATA_ID,
        type=MonitorNotificationRuleResourceType.MONITOR_NOTIFICATION_RULE,
    ),
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = MonitorsApi(api_client)
    response = api_instance.update_monitor_notification_rule(rule_id=MONITOR_NOTIFICATION_RULE_DATA_ID, body=body)

    print(response)

"""
Update a monitor notification rule with scope returns "OK" response
"""

from os import environ
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.monitors_api import MonitorsApi
from datadog_api_client.v2.model.monitor_notification_rule_attributes import MonitorNotificationRuleAttributes
from datadog_api_client.v2.model.monitor_notification_rule_filter_scope import MonitorNotificationRuleFilterScope
from datadog_api_client.v2.model.monitor_notification_rule_resource_type import MonitorNotificationRuleResourceType
from datadog_api_client.v2.model.monitor_notification_rule_update_request import MonitorNotificationRuleUpdateRequest
from datadog_api_client.v2.model.monitor_notification_rule_update_request_data import (
    MonitorNotificationRuleUpdateRequestData,
)

# there is a valid "monitor_notification_rule" in the system
MONITOR_NOTIFICATION_RULE_DATA_ID = environ["MONITOR_NOTIFICATION_RULE_DATA_ID"]

body = MonitorNotificationRuleUpdateRequest(
    data=MonitorNotificationRuleUpdateRequestData(
        attributes=MonitorNotificationRuleAttributes(
            filter=MonitorNotificationRuleFilterScope(
                scope="test:example-monitor",
            ),
            name="updated rule",
            recipients=[
                "slack-test-channel",
            ],
        ),
        id=MONITOR_NOTIFICATION_RULE_DATA_ID,
        type=MonitorNotificationRuleResourceType.MONITOR_NOTIFICATION_RULE,
    ),
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = MonitorsApi(api_client)
    response = api_instance.update_monitor_notification_rule(rule_id=MONITOR_NOTIFICATION_RULE_DATA_ID, body=body)

    print(response)

Instructions

First install the library and its dependencies and then save the example to example.py and run following commands:

    
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" python3 "example.py"
# Update a monitor notification rule returns "OK" response

require "datadog_api_client"
api_instance = DatadogAPIClient::V2::MonitorsAPI.new

# there is a valid "monitor_notification_rule" in the system
MONITOR_NOTIFICATION_RULE_DATA_ID = ENV["MONITOR_NOTIFICATION_RULE_DATA_ID"]

body = DatadogAPIClient::V2::MonitorNotificationRuleUpdateRequest.new({
  data: DatadogAPIClient::V2::MonitorNotificationRuleUpdateRequestData.new({
    attributes: DatadogAPIClient::V2::MonitorNotificationRuleAttributes.new({
      filter: DatadogAPIClient::V2::MonitorNotificationRuleFilterTags.new({
        tags: [
          "test:example-monitor",
          "host:abc",
        ],
      }),
      name: "updated rule",
      recipients: [
        "slack-test-channel",
      ],
    }),
    id: MONITOR_NOTIFICATION_RULE_DATA_ID,
    type: DatadogAPIClient::V2::MonitorNotificationRuleResourceType::MONITOR_NOTIFICATION_RULE,
  }),
})
p api_instance.update_monitor_notification_rule(MONITOR_NOTIFICATION_RULE_DATA_ID, body)

# Update a monitor notification rule with conditional_recipients returns "OK" response

require "datadog_api_client"
api_instance = DatadogAPIClient::V2::MonitorsAPI.new

# there is a valid "monitor_notification_rule" in the system
MONITOR_NOTIFICATION_RULE_DATA_ID = ENV["MONITOR_NOTIFICATION_RULE_DATA_ID"]

body = DatadogAPIClient::V2::MonitorNotificationRuleUpdateRequest.new({
  data: DatadogAPIClient::V2::MonitorNotificationRuleUpdateRequestData.new({
    attributes: DatadogAPIClient::V2::MonitorNotificationRuleAttributes.new({
      filter: DatadogAPIClient::V2::MonitorNotificationRuleFilterTags.new({
        tags: [
          "test:example-monitor",
          "host:abc",
        ],
      }),
      name: "updated rule",
      conditional_recipients: DatadogAPIClient::V2::MonitorNotificationRuleConditionalRecipients.new({
        conditions: [
          DatadogAPIClient::V2::MonitorNotificationRuleCondition.new({
            scope: "transition_type:is_alert",
            recipients: [
              "slack-test-channel",
              "jira-test",
            ],
          }),
        ],
      }),
    }),
    id: MONITOR_NOTIFICATION_RULE_DATA_ID,
    type: DatadogAPIClient::V2::MonitorNotificationRuleResourceType::MONITOR_NOTIFICATION_RULE,
  }),
})
p api_instance.update_monitor_notification_rule(MONITOR_NOTIFICATION_RULE_DATA_ID, body)

# Update a monitor notification rule with scope returns "OK" response

require "datadog_api_client"
api_instance = DatadogAPIClient::V2::MonitorsAPI.new

# there is a valid "monitor_notification_rule" in the system
MONITOR_NOTIFICATION_RULE_DATA_ID = ENV["MONITOR_NOTIFICATION_RULE_DATA_ID"]

body = DatadogAPIClient::V2::MonitorNotificationRuleUpdateRequest.new({
  data: DatadogAPIClient::V2::MonitorNotificationRuleUpdateRequestData.new({
    attributes: DatadogAPIClient::V2::MonitorNotificationRuleAttributes.new({
      filter: DatadogAPIClient::V2::MonitorNotificationRuleFilterScope.new({
        scope: "test:example-monitor",
      }),
      name: "updated rule",
      recipients: [
        "slack-test-channel",
      ],
    }),
    id: MONITOR_NOTIFICATION_RULE_DATA_ID,
    type: DatadogAPIClient::V2::MonitorNotificationRuleResourceType::MONITOR_NOTIFICATION_RULE,
  }),
})
p api_instance.update_monitor_notification_rule(MONITOR_NOTIFICATION_RULE_DATA_ID, body)

Instructions

First install the library and its dependencies and then save the example to example.rb and run following commands:

    
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" rb "example.rb"
// Update a monitor notification rule returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_monitors::MonitorsAPI;
use datadog_api_client::datadogV2::model::MonitorNotificationRuleAttributes;
use datadog_api_client::datadogV2::model::MonitorNotificationRuleFilter;
use datadog_api_client::datadogV2::model::MonitorNotificationRuleFilterTags;
use datadog_api_client::datadogV2::model::MonitorNotificationRuleResourceType;
use datadog_api_client::datadogV2::model::MonitorNotificationRuleUpdateRequest;
use datadog_api_client::datadogV2::model::MonitorNotificationRuleUpdateRequestData;

#[tokio::main]
async fn main() {
    // there is a valid "monitor_notification_rule" in the system
    let monitor_notification_rule_data_id =
        std::env::var("MONITOR_NOTIFICATION_RULE_DATA_ID").unwrap();
    let body = MonitorNotificationRuleUpdateRequest::new(
        MonitorNotificationRuleUpdateRequestData::new(
            MonitorNotificationRuleAttributes::new("updated rule".to_string())
                .filter(
                    MonitorNotificationRuleFilter::MonitorNotificationRuleFilterTags(Box::new(
                        MonitorNotificationRuleFilterTags::new(vec![
                            "test:example-monitor".to_string(),
                            "host:abc".to_string(),
                        ]),
                    )),
                )
                .recipients(vec!["slack-test-channel".to_string()]),
            monitor_notification_rule_data_id.clone(),
        )
        .type_(MonitorNotificationRuleResourceType::MONITOR_NOTIFICATION_RULE),
    );
    let configuration = datadog::Configuration::new();
    let api = MonitorsAPI::with_config(configuration);
    let resp = api
        .update_monitor_notification_rule(monitor_notification_rule_data_id.clone(), body)
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

// Update a monitor notification rule with conditional_recipients returns "OK"
// response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_monitors::MonitorsAPI;
use datadog_api_client::datadogV2::model::MonitorNotificationRuleAttributes;
use datadog_api_client::datadogV2::model::MonitorNotificationRuleCondition;
use datadog_api_client::datadogV2::model::MonitorNotificationRuleConditionalRecipients;
use datadog_api_client::datadogV2::model::MonitorNotificationRuleFilter;
use datadog_api_client::datadogV2::model::MonitorNotificationRuleFilterTags;
use datadog_api_client::datadogV2::model::MonitorNotificationRuleResourceType;
use datadog_api_client::datadogV2::model::MonitorNotificationRuleUpdateRequest;
use datadog_api_client::datadogV2::model::MonitorNotificationRuleUpdateRequestData;

#[tokio::main]
async fn main() {
    // there is a valid "monitor_notification_rule" in the system
    let monitor_notification_rule_data_id =
        std::env::var("MONITOR_NOTIFICATION_RULE_DATA_ID").unwrap();
    let body = MonitorNotificationRuleUpdateRequest::new(
        MonitorNotificationRuleUpdateRequestData::new(
            MonitorNotificationRuleAttributes::new("updated rule".to_string())
                .conditional_recipients(MonitorNotificationRuleConditionalRecipients::new(vec![
                    MonitorNotificationRuleCondition::new(
                        vec!["slack-test-channel".to_string(), "jira-test".to_string()],
                        "transition_type:is_alert".to_string(),
                    ),
                ]))
                .filter(
                    MonitorNotificationRuleFilter::MonitorNotificationRuleFilterTags(Box::new(
                        MonitorNotificationRuleFilterTags::new(vec![
                            "test:example-monitor".to_string(),
                            "host:abc".to_string(),
                        ]),
                    )),
                ),
            monitor_notification_rule_data_id.clone(),
        )
        .type_(MonitorNotificationRuleResourceType::MONITOR_NOTIFICATION_RULE),
    );
    let configuration = datadog::Configuration::new();
    let api = MonitorsAPI::with_config(configuration);
    let resp = api
        .update_monitor_notification_rule(monitor_notification_rule_data_id.clone(), body)
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

// Update a monitor notification rule with scope returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_monitors::MonitorsAPI;
use datadog_api_client::datadogV2::model::MonitorNotificationRuleAttributes;
use datadog_api_client::datadogV2::model::MonitorNotificationRuleFilter;
use datadog_api_client::datadogV2::model::MonitorNotificationRuleFilterScope;
use datadog_api_client::datadogV2::model::MonitorNotificationRuleResourceType;
use datadog_api_client::datadogV2::model::MonitorNotificationRuleUpdateRequest;
use datadog_api_client::datadogV2::model::MonitorNotificationRuleUpdateRequestData;

#[tokio::main]
async fn main() {
    // there is a valid "monitor_notification_rule" in the system
    let monitor_notification_rule_data_id =
        std::env::var("MONITOR_NOTIFICATION_RULE_DATA_ID").unwrap();
    let body = MonitorNotificationRuleUpdateRequest::new(
        MonitorNotificationRuleUpdateRequestData::new(
            MonitorNotificationRuleAttributes::new("updated rule".to_string())
                .filter(
                    MonitorNotificationRuleFilter::MonitorNotificationRuleFilterScope(Box::new(
                        MonitorNotificationRuleFilterScope::new("test:example-monitor".to_string()),
                    )),
                )
                .recipients(vec!["slack-test-channel".to_string()]),
            monitor_notification_rule_data_id.clone(),
        )
        .type_(MonitorNotificationRuleResourceType::MONITOR_NOTIFICATION_RULE),
    );
    let configuration = datadog::Configuration::new();
    let api = MonitorsAPI::with_config(configuration);
    let resp = api
        .update_monitor_notification_rule(monitor_notification_rule_data_id.clone(), body)
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

Instructions

First install the library and its dependencies and then save the example to src/main.rs and run following commands:

    
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" cargo run
/**
 * Update a monitor notification rule returns "OK" response
 */

import { client, v2 } from "@datadog/datadog-api-client";

const configuration = client.createConfiguration();
const apiInstance = new v2.MonitorsApi(configuration);

// there is a valid "monitor_notification_rule" in the system
const MONITOR_NOTIFICATION_RULE_DATA_ID = process.env
  .MONITOR_NOTIFICATION_RULE_DATA_ID as string;

const params: v2.MonitorsApiUpdateMonitorNotificationRuleRequest = {
  body: {
    data: {
      attributes: {
        filter: {
          tags: ["test:example-monitor", "host:abc"],
        },
        name: "updated rule",
        recipients: ["slack-test-channel"],
      },
      id: MONITOR_NOTIFICATION_RULE_DATA_ID,
      type: "monitor-notification-rule",
    },
  },
  ruleId: MONITOR_NOTIFICATION_RULE_DATA_ID,
};

apiInstance
  .updateMonitorNotificationRule(params)
  .then((data: v2.MonitorNotificationRuleResponse) => {
    console.log(
      "API called successfully. Returned data: " + JSON.stringify(data)
    );
  })
  .catch((error: any) => console.error(error));

/**
 * Update a monitor notification rule with conditional_recipients returns "OK" response
 */

import { client, v2 } from "@datadog/datadog-api-client";

const configuration = client.createConfiguration();
const apiInstance = new v2.MonitorsApi(configuration);

// there is a valid "monitor_notification_rule" in the system
const MONITOR_NOTIFICATION_RULE_DATA_ID = process.env
  .MONITOR_NOTIFICATION_RULE_DATA_ID as string;

const params: v2.MonitorsApiUpdateMonitorNotificationRuleRequest = {
  body: {
    data: {
      attributes: {
        filter: {
          tags: ["test:example-monitor", "host:abc"],
        },
        name: "updated rule",
        conditionalRecipients: {
          conditions: [
            {
              scope: "transition_type:is_alert",
              recipients: ["slack-test-channel", "jira-test"],
            },
          ],
        },
      },
      id: MONITOR_NOTIFICATION_RULE_DATA_ID,
      type: "monitor-notification-rule",
    },
  },
  ruleId: MONITOR_NOTIFICATION_RULE_DATA_ID,
};

apiInstance
  .updateMonitorNotificationRule(params)
  .then((data: v2.MonitorNotificationRuleResponse) => {
    console.log(
      "API called successfully. Returned data: " + JSON.stringify(data)
    );
  })
  .catch((error: any) => console.error(error));

/**
 * Update a monitor notification rule with scope returns "OK" response
 */

import { client, v2 } from "@datadog/datadog-api-client";

const configuration = client.createConfiguration();
const apiInstance = new v2.MonitorsApi(configuration);

// there is a valid "monitor_notification_rule" in the system
const MONITOR_NOTIFICATION_RULE_DATA_ID = process.env
  .MONITOR_NOTIFICATION_RULE_DATA_ID as string;

const params: v2.MonitorsApiUpdateMonitorNotificationRuleRequest = {
  body: {
    data: {
      attributes: {
        filter: {
          scope: "test:example-monitor",
        },
        name: "updated rule",
        recipients: ["slack-test-channel"],
      },
      id: MONITOR_NOTIFICATION_RULE_DATA_ID,
      type: "monitor-notification-rule",
    },
  },
  ruleId: MONITOR_NOTIFICATION_RULE_DATA_ID,
};

apiInstance
  .updateMonitorNotificationRule(params)
  .then((data: v2.MonitorNotificationRuleResponse) => {
    console.log(
      "API called successfully. Returned data: " + JSON.stringify(data)
    );
  })
  .catch((error: any) => console.error(error));

Instructions

First install the library and its dependencies and then save the example to example.ts and run following commands:

    
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" tsc "example.ts"