태그 인덱싱 규칙 업데이트 - 메트릭

경고Note: The Tag Indexing Rules feature is currently in Preview. If you have any feedback, contact Datadog support.

PUThttps://api.datadoghq.com/api/v2/metrics/tag-indexing-rules/{id}https://api.us3.datadoghq.com/api/v2/metrics/tag-indexing-rules/{id}https://api.us5.datadoghq.com/api/v2/metrics/tag-indexing-rules/{id}https://api.datadoghq.eu/api/v2/metrics/tag-indexing-rules/{id}https://api.ap1.datadoghq.com/api/v2/metrics/tag-indexing-rules/{id}https://api.ap2.datadoghq.com/api/v2/metrics/tag-indexing-rules/{id}https://api.uk1.datadoghq.com/api/v2/metrics/tag-indexing-rules/{id}https://api.ddog-gov.com/api/v2/metrics/tag-indexing-rules/{id}https://api.us2.ddog-gov.com/api/v2/metrics/tag-indexing-rules/{id}

개요

태그 인덱싱 규칙을 부분적으로 업데이트합니다. 요청 본문에서 생략된 필드는 변경되지 않은 상태로 유지됩니다. rule_order를 다른 규칙에서 이미 사용 중인 값으로 설정하면 409가 반환됩니다. 원자적 재정렬에 재정렬 엔드포인트를 사용합니다. Manage Tags for Metrics 권한이 필요합니다.

This endpoint requires the metric_tags_write permission.

OAuth apps require the metric_tags_write authorization scope to access this endpoint.

인수

경로 파라미터

이름

유형

설명

id [required]

string

ID of the tag indexing rule.

요청

Body Data (required)

항목

유형

설명

data [required]

object

태그 인덱싱 규칙 업데이트를 위한 요청 본문입니다.

attributes

object

Attributes for updating a tag indexing rule. All fields are optional; omitted fields are unchanged.

exclude_tags_mode

boolean

When true, the rule excludes the listed tags and indexes all others.

ignored_metric_name_matches

[string]

Metric name prefixes excluded from the rule's scope.

metric_name_matches

[string]

Metric name prefixes (glob patterns) this rule applies to.

name

string

Human-readable name for the rule.

options

object

Versioned configuration options for a tag indexing rule.

rule_order

int64

Desired evaluation order. Returns 409 if the value conflicts with another rule; use POST /api/v2/metrics/tag-indexing-rules/order for atomic re-sequencing.

tags

[string]

Tag keys managed by this rule.

type [required]

enum

The tag indexing rule resource type.

Default: tag_indexing_rules

Allowed enum values: tag_indexing_rules

Update a tag indexing rule returns "OK" response

{
  "data": {
    "attributes": {
      "ignored_metric_name_matches": [],
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "options": {
        "data": {
          "dynamic_tags": {},
          "manage_preexisting_metrics": true,
          "metric_match": {
            "queried_window_seconds": 3600
          },
          "override_previous_rules": false
        },
        "version": 1
      },
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}

Update a tag indexing rule with exclude-mode tag usage fields returns "OK" response

{
  "data": {
    "attributes": {
      "exclude_tags_mode": true,
      "ignored_metric_name_matches": [],
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "options": {
        "data": {
          "dynamic_tags": {
            "exclude_not_queried_window_seconds": 7200,
            "exclude_not_used_in_assets": true
          },
          "manage_preexisting_metrics": true,
          "override_previous_rules": false
        },
        "version": 1
      },
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}

응답

Response containing a single tag indexing rule.

항목

유형

설명

data

object

A tag indexing rule resource object.

attributes

object

Attributes of a tag indexing rule.

created_at

date-time

Timestamp when the rule was created.

created_by_handle

string

Handle of the user who created the rule.

exclude_tags_mode

boolean

When true, the rule excludes the listed tags and indexes all others. When false (default), the rule includes only the listed tags.

ignored_metric_name_matches

[string]

Metric name prefixes excluded from the rule's scope.

metric_name_matches

[string]

Metric name prefixes (glob patterns) this rule applies to.

modified_at

date-time

Timestamp when the rule was last modified.

modified_by_handle

string

Handle of the user who last modified the rule.

name

string

Human-readable name for the rule.

options

object

Versioned configuration options for a tag indexing rule.

rule_order

int64

Evaluation order within the org. Lower values are evaluated first. Assigned server-side on create (max+1); pass on update to change the rule's position.

tags

[string]

Tag keys managed by this rule.

id

string

The unique identifier (UUID) of the tag indexing rule.

type

enum

The tag indexing rule resource type.

Default: tag_indexing_rules

Allowed enum values: tag_indexing_rules

{
  "data": {
    "attributes": {
      "created_at": "2024-01-15T12:00:00.000Z",
      "created_by_handle": "user@datadoghq.com",
      "exclude_tags_mode": false,
      "ignored_metric_name_matches": [
        "dd.test.excluded.*"
      ],
      "metric_name_matches": [
        "dd.test.*"
      ],
      "modified_at": "2024-01-15T12:00:00.000Z",
      "modified_by_handle": "user@datadoghq.com",
      "name": "my-indexing-rule",
      "options": {
        "data": {
          "dynamic_tags": {
            "exclude_not_queried_window_seconds": 3600,
            "exclude_not_used_in_assets": false
          },
          "manage_preexisting_metrics": true,
          "metric_match": {
            "is_queried": false,
            "not_queried": false,
            "not_used_in_assets": false,
            "queried_window_seconds": 3600,
            "used_in_assets": false
          },
          "override_previous_rules": false
        },
        "version": 1
      },
      "rule_order": 1,
      "tags": [
        "env",
        "service"
      ]
    },
    "id": "00000000-0000-0000-0000-000000000001",
    "type": "tag_indexing_rules"
  }
}

Bad Request

API error response.

항목

유형

설명

errors [required]

[object]

A list of errors.

{
  "errors": [
    {
      "detail": "Missing required attribute in body",
      "meta": {},
      "source": {
        "header": "Authorization",
        "parameter": "limit",
        "pointer": "/data/attributes/title"
      },
      "status": "400",
      "title": "Bad Request"
    }
  ]
}

Forbidden

API error response.

항목

유형

설명

errors [required]

[object]

A list of errors.

{
  "errors": [
    {
      "detail": "Missing required attribute in body",
      "meta": {},
      "source": {
        "header": "Authorization",
        "parameter": "limit",
        "pointer": "/data/attributes/title"
      },
      "status": "400",
      "title": "Bad Request"
    }
  ]
}

Not Found

API error response.

항목

유형

설명

errors [required]

[object]

A list of errors.

{
  "errors": [
    {
      "detail": "Missing required attribute in body",
      "meta": {},
      "source": {
        "header": "Authorization",
        "parameter": "limit",
        "pointer": "/data/attributes/title"
      },
      "status": "400",
      "title": "Bad Request"
    }
  ]
}

Conflict

API error response.

항목

유형

설명

errors [required]

[object]

A list of errors.

{
  "errors": [
    {
      "detail": "Missing required attribute in body",
      "meta": {},
      "source": {
        "header": "Authorization",
        "parameter": "limit",
        "pointer": "/data/attributes/title"
      },
      "status": "400",
      "title": "Bad Request"
    }
  ]
}

Too Many Requests

API error response.

항목

유형

설명

errors [required]

[object]

A list of errors.

{
  "errors": [
    {
      "detail": "Missing required attribute in body",
      "meta": {},
      "source": {
        "header": "Authorization",
        "parameter": "limit",
        "pointer": "/data/attributes/title"
      },
      "status": "400",
      "title": "Bad Request"
    }
  ]
}

코드 예시

Update a tag indexing rule returns "OK" response

# Path parameters
export id="00000000-0000-0000-0000-000000000001"

# Set your Datadog site and credentials
export DD_SITE="datadoghq.com"
# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

curl -X PUT "https://api.${DD_SITE}/api/v2/metrics/tag-indexing-rules/${id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "ignored_metric_name_matches": [],
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "options": {
        "data": {
          "dynamic_tags": {},
          "manage_preexisting_metrics": true,
          "metric_match": {
            "queried_window_seconds": 3600
          },
          "override_previous_rules": false
        },
        "version": 1
      },
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}
EOF

# Path parameters
export id="00000000-0000-0000-0000-000000000001"

# Set your Datadog site and credentials
export DD_SITE="us3.datadoghq.com"
# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

curl -X PUT "https://api.${DD_SITE}/api/v2/metrics/tag-indexing-rules/${id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "ignored_metric_name_matches": [],
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "options": {
        "data": {
          "dynamic_tags": {},
          "manage_preexisting_metrics": true,
          "metric_match": {
            "queried_window_seconds": 3600
          },
          "override_previous_rules": false
        },
        "version": 1
      },
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}
EOF

# Path parameters
export id="00000000-0000-0000-0000-000000000001"

# Set your Datadog site and credentials
export DD_SITE="us5.datadoghq.com"
# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

curl -X PUT "https://api.${DD_SITE}/api/v2/metrics/tag-indexing-rules/${id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "ignored_metric_name_matches": [],
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "options": {
        "data": {
          "dynamic_tags": {},
          "manage_preexisting_metrics": true,
          "metric_match": {
            "queried_window_seconds": 3600
          },
          "override_previous_rules": false
        },
        "version": 1
      },
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}
EOF

# Path parameters
export id="00000000-0000-0000-0000-000000000001"

# Set your Datadog site and credentials
export DD_SITE="datadoghq.eu"
# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

curl -X PUT "https://api.${DD_SITE}/api/v2/metrics/tag-indexing-rules/${id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "ignored_metric_name_matches": [],
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "options": {
        "data": {
          "dynamic_tags": {},
          "manage_preexisting_metrics": true,
          "metric_match": {
            "queried_window_seconds": 3600
          },
          "override_previous_rules": false
        },
        "version": 1
      },
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}
EOF

# Path parameters
export id="00000000-0000-0000-0000-000000000001"

# Set your Datadog site and credentials
export DD_SITE="ap1.datadoghq.com"
# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

curl -X PUT "https://api.${DD_SITE}/api/v2/metrics/tag-indexing-rules/${id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "ignored_metric_name_matches": [],
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "options": {
        "data": {
          "dynamic_tags": {},
          "manage_preexisting_metrics": true,
          "metric_match": {
            "queried_window_seconds": 3600
          },
          "override_previous_rules": false
        },
        "version": 1
      },
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}
EOF

# Path parameters
export id="00000000-0000-0000-0000-000000000001"

# Set your Datadog site and credentials
export DD_SITE="ap2.datadoghq.com"
# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

curl -X PUT "https://api.${DD_SITE}/api/v2/metrics/tag-indexing-rules/${id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "ignored_metric_name_matches": [],
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "options": {
        "data": {
          "dynamic_tags": {},
          "manage_preexisting_metrics": true,
          "metric_match": {
            "queried_window_seconds": 3600
          },
          "override_previous_rules": false
        },
        "version": 1
      },
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}
EOF

# Path parameters
export id="00000000-0000-0000-0000-000000000001"

# Set your Datadog site and credentials
export DD_SITE="uk1.datadoghq.com"
# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

curl -X PUT "https://api.${DD_SITE}/api/v2/metrics/tag-indexing-rules/${id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "ignored_metric_name_matches": [],
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "options": {
        "data": {
          "dynamic_tags": {},
          "manage_preexisting_metrics": true,
          "metric_match": {
            "queried_window_seconds": 3600
          },
          "override_previous_rules": false
        },
        "version": 1
      },
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}
EOF

# Path parameters
export id="00000000-0000-0000-0000-000000000001"

# Set your Datadog site and credentials
export DD_SITE="ddog-gov.com"
# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

curl -X PUT "https://api.${DD_SITE}/api/v2/metrics/tag-indexing-rules/${id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "ignored_metric_name_matches": [],
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "options": {
        "data": {
          "dynamic_tags": {},
          "manage_preexisting_metrics": true,
          "metric_match": {
            "queried_window_seconds": 3600
          },
          "override_previous_rules": false
        },
        "version": 1
      },
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}
EOF

# Path parameters
export id="00000000-0000-0000-0000-000000000001"

# Set your Datadog site and credentials
export DD_SITE="us2.ddog-gov.com"
# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

curl -X PUT "https://api.${DD_SITE}/api/v2/metrics/tag-indexing-rules/${id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "ignored_metric_name_matches": [],
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "options": {
        "data": {
          "dynamic_tags": {},
          "manage_preexisting_metrics": true,
          "metric_match": {
            "queried_window_seconds": 3600
          },
          "override_previous_rules": false
        },
        "version": 1
      },
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}
EOF

Update a tag indexing rule with exclude-mode tag usage fields returns "OK" response

# Path parameters
export id="00000000-0000-0000-0000-000000000001"

# Set your Datadog site and credentials
export DD_SITE="datadoghq.com"
# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

curl -X PUT "https://api.${DD_SITE}/api/v2/metrics/tag-indexing-rules/${id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "exclude_tags_mode": true,
      "ignored_metric_name_matches": [],
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "options": {
        "data": {
          "dynamic_tags": {
            "exclude_not_queried_window_seconds": 7200,
            "exclude_not_used_in_assets": true
          },
          "manage_preexisting_metrics": true,
          "override_previous_rules": false
        },
        "version": 1
      },
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}
EOF

# Path parameters
export id="00000000-0000-0000-0000-000000000001"

# Set your Datadog site and credentials
export DD_SITE="us3.datadoghq.com"
# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

curl -X PUT "https://api.${DD_SITE}/api/v2/metrics/tag-indexing-rules/${id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "exclude_tags_mode": true,
      "ignored_metric_name_matches": [],
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "options": {
        "data": {
          "dynamic_tags": {
            "exclude_not_queried_window_seconds": 7200,
            "exclude_not_used_in_assets": true
          },
          "manage_preexisting_metrics": true,
          "override_previous_rules": false
        },
        "version": 1
      },
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}
EOF

# Path parameters
export id="00000000-0000-0000-0000-000000000001"

# Set your Datadog site and credentials
export DD_SITE="us5.datadoghq.com"
# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

curl -X PUT "https://api.${DD_SITE}/api/v2/metrics/tag-indexing-rules/${id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "exclude_tags_mode": true,
      "ignored_metric_name_matches": [],
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "options": {
        "data": {
          "dynamic_tags": {
            "exclude_not_queried_window_seconds": 7200,
            "exclude_not_used_in_assets": true
          },
          "manage_preexisting_metrics": true,
          "override_previous_rules": false
        },
        "version": 1
      },
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}
EOF

# Path parameters
export id="00000000-0000-0000-0000-000000000001"

# Set your Datadog site and credentials
export DD_SITE="datadoghq.eu"
# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

curl -X PUT "https://api.${DD_SITE}/api/v2/metrics/tag-indexing-rules/${id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "exclude_tags_mode": true,
      "ignored_metric_name_matches": [],
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "options": {
        "data": {
          "dynamic_tags": {
            "exclude_not_queried_window_seconds": 7200,
            "exclude_not_used_in_assets": true
          },
          "manage_preexisting_metrics": true,
          "override_previous_rules": false
        },
        "version": 1
      },
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}
EOF

# Path parameters
export id="00000000-0000-0000-0000-000000000001"

# Set your Datadog site and credentials
export DD_SITE="ap1.datadoghq.com"
# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

curl -X PUT "https://api.${DD_SITE}/api/v2/metrics/tag-indexing-rules/${id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "exclude_tags_mode": true,
      "ignored_metric_name_matches": [],
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "options": {
        "data": {
          "dynamic_tags": {
            "exclude_not_queried_window_seconds": 7200,
            "exclude_not_used_in_assets": true
          },
          "manage_preexisting_metrics": true,
          "override_previous_rules": false
        },
        "version": 1
      },
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}
EOF

# Path parameters
export id="00000000-0000-0000-0000-000000000001"

# Set your Datadog site and credentials
export DD_SITE="ap2.datadoghq.com"
# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

curl -X PUT "https://api.${DD_SITE}/api/v2/metrics/tag-indexing-rules/${id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "exclude_tags_mode": true,
      "ignored_metric_name_matches": [],
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "options": {
        "data": {
          "dynamic_tags": {
            "exclude_not_queried_window_seconds": 7200,
            "exclude_not_used_in_assets": true
          },
          "manage_preexisting_metrics": true,
          "override_previous_rules": false
        },
        "version": 1
      },
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}
EOF

# Path parameters
export id="00000000-0000-0000-0000-000000000001"

# Set your Datadog site and credentials
export DD_SITE="uk1.datadoghq.com"
# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

curl -X PUT "https://api.${DD_SITE}/api/v2/metrics/tag-indexing-rules/${id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "exclude_tags_mode": true,
      "ignored_metric_name_matches": [],
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "options": {
        "data": {
          "dynamic_tags": {
            "exclude_not_queried_window_seconds": 7200,
            "exclude_not_used_in_assets": true
          },
          "manage_preexisting_metrics": true,
          "override_previous_rules": false
        },
        "version": 1
      },
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}
EOF

# Path parameters
export id="00000000-0000-0000-0000-000000000001"

# Set your Datadog site and credentials
export DD_SITE="ddog-gov.com"
# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

curl -X PUT "https://api.${DD_SITE}/api/v2/metrics/tag-indexing-rules/${id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "exclude_tags_mode": true,
      "ignored_metric_name_matches": [],
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "options": {
        "data": {
          "dynamic_tags": {
            "exclude_not_queried_window_seconds": 7200,
            "exclude_not_used_in_assets": true
          },
          "manage_preexisting_metrics": true,
          "override_previous_rules": false
        },
        "version": 1
      },
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}
EOF

# Path parameters
export id="00000000-0000-0000-0000-000000000001"

# Set your Datadog site and credentials
export DD_SITE="us2.ddog-gov.com"
# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

curl -X PUT "https://api.${DD_SITE}/api/v2/metrics/tag-indexing-rules/${id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "exclude_tags_mode": true,
      "ignored_metric_name_matches": [],
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "options": {
        "data": {
          "dynamic_tags": {
            "exclude_not_queried_window_seconds": 7200,
            "exclude_not_used_in_assets": true
          },
          "manage_preexisting_metrics": true,
          "override_previous_rules": false
        },
        "version": 1
      },
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}
EOF

Update a tag indexing rule returns "OK" response

// Update a tag indexing 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 "tag_indexing_rule" in the system
	TagIndexingRuleDataID := os.Getenv("TAG_INDEXING_RULE_DATA_ID")

	body := datadogV2.TagIndexingRuleUpdateRequest{
		Data: datadogV2.TagIndexingRuleUpdateData{
			Attributes: &datadogV2.TagIndexingRuleUpdateAttributes{
				IgnoredMetricNameMatches: []string{},
				MetricNameMatches: []string{
					"dd.test.*",
				},
				Name: datadog.PtrString("my-indexing-rule"),
				Options: &datadogV2.TagIndexingRuleOptions{
					Data: &datadogV2.TagIndexingRuleOptionsData{
						DynamicTags:              &datadogV2.TagIndexingRuleDynamicTags{},
						ManagePreexistingMetrics: datadog.PtrBool(true),
						MetricMatch: &datadogV2.TagIndexingRuleMetricMatch{
							QueriedWindowSeconds: datadog.PtrInt64(3600),
						},
						OverridePreviousRules: datadog.PtrBool(false),
					},
					Version: datadog.PtrInt64(1),
				},
				RuleOrder: datadog.PtrInt64(2),
				Tags: []string{
					"env",
					"service",
				},
			},
			Type: datadogV2.TAGINDEXINGRULETYPE_TAG_INDEXING_RULES,
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	ctx = context.WithValue(ctx, datadog.ContextAccessToken, os.Getenv("DD_BEARER_TOKEN"))
	configuration := datadog.NewConfiguration()
	configuration.SetUnstableOperationEnabled("v2.UpdateTagIndexingRule", true)
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewMetricsApi(apiClient)
	resp, r, err := api.UpdateTagIndexingRule(ctx, TagIndexingRuleDataID, body)

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

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

Update a tag indexing rule with exclude-mode tag usage fields returns "OK" response

// Update a tag indexing rule with exclude-mode tag usage fields 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 "tag_indexing_rule_exclude_mode" in the system
	TagIndexingRuleExcludeModeDataID := os.Getenv("TAG_INDEXING_RULE_EXCLUDE_MODE_DATA_ID")

	body := datadogV2.TagIndexingRuleUpdateRequest{
		Data: datadogV2.TagIndexingRuleUpdateData{
			Attributes: &datadogV2.TagIndexingRuleUpdateAttributes{
				ExcludeTagsMode:          datadog.PtrBool(true),
				IgnoredMetricNameMatches: []string{},
				MetricNameMatches: []string{
					"dd.test.*",
				},
				Name: datadog.PtrString("my-indexing-rule"),
				Options: &datadogV2.TagIndexingRuleOptions{
					Data: &datadogV2.TagIndexingRuleOptionsData{
						DynamicTags: &datadogV2.TagIndexingRuleDynamicTags{
							ExcludeNotQueriedWindowSeconds: datadog.PtrInt64(7200),
							ExcludeNotUsedInAssets:         datadog.PtrBool(true),
						},
						ManagePreexistingMetrics: datadog.PtrBool(true),
						OverridePreviousRules:    datadog.PtrBool(false),
					},
					Version: datadog.PtrInt64(1),
				},
				RuleOrder: datadog.PtrInt64(2),
				Tags: []string{
					"env",
					"service",
				},
			},
			Type: datadogV2.TAGINDEXINGRULETYPE_TAG_INDEXING_RULES,
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	ctx = context.WithValue(ctx, datadog.ContextAccessToken, os.Getenv("DD_BEARER_TOKEN"))
	configuration := datadog.NewConfiguration()
	configuration.SetUnstableOperationEnabled("v2.UpdateTagIndexingRule", true)
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewMetricsApi(apiClient)
	resp, r, err := api.UpdateTagIndexingRule(ctx, TagIndexingRuleExcludeModeDataID, body)

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

	responseContent, _ := json.MarshalIndent(resp, "", "  ")
	fmt.Fprintf(os.Stdout, "Response from `MetricsApi.UpdateTagIndexingRule`:\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.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" go run "main.go"

DD_SITE="us3.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" go run "main.go"

DD_SITE="us5.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" go run "main.go"

DD_SITE="datadoghq.eu" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" go run "main.go"

DD_SITE="ap1.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" go run "main.go"

DD_SITE="ap2.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" go run "main.go"

DD_SITE="uk1.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" go run "main.go"

DD_SITE="ddog-gov.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" go run "main.go"

DD_SITE="us2.ddog-gov.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" go run "main.go"

Update a tag indexing rule returns "OK" response

// Update a tag indexing rule returns "OK" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.MetricsApi;
import com.datadog.api.client.v2.model.TagIndexingRuleDynamicTags;
import com.datadog.api.client.v2.model.TagIndexingRuleMetricMatch;
import com.datadog.api.client.v2.model.TagIndexingRuleOptions;
import com.datadog.api.client.v2.model.TagIndexingRuleOptionsData;
import com.datadog.api.client.v2.model.TagIndexingRuleResponse;
import com.datadog.api.client.v2.model.TagIndexingRuleType;
import com.datadog.api.client.v2.model.TagIndexingRuleUpdateAttributes;
import com.datadog.api.client.v2.model.TagIndexingRuleUpdateData;
import com.datadog.api.client.v2.model.TagIndexingRuleUpdateRequest;
import java.util.Arrays;
import java.util.Collections;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = ApiClient.getDefaultApiClient();
    defaultClient.setAccessToken(System.getenv("DD_BEARER_TOKEN"));
    defaultClient.setUnstableOperationEnabled("v2.updateTagIndexingRule", true);
    MetricsApi apiInstance = new MetricsApi(defaultClient);

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

    TagIndexingRuleUpdateRequest body =
        new TagIndexingRuleUpdateRequest()
            .data(
                new TagIndexingRuleUpdateData()
                    .attributes(
                        new TagIndexingRuleUpdateAttributes()
                            .metricNameMatches(Collections.singletonList("dd.test.*"))
                            .name("my-indexing-rule")
                            .options(
                                new TagIndexingRuleOptions()
                                    .data(
                                        new TagIndexingRuleOptionsData()
                                            .dynamicTags(new TagIndexingRuleDynamicTags())
                                            .managePreexistingMetrics(true)
                                            .metricMatch(
                                                new TagIndexingRuleMetricMatch()
                                                    .queriedWindowSeconds(3600L))
                                            .overridePreviousRules(false))
                                    .version(1L))
                            .ruleOrder(2L)
                            .tags(Arrays.asList("env", "service")))
                    .type(TagIndexingRuleType.TAG_INDEXING_RULES));

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

Update a tag indexing rule with exclude-mode tag usage fields returns "OK" response

// Update a tag indexing rule with exclude-mode tag usage fields returns "OK" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.MetricsApi;
import com.datadog.api.client.v2.model.TagIndexingRuleDynamicTags;
import com.datadog.api.client.v2.model.TagIndexingRuleOptions;
import com.datadog.api.client.v2.model.TagIndexingRuleOptionsData;
import com.datadog.api.client.v2.model.TagIndexingRuleResponse;
import com.datadog.api.client.v2.model.TagIndexingRuleType;
import com.datadog.api.client.v2.model.TagIndexingRuleUpdateAttributes;
import com.datadog.api.client.v2.model.TagIndexingRuleUpdateData;
import com.datadog.api.client.v2.model.TagIndexingRuleUpdateRequest;
import java.util.Arrays;
import java.util.Collections;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = ApiClient.getDefaultApiClient();
    defaultClient.setAccessToken(System.getenv("DD_BEARER_TOKEN"));
    defaultClient.setUnstableOperationEnabled("v2.updateTagIndexingRule", true);
    MetricsApi apiInstance = new MetricsApi(defaultClient);

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

    TagIndexingRuleUpdateRequest body =
        new TagIndexingRuleUpdateRequest()
            .data(
                new TagIndexingRuleUpdateData()
                    .attributes(
                        new TagIndexingRuleUpdateAttributes()
                            .excludeTagsMode(true)
                            .metricNameMatches(Collections.singletonList("dd.test.*"))
                            .name("my-indexing-rule")
                            .options(
                                new TagIndexingRuleOptions()
                                    .data(
                                        new TagIndexingRuleOptionsData()
                                            .dynamicTags(
                                                new TagIndexingRuleDynamicTags()
                                                    .excludeNotQueriedWindowSeconds(7200L)
                                                    .excludeNotUsedInAssets(true))
                                            .managePreexistingMetrics(true)
                                            .overridePreviousRules(false))
                                    .version(1L))
                            .ruleOrder(2L)
                            .tags(Arrays.asList("env", "service")))
                    .type(TagIndexingRuleType.TAG_INDEXING_RULES));

    try {
      TagIndexingRuleResponse result =
          apiInstance.updateTagIndexingRule(TAG_INDEXING_RULE_EXCLUDE_MODE_DATA_ID, body);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling MetricsApi#updateTagIndexingRule");
      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.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" java "Example.java"

DD_SITE="us3.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" java "Example.java"

DD_SITE="us5.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" java "Example.java"

DD_SITE="datadoghq.eu" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" java "Example.java"

DD_SITE="ap1.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" java "Example.java"

DD_SITE="ap2.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" java "Example.java"

DD_SITE="uk1.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" java "Example.java"

DD_SITE="ddog-gov.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" java "Example.java"

DD_SITE="us2.ddog-gov.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" java "Example.java"

Update a tag indexing rule returns "OK" response

"""
Update a tag indexing rule returns "OK" response
"""

from os import environ
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.metrics_api import MetricsApi
from datadog_api_client.v2.model.tag_indexing_rule_dynamic_tags import TagIndexingRuleDynamicTags
from datadog_api_client.v2.model.tag_indexing_rule_metric_match import TagIndexingRuleMetricMatch
from datadog_api_client.v2.model.tag_indexing_rule_options import TagIndexingRuleOptions
from datadog_api_client.v2.model.tag_indexing_rule_options_data import TagIndexingRuleOptionsData
from datadog_api_client.v2.model.tag_indexing_rule_type import TagIndexingRuleType
from datadog_api_client.v2.model.tag_indexing_rule_update_attributes import TagIndexingRuleUpdateAttributes
from datadog_api_client.v2.model.tag_indexing_rule_update_data import TagIndexingRuleUpdateData
from datadog_api_client.v2.model.tag_indexing_rule_update_request import TagIndexingRuleUpdateRequest

# there is a valid "tag_indexing_rule" in the system
TAG_INDEXING_RULE_DATA_ID = environ["TAG_INDEXING_RULE_DATA_ID"]

body = TagIndexingRuleUpdateRequest(
    data=TagIndexingRuleUpdateData(
        attributes=TagIndexingRuleUpdateAttributes(
            ignored_metric_name_matches=[],
            metric_name_matches=[
                "dd.test.*",
            ],
            name="my-indexing-rule",
            options=TagIndexingRuleOptions(
                data=TagIndexingRuleOptionsData(
                    dynamic_tags=TagIndexingRuleDynamicTags(),
                    manage_preexisting_metrics=True,
                    metric_match=TagIndexingRuleMetricMatch(
                        queried_window_seconds=3600,
                    ),
                    override_previous_rules=False,
                ),
                version=1,
            ),
            rule_order=2,
            tags=[
                "env",
                "service",
            ],
        ),
        type=TagIndexingRuleType.TAG_INDEXING_RULES,
    ),
)

configuration = Configuration()
configuration.access_token = environ["DD_BEARER_TOKEN"]
configuration.unstable_operations["update_tag_indexing_rule"] = True
with ApiClient(configuration) as api_client:
    api_instance = MetricsApi(api_client)
    response = api_instance.update_tag_indexing_rule(id=TAG_INDEXING_RULE_DATA_ID, body=body)

    print(response)

Update a tag indexing rule with exclude-mode tag usage fields returns "OK" response

"""
Update a tag indexing rule with exclude-mode tag usage fields returns "OK" response
"""

from os import environ
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.metrics_api import MetricsApi
from datadog_api_client.v2.model.tag_indexing_rule_dynamic_tags import TagIndexingRuleDynamicTags
from datadog_api_client.v2.model.tag_indexing_rule_options import TagIndexingRuleOptions
from datadog_api_client.v2.model.tag_indexing_rule_options_data import TagIndexingRuleOptionsData
from datadog_api_client.v2.model.tag_indexing_rule_type import TagIndexingRuleType
from datadog_api_client.v2.model.tag_indexing_rule_update_attributes import TagIndexingRuleUpdateAttributes
from datadog_api_client.v2.model.tag_indexing_rule_update_data import TagIndexingRuleUpdateData
from datadog_api_client.v2.model.tag_indexing_rule_update_request import TagIndexingRuleUpdateRequest

# there is a valid "tag_indexing_rule_exclude_mode" in the system
TAG_INDEXING_RULE_EXCLUDE_MODE_DATA_ID = environ["TAG_INDEXING_RULE_EXCLUDE_MODE_DATA_ID"]

body = TagIndexingRuleUpdateRequest(
    data=TagIndexingRuleUpdateData(
        attributes=TagIndexingRuleUpdateAttributes(
            exclude_tags_mode=True,
            ignored_metric_name_matches=[],
            metric_name_matches=[
                "dd.test.*",
            ],
            name="my-indexing-rule",
            options=TagIndexingRuleOptions(
                data=TagIndexingRuleOptionsData(
                    dynamic_tags=TagIndexingRuleDynamicTags(
                        exclude_not_queried_window_seconds=7200,
                        exclude_not_used_in_assets=True,
                    ),
                    manage_preexisting_metrics=True,
                    override_previous_rules=False,
                ),
                version=1,
            ),
            rule_order=2,
            tags=[
                "env",
                "service",
            ],
        ),
        type=TagIndexingRuleType.TAG_INDEXING_RULES,
    ),
)

configuration = Configuration()
configuration.access_token = environ["DD_BEARER_TOKEN"]
configuration.unstable_operations["update_tag_indexing_rule"] = True
with ApiClient(configuration) as api_client:
    api_instance = MetricsApi(api_client)
    response = api_instance.update_tag_indexing_rule(id=TAG_INDEXING_RULE_EXCLUDE_MODE_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.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" python3 "example.py"

DD_SITE="us3.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" python3 "example.py"

DD_SITE="us5.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" python3 "example.py"

DD_SITE="datadoghq.eu" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" python3 "example.py"

DD_SITE="ap1.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" python3 "example.py"

DD_SITE="ap2.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" python3 "example.py"

DD_SITE="uk1.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" python3 "example.py"

DD_SITE="ddog-gov.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" python3 "example.py"

DD_SITE="us2.ddog-gov.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" python3 "example.py"

Update a tag indexing rule returns "OK" response

# Update a tag indexing rule returns "OK" response

require "datadog_api_client"
DatadogAPIClient.configure do |config|
  config.access_token = ENV["DD_BEARER_TOKEN"]
  config.unstable_operations["v2.update_tag_indexing_rule".to_sym] = true
end
api_instance = DatadogAPIClient::V2::MetricsAPI.new

# there is a valid "tag_indexing_rule" in the system
TAG_INDEXING_RULE_DATA_ID = ENV["TAG_INDEXING_RULE_DATA_ID"]

body = DatadogAPIClient::V2::TagIndexingRuleUpdateRequest.new({
  data: DatadogAPIClient::V2::TagIndexingRuleUpdateData.new({
    attributes: DatadogAPIClient::V2::TagIndexingRuleUpdateAttributes.new({
      ignored_metric_name_matches: [],
      metric_name_matches: [
        "dd.test.*",
      ],
      name: "my-indexing-rule",
      options: DatadogAPIClient::V2::TagIndexingRuleOptions.new({
        data: DatadogAPIClient::V2::TagIndexingRuleOptionsData.new({
          dynamic_tags: DatadogAPIClient::V2::TagIndexingRuleDynamicTags.new({}),
          manage_preexisting_metrics: true,
          metric_match: DatadogAPIClient::V2::TagIndexingRuleMetricMatch.new({
            queried_window_seconds: 3600,
          }),
          override_previous_rules: false,
        }),
        version: 1,
      }),
      rule_order: 2,
      tags: [
        "env",
        "service",
      ],
    }),
    type: DatadogAPIClient::V2::TagIndexingRuleType::TAG_INDEXING_RULES,
  }),
})
p api_instance.update_tag_indexing_rule(TAG_INDEXING_RULE_DATA_ID, body)

Update a tag indexing rule with exclude-mode tag usage fields returns "OK" response

# Update a tag indexing rule with exclude-mode tag usage fields returns "OK" response

require "datadog_api_client"
DatadogAPIClient.configure do |config|
  config.access_token = ENV["DD_BEARER_TOKEN"]
  config.unstable_operations["v2.update_tag_indexing_rule".to_sym] = true
end
api_instance = DatadogAPIClient::V2::MetricsAPI.new

# there is a valid "tag_indexing_rule_exclude_mode" in the system
TAG_INDEXING_RULE_EXCLUDE_MODE_DATA_ID = ENV["TAG_INDEXING_RULE_EXCLUDE_MODE_DATA_ID"]

body = DatadogAPIClient::V2::TagIndexingRuleUpdateRequest.new({
  data: DatadogAPIClient::V2::TagIndexingRuleUpdateData.new({
    attributes: DatadogAPIClient::V2::TagIndexingRuleUpdateAttributes.new({
      exclude_tags_mode: true,
      ignored_metric_name_matches: [],
      metric_name_matches: [
        "dd.test.*",
      ],
      name: "my-indexing-rule",
      options: DatadogAPIClient::V2::TagIndexingRuleOptions.new({
        data: DatadogAPIClient::V2::TagIndexingRuleOptionsData.new({
          dynamic_tags: DatadogAPIClient::V2::TagIndexingRuleDynamicTags.new({
            exclude_not_queried_window_seconds: 7200,
            exclude_not_used_in_assets: true,
          }),
          manage_preexisting_metrics: true,
          override_previous_rules: false,
        }),
        version: 1,
      }),
      rule_order: 2,
      tags: [
        "env",
        "service",
      ],
    }),
    type: DatadogAPIClient::V2::TagIndexingRuleType::TAG_INDEXING_RULES,
  }),
})
p api_instance.update_tag_indexing_rule(TAG_INDEXING_RULE_EXCLUDE_MODE_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.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" rb "example.rb"

DD_SITE="us3.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" rb "example.rb"

DD_SITE="us5.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" rb "example.rb"

DD_SITE="datadoghq.eu" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" rb "example.rb"

DD_SITE="ap1.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" rb "example.rb"

DD_SITE="ap2.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" rb "example.rb"

DD_SITE="uk1.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" rb "example.rb"

DD_SITE="ddog-gov.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" rb "example.rb"

DD_SITE="us2.ddog-gov.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" rb "example.rb"

Update a tag indexing rule returns "OK" response

// Update a tag indexing rule returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_metrics::MetricsAPI;
use datadog_api_client::datadogV2::model::TagIndexingRuleDynamicTags;
use datadog_api_client::datadogV2::model::TagIndexingRuleMetricMatch;
use datadog_api_client::datadogV2::model::TagIndexingRuleOptions;
use datadog_api_client::datadogV2::model::TagIndexingRuleOptionsData;
use datadog_api_client::datadogV2::model::TagIndexingRuleType;
use datadog_api_client::datadogV2::model::TagIndexingRuleUpdateAttributes;
use datadog_api_client::datadogV2::model::TagIndexingRuleUpdateData;
use datadog_api_client::datadogV2::model::TagIndexingRuleUpdateRequest;

#[tokio::main]
async fn main() {
    // there is a valid "tag_indexing_rule" in the system
    let tag_indexing_rule_data_id = std::env::var("TAG_INDEXING_RULE_DATA_ID").unwrap();
    let body = TagIndexingRuleUpdateRequest::new(
        TagIndexingRuleUpdateData::new(TagIndexingRuleType::TAG_INDEXING_RULES).attributes(
            TagIndexingRuleUpdateAttributes::new()
                .ignored_metric_name_matches(vec![])
                .metric_name_matches(vec!["dd.test.*".to_string()])
                .name("my-indexing-rule".to_string())
                .options(
                    TagIndexingRuleOptions::new()
                        .data(
                            TagIndexingRuleOptionsData::new()
                                .dynamic_tags(TagIndexingRuleDynamicTags::new())
                                .manage_preexisting_metrics(true)
                                .metric_match(
                                    TagIndexingRuleMetricMatch::new().queried_window_seconds(3600),
                                )
                                .override_previous_rules(false),
                        )
                        .version(1),
                )
                .rule_order(2)
                .tags(vec!["env".to_string(), "service".to_string()]),
        ),
    );
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled("v2.update_tag_indexing_rule", true);
    let api = MetricsAPI::with_config(configuration);
    let resp = api
        .update_tag_indexing_rule(tag_indexing_rule_data_id.clone(), body)
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

Update a tag indexing rule with exclude-mode tag usage fields returns "OK" response

// Update a tag indexing rule with exclude-mode tag usage fields returns "OK"
// response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_metrics::MetricsAPI;
use datadog_api_client::datadogV2::model::TagIndexingRuleDynamicTags;
use datadog_api_client::datadogV2::model::TagIndexingRuleOptions;
use datadog_api_client::datadogV2::model::TagIndexingRuleOptionsData;
use datadog_api_client::datadogV2::model::TagIndexingRuleType;
use datadog_api_client::datadogV2::model::TagIndexingRuleUpdateAttributes;
use datadog_api_client::datadogV2::model::TagIndexingRuleUpdateData;
use datadog_api_client::datadogV2::model::TagIndexingRuleUpdateRequest;

#[tokio::main]
async fn main() {
    // there is a valid "tag_indexing_rule_exclude_mode" in the system
    let tag_indexing_rule_exclude_mode_data_id =
        std::env::var("TAG_INDEXING_RULE_EXCLUDE_MODE_DATA_ID").unwrap();
    let body = TagIndexingRuleUpdateRequest::new(
        TagIndexingRuleUpdateData::new(TagIndexingRuleType::TAG_INDEXING_RULES).attributes(
            TagIndexingRuleUpdateAttributes::new()
                .exclude_tags_mode(true)
                .ignored_metric_name_matches(vec![])
                .metric_name_matches(vec!["dd.test.*".to_string()])
                .name("my-indexing-rule".to_string())
                .options(
                    TagIndexingRuleOptions::new()
                        .data(
                            TagIndexingRuleOptionsData::new()
                                .dynamic_tags(
                                    TagIndexingRuleDynamicTags::new()
                                        .exclude_not_queried_window_seconds(7200)
                                        .exclude_not_used_in_assets(true),
                                )
                                .manage_preexisting_metrics(true)
                                .override_previous_rules(false),
                        )
                        .version(1),
                )
                .rule_order(2)
                .tags(vec!["env".to_string(), "service".to_string()]),
        ),
    );
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled("v2.update_tag_indexing_rule", true);
    let api = MetricsAPI::with_config(configuration);
    let resp = api
        .update_tag_indexing_rule(tag_indexing_rule_exclude_mode_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.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" cargo run

DD_SITE="us3.datadoghq.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" cargo run

DD_SITE="us5.datadoghq.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" cargo run

DD_SITE="datadoghq.eu" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" cargo run

DD_SITE="ap1.datadoghq.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" cargo run

DD_SITE="ap2.datadoghq.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" cargo run

DD_SITE="uk1.datadoghq.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" cargo run

DD_SITE="ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" cargo run

DD_SITE="us2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" cargo run

Update a tag indexing rule returns "OK" response

/**
 * Update a tag indexing rule returns "OK" response
 */

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

const configuration = client.createConfiguration({
  authMethods: {
    AuthZ: {
      accessToken: process.env.DD_BEARER_TOKEN as string,
    },
  },
});
configuration.unstableOperations["v2.updateTagIndexingRule"] = true;
const apiInstance = new v2.MetricsApi(configuration);

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

const params: v2.MetricsApiUpdateTagIndexingRuleRequest = {
  body: {
    data: {
      attributes: {
        ignoredMetricNameMatches: [],
        metricNameMatches: ["dd.test.*"],
        name: "my-indexing-rule",
        options: {
          data: {
            dynamicTags: {},
            managePreexistingMetrics: true,
            metricMatch: {
              queriedWindowSeconds: 3600,
            },
            overridePreviousRules: false,
          },
          version: 1,
        },
        ruleOrder: 2,
        tags: ["env", "service"],
      },
      type: "tag_indexing_rules",
    },
  },
  id: TAG_INDEXING_RULE_DATA_ID,
};

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

Update a tag indexing rule with exclude-mode tag usage fields returns "OK" response

/**
 * Update a tag indexing rule with exclude-mode tag usage fields returns "OK" response
 */

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

const configuration = client.createConfiguration({
  authMethods: {
    AuthZ: {
      accessToken: process.env.DD_BEARER_TOKEN as string,
    },
  },
});
configuration.unstableOperations["v2.updateTagIndexingRule"] = true;
const apiInstance = new v2.MetricsApi(configuration);

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

const params: v2.MetricsApiUpdateTagIndexingRuleRequest = {
  body: {
    data: {
      attributes: {
        excludeTagsMode: true,
        ignoredMetricNameMatches: [],
        metricNameMatches: ["dd.test.*"],
        name: "my-indexing-rule",
        options: {
          data: {
            dynamicTags: {
              excludeNotQueriedWindowSeconds: 7200,
              excludeNotUsedInAssets: true,
            },
            managePreexistingMetrics: true,
            overridePreviousRules: false,
          },
          version: 1,
        },
        ruleOrder: 2,
        tags: ["env", "service"],
      },
      type: "tag_indexing_rules",
    },
  },
  id: TAG_INDEXING_RULE_EXCLUDE_MODE_DATA_ID,
};

apiInstance
  .updateTagIndexingRule(params)
  .then((data: v2.TagIndexingRuleResponse) => {
    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.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" tsc "example.ts"

DD_SITE="us3.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" tsc "example.ts"

DD_SITE="us5.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" tsc "example.ts"

DD_SITE="datadoghq.eu" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" tsc "example.ts"

DD_SITE="ap1.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" tsc "example.ts"

DD_SITE="ap2.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" tsc "example.ts"

DD_SITE="uk1.datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" tsc "example.ts"

DD_SITE="ddog-gov.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" tsc "example.ts"

DD_SITE="us2.ddog-gov.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" tsc "example.ts"