Language

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

Datadog Site

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

Create a tag indexing rule

copy ページをコピーコピーしました

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

POST https://api.ap1.datadoghq.com/api/v2/metrics/tag-indexing-ruleshttps://api.ap2.datadoghq.com/api/v2/metrics/tag-indexing-ruleshttps://api.datadoghq.eu/api/v2/metrics/tag-indexing-ruleshttps://api.ddog-gov.com/api/v2/metrics/tag-indexing-ruleshttps://api.us2.ddog-gov.com/api/v2/metrics/tag-indexing-ruleshttps://api.uk1.datadoghq.com/api/v2/metrics/tag-indexing-ruleshttps://api.datadoghq.com/api/v2/metrics/tag-indexing-ruleshttps://api.us3.datadoghq.com/api/v2/metrics/tag-indexing-ruleshttps://api.us5.datadoghq.com/api/v2/metrics/tag-indexing-rules

概要

Create a tag indexing rule for the org. rule_order is assigned server-side as max+1 among existing rules; use the reorder endpoint to change the evaluation order. Requires the Manage Tags for Metrics permission. This endpoint requires the metric_tags_write permission.

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

リクエスト

Body Data (required)

Expand All

フィールド

タイプ

説明

data [required]

object

Data object for creating a tag indexing rule.

attributes [required]

object

Attributes for creating a tag indexing 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 [required]

[string]

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

name [required]

string

Human-readable name for the rule.

options

object

Versioned configuration options for a tag indexing rule.

data

object

Data payload for tag indexing rule options.

dynamic_tags

object

Options for dynamic tag indexing applied per metric, such as tags filtered by query usage.

Before a tag key is dropped by this rule, two grace period conditions must be met:

  1. The metric must be submitted for at least as long as the selected window.
  2. A tag key must have been submitted for at least 15 days.

Any metric or tag key that does not meet these conditions are excluded from this indexing rule. The exclude_not_* fields require exclude_tags_mode to be set to true.

exclude_not_queried_window_seconds

int64

Tags that have not been queried within this window are excluded from indexing. Maximum of 7776000 (90 days).

exclude_not_used_in_assets

boolean

Tags not used in any dashboards, monitors, notebooks, or SLOs are excluded from indexing.

manage_preexisting_metrics

boolean

When true, the rule applies to metrics that were ingested before the rule was created.

metric_match

object

Criteria for matching metrics based on query state.

is_queried

boolean

Match metrics that are being queried.

not_queried

boolean

Match metrics that are not being queried.

not_used_in_assets

boolean

Match metrics not used in any dashboards or monitors.

queried_window_seconds

int64

Window in seconds for evaluating query state.

used_in_assets

boolean

Match metrics used in dashboards or monitors.

override_previous_rules

boolean

When true, this rule's tag list overrides tags configured by earlier rules for the same metric. When false (default), tags from all matching rules are combined.

version

int64

Options schema version. Only 1 is supported.

tags

[string]

Tag keys managed by this rule.

type [required]

enum

The tag indexing rule resource type. Allowed enum values: tag_indexing_rules

default: tag_indexing_rules

{
  "data": {
    "attributes": {
      "exclude_tags_mode": false,
      "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"
  }
}
{
  "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": 3600,
            "exclude_not_used_in_assets": true
          },
          "manage_preexisting_metrics": true,
          "override_previous_rules": false
        },
        "version": 1
      },
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}

応答

Created

Response containing a single tag indexing rule.

Expand All

フィールド

タイプ

説明

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.

data

object

Data payload for tag indexing rule options.

dynamic_tags

object

Options for dynamic tag indexing applied per metric, such as tags filtered by query usage.

Before a tag key is dropped by this rule, two grace period conditions must be met:

  1. The metric must be submitted for at least as long as the selected window.
  2. A tag key must have been submitted for at least 15 days.

Any metric or tag key that does not meet these conditions are excluded from this indexing rule. The exclude_not_* fields require exclude_tags_mode to be set to true.

exclude_not_queried_window_seconds

int64

Tags that have not been queried within this window are excluded from indexing. Maximum of 7776000 (90 days).

exclude_not_used_in_assets

boolean

Tags not used in any dashboards, monitors, notebooks, or SLOs are excluded from indexing.

manage_preexisting_metrics

boolean

When true, the rule applies to metrics that were ingested before the rule was created.

metric_match

object

Criteria for matching metrics based on query state.

is_queried

boolean

Match metrics that are being queried.

not_queried

boolean

Match metrics that are not being queried.

not_used_in_assets

boolean

Match metrics not used in any dashboards or monitors.

queried_window_seconds

int64

Window in seconds for evaluating query state.

used_in_assets

boolean

Match metrics used in dashboards or monitors.

override_previous_rules

boolean

When true, this rule's tag list overrides tags configured by earlier rules for the same metric. When false (default), tags from all matching rules are combined.

version

int64

Options schema version. Only 1 is supported.

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. Allowed enum values: tag_indexing_rules

default: 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.

Expand All

フィールド

タイプ

説明

errors [required]

[object]

A list of errors.

detail

string

A human-readable explanation specific to this occurrence of the error.

meta

object

Non-standard meta-information about the error

source

object

References to the source of the error.

header

string

A string indicating the name of a single request header which caused the error.

parameter

string

A string indicating which URI query parameter caused the error.

pointer

string

A JSON pointer to the value in the request document that caused the error.

status

string

Status code of the response.

title

string

Short human-readable summary of the error.

{
  "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.

Expand All

フィールド

タイプ

説明

errors [required]

[object]

A list of errors.

detail

string

A human-readable explanation specific to this occurrence of the error.

meta

object

Non-standard meta-information about the error

source

object

References to the source of the error.

header

string

A string indicating the name of a single request header which caused the error.

parameter

string

A string indicating which URI query parameter caused the error.

pointer

string

A JSON pointer to the value in the request document that caused the error.

status

string

Status code of the response.

title

string

Short human-readable summary of the error.

{
  "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.

Expand All

フィールド

タイプ

説明

errors [required]

[object]

A list of errors.

detail

string

A human-readable explanation specific to this occurrence of the error.

meta

object

Non-standard meta-information about the error

source

object

References to the source of the error.

header

string

A string indicating the name of a single request header which caused the error.

parameter

string

A string indicating which URI query parameter caused the error.

pointer

string

A JSON pointer to the value in the request document that caused the error.

status

string

Status code of the response.

title

string

Short human-readable summary of the error.

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

コード例

                          ## default
# 

# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

# Curl command
curl -X POST "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.uk1.datadoghq.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v2/metrics/tag-indexing-rules" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}
EOF

                        
                          ## default
# 

# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

# Curl command
curl -X POST "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.uk1.datadoghq.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v2/metrics/tag-indexing-rules" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "metric_name_matches": [
        "dd.test.*"
      ],
      "name": "my-indexing-rule",
      "tags": [
        "env",
        "service"
      ]
    },
    "type": "tag_indexing_rules"
  }
}
EOF

                        
// Create a tag indexing rule returns "Created" 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() {
	body := datadogV2.TagIndexingRuleCreateRequest{
		Data: datadogV2.TagIndexingRuleCreateData{
			Attributes: datadogV2.TagIndexingRuleCreateAttributes{
				ExcludeTagsMode:          datadog.PtrBool(false),
				IgnoredMetricNameMatches: []string{},
				MetricNameMatches: []string{
					"dd.test.*",
				},
				Name: "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),
				},
				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.CreateTagIndexingRule", true)
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewMetricsApi(apiClient)
	resp, r, err := api.CreateTagIndexingRule(ctx, body)

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

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

// Create a tag indexing rule with exclude-mode tag usage fields returns "Created" 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() {
	body := datadogV2.TagIndexingRuleCreateRequest{
		Data: datadogV2.TagIndexingRuleCreateData{
			Attributes: datadogV2.TagIndexingRuleCreateAttributes{
				ExcludeTagsMode:          datadog.PtrBool(true),
				IgnoredMetricNameMatches: []string{},
				MetricNameMatches: []string{
					"dd.test.*",
				},
				Name: "my-indexing-rule",
				Options: &datadogV2.TagIndexingRuleOptions{
					Data: &datadogV2.TagIndexingRuleOptionsData{
						DynamicTags: &datadogV2.TagIndexingRuleDynamicTags{
							ExcludeNotQueriedWindowSeconds: datadog.PtrInt64(3600),
							ExcludeNotUsedInAssets:         datadog.PtrBool(true),
						},
						ManagePreexistingMetrics: datadog.PtrBool(true),
						OverridePreviousRules:    datadog.PtrBool(false),
					},
					Version: datadog.PtrInt64(1),
				},
				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.CreateTagIndexingRule", true)
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewMetricsApi(apiClient)
	resp, r, err := api.CreateTagIndexingRule(ctx, body)

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

	responseContent, _ := json.MarshalIndent(resp, "", "  ")
	fmt.Fprintf(os.Stdout, "Response from `MetricsApi.CreateTagIndexingRule`:\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.comuk1.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" go run "main.go"
// Create a tag indexing rule returns "Created" 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.TagIndexingRuleCreateAttributes;
import com.datadog.api.client.v2.model.TagIndexingRuleCreateData;
import com.datadog.api.client.v2.model.TagIndexingRuleCreateRequest;
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 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.createTagIndexingRule", true);
    MetricsApi apiInstance = new MetricsApi(defaultClient);

    TagIndexingRuleCreateRequest body =
        new TagIndexingRuleCreateRequest()
            .data(
                new TagIndexingRuleCreateData()
                    .attributes(
                        new TagIndexingRuleCreateAttributes()
                            .excludeTagsMode(false)
                            .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))
                            .tags(Arrays.asList("env", "service")))
                    .type(TagIndexingRuleType.TAG_INDEXING_RULES));

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

// Create a tag indexing rule with exclude-mode tag usage fields returns "Created" 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.TagIndexingRuleCreateAttributes;
import com.datadog.api.client.v2.model.TagIndexingRuleCreateData;
import com.datadog.api.client.v2.model.TagIndexingRuleCreateRequest;
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 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.createTagIndexingRule", true);
    MetricsApi apiInstance = new MetricsApi(defaultClient);

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

    try {
      TagIndexingRuleResponse result = apiInstance.createTagIndexingRule(body);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling MetricsApi#createTagIndexingRule");
      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.comuk1.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" java "Example.java"
"""
Create a tag indexing rule returns "Created" 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_create_attributes import TagIndexingRuleCreateAttributes
from datadog_api_client.v2.model.tag_indexing_rule_create_data import TagIndexingRuleCreateData
from datadog_api_client.v2.model.tag_indexing_rule_create_request import TagIndexingRuleCreateRequest
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

body = TagIndexingRuleCreateRequest(
    data=TagIndexingRuleCreateData(
        attributes=TagIndexingRuleCreateAttributes(
            exclude_tags_mode=False,
            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,
            ),
            tags=[
                "env",
                "service",
            ],
        ),
        type=TagIndexingRuleType.TAG_INDEXING_RULES,
    ),
)

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

    print(response)

"""
Create a tag indexing rule with exclude-mode tag usage fields returns "Created" 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_create_attributes import TagIndexingRuleCreateAttributes
from datadog_api_client.v2.model.tag_indexing_rule_create_data import TagIndexingRuleCreateData
from datadog_api_client.v2.model.tag_indexing_rule_create_request import TagIndexingRuleCreateRequest
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

body = TagIndexingRuleCreateRequest(
    data=TagIndexingRuleCreateData(
        attributes=TagIndexingRuleCreateAttributes(
            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=3600,
                        exclude_not_used_in_assets=True,
                    ),
                    manage_preexisting_metrics=True,
                    override_previous_rules=False,
                ),
                version=1,
            ),
            tags=[
                "env",
                "service",
            ],
        ),
        type=TagIndexingRuleType.TAG_INDEXING_RULES,
    ),
)

configuration = Configuration()
configuration.access_token = environ["DD_BEARER_TOKEN"]
configuration.unstable_operations["create_tag_indexing_rule"] = True
with ApiClient(configuration) as api_client:
    api_instance = MetricsApi(api_client)
    response = api_instance.create_tag_indexing_rule(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.comuk1.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" python3 "example.py"
# Create a tag indexing rule returns "Created" response

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

body = DatadogAPIClient::V2::TagIndexingRuleCreateRequest.new({
  data: DatadogAPIClient::V2::TagIndexingRuleCreateData.new({
    attributes: DatadogAPIClient::V2::TagIndexingRuleCreateAttributes.new({
      exclude_tags_mode: false,
      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,
      }),
      tags: [
        "env",
        "service",
      ],
    }),
    type: DatadogAPIClient::V2::TagIndexingRuleType::TAG_INDEXING_RULES,
  }),
})
p api_instance.create_tag_indexing_rule(body)

# Create a tag indexing rule with exclude-mode tag usage fields returns "Created" response

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

body = DatadogAPIClient::V2::TagIndexingRuleCreateRequest.new({
  data: DatadogAPIClient::V2::TagIndexingRuleCreateData.new({
    attributes: DatadogAPIClient::V2::TagIndexingRuleCreateAttributes.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: 3600,
            exclude_not_used_in_assets: true,
          }),
          manage_preexisting_metrics: true,
          override_previous_rules: false,
        }),
        version: 1,
      }),
      tags: [
        "env",
        "service",
      ],
    }),
    type: DatadogAPIClient::V2::TagIndexingRuleType::TAG_INDEXING_RULES,
  }),
})
p api_instance.create_tag_indexing_rule(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.comuk1.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" rb "example.rb"
// Create a tag indexing rule returns "Created" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_metrics::MetricsAPI;
use datadog_api_client::datadogV2::model::TagIndexingRuleCreateAttributes;
use datadog_api_client::datadogV2::model::TagIndexingRuleCreateData;
use datadog_api_client::datadogV2::model::TagIndexingRuleCreateRequest;
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;

#[tokio::main]
async fn main() {
    let body = TagIndexingRuleCreateRequest::new(TagIndexingRuleCreateData::new(
        TagIndexingRuleCreateAttributes::new(
            vec!["dd.test.*".to_string()],
            "my-indexing-rule".to_string(),
        )
        .exclude_tags_mode(false)
        .ignored_metric_name_matches(vec![])
        .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),
        )
        .tags(vec!["env".to_string(), "service".to_string()]),
        TagIndexingRuleType::TAG_INDEXING_RULES,
    ));
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled("v2.CreateTagIndexingRule", true);
    let api = MetricsAPI::with_config(configuration);
    let resp = api.create_tag_indexing_rule(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

// Create a tag indexing rule with exclude-mode tag usage fields returns "Created"
// response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_metrics::MetricsAPI;
use datadog_api_client::datadogV2::model::TagIndexingRuleCreateAttributes;
use datadog_api_client::datadogV2::model::TagIndexingRuleCreateData;
use datadog_api_client::datadogV2::model::TagIndexingRuleCreateRequest;
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;

#[tokio::main]
async fn main() {
    let body = TagIndexingRuleCreateRequest::new(TagIndexingRuleCreateData::new(
        TagIndexingRuleCreateAttributes::new(
            vec!["dd.test.*".to_string()],
            "my-indexing-rule".to_string(),
        )
        .exclude_tags_mode(true)
        .ignored_metric_name_matches(vec![])
        .options(
            TagIndexingRuleOptions::new()
                .data(
                    TagIndexingRuleOptionsData::new()
                        .dynamic_tags(
                            TagIndexingRuleDynamicTags::new()
                                .exclude_not_queried_window_seconds(3600)
                                .exclude_not_used_in_assets(true),
                        )
                        .manage_preexisting_metrics(true)
                        .override_previous_rules(false),
                )
                .version(1),
        )
        .tags(vec!["env".to_string(), "service".to_string()]),
        TagIndexingRuleType::TAG_INDEXING_RULES,
    ));
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled("v2.CreateTagIndexingRule", true);
    let api = MetricsAPI::with_config(configuration);
    let resp = api.create_tag_indexing_rule(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.comuk1.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" cargo run
/**
 * Create a tag indexing rule returns "Created" 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.createTagIndexingRule"] = true;
const apiInstance = new v2.MetricsApi(configuration);

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

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

/**
 * Create a tag indexing rule with exclude-mode tag usage fields returns "Created" 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.createTagIndexingRule"] = true;
const apiInstance = new v2.MetricsApi(configuration);

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

apiInstance
  .createTagIndexingRule(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.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comuk1.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" tsc "example.ts"