Add tag indexing rule APIs to v2 metrics spec (#1689)

Co-authored-by: ci.datadog-api-spec <packages@datadoghq.com>

Author: api-clients-generation-pipeline[bot]

.generator/schemas/v2/openapi.yaml

@@ -0,0 +1,50 @@
+// 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()
+                                .queried_tags_window_seconds(3600)
+                                .related_asset_tags(false),
+                        )
+                        .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 configuration = datadog::Configuration::new();
+    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());
+    }
+}

examples/v2_metrics_CreateTagIndexingRule.rs

@@ -0,0 +1,27 @@
+// Create a tag indexing rule exemption returns "Created" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_metrics::MetricsAPI;
+use datadog_api_client::datadogV2::model::TagIndexingRuleExemptionCreateAttributes;
+use datadog_api_client::datadogV2::model::TagIndexingRuleExemptionCreateData;
+use datadog_api_client::datadogV2::model::TagIndexingRuleExemptionCreateRequest;
+use datadog_api_client::datadogV2::model::TagIndexingRuleExemptionType;
+
+#[tokio::main]
+async fn main() {
+    let body = TagIndexingRuleExemptionCreateRequest::new(TagIndexingRuleExemptionCreateData::new(
+        TagIndexingRuleExemptionCreateAttributes::new(
+            "This metric has a pre-existing tag configuration.".to_string(),
+        ),
+        TagIndexingRuleExemptionType::TAG_INDEXING_RULE_EXEMPTIONS,
+    ));
+    let configuration = datadog::Configuration::new();
+    let api = MetricsAPI::with_config(configuration);
+    let resp = api
+        .create_tag_indexing_rule_exemption("metric_name".to_string(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_metrics_CreateTagIndexingRuleExemption.rs

@@ -0,0 +1,19 @@
+// Delete a tag indexing rule returns "No Content" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_metrics::MetricsAPI;
+
+#[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 configuration = datadog::Configuration::new();
+    let api = MetricsAPI::with_config(configuration);
+    let resp = api
+        .delete_tag_indexing_rule(tag_indexing_rule_data_id.clone())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_metrics_DeleteTagIndexingRule.rs

@@ -0,0 +1,17 @@
+// Delete a tag indexing rule exemption returns "No Content" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_metrics::MetricsAPI;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = MetricsAPI::with_config(configuration);
+    let resp = api
+        .delete_tag_indexing_rule_exemption("metric_name".to_string())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_metrics_DeleteTagIndexingRuleExemption.rs

@@ -0,0 +1,19 @@
+// Get a tag indexing rule returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_metrics::MetricsAPI;
+
+#[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 configuration = datadog::Configuration::new();
+    let api = MetricsAPI::with_config(configuration);
+    let resp = api
+        .get_tag_indexing_rule(tag_indexing_rule_data_id.clone())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_metrics_GetTagIndexingRule.rs

@@ -0,0 +1,17 @@
+// Get a tag indexing rule exemption returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_metrics::MetricsAPI;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = MetricsAPI::with_config(configuration);
+    let resp = api
+        .get_tag_indexing_rule_exemption("metric_name".to_string())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_metrics_GetTagIndexingRuleExemption.rs

@@ -0,0 +1,18 @@
+// List tag indexing rules returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_metrics::ListTagIndexingRulesOptionalParams;
+use datadog_api_client::datadogV2::api_metrics::MetricsAPI;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = MetricsAPI::with_config(configuration);
+    let resp = api
+        .list_tag_indexing_rules(ListTagIndexingRulesOptionalParams::default())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_metrics_ListTagIndexingRules.rs

@@ -0,0 +1,17 @@
+// List tag indexing rules for a metric returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_metrics::MetricsAPI;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = MetricsAPI::with_config(configuration);
+    let resp = api
+        .list_tag_indexing_rules_for_metric("ExampleMetric".to_string())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_metrics_ListTagIndexingRulesForMetric.rs

@@ -0,0 +1,25 @@
+// Reorder tag indexing rules returns "No Content" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_metrics::MetricsAPI;
+use datadog_api_client::datadogV2::model::TagIndexingRuleOrderAttributes;
+use datadog_api_client::datadogV2::model::TagIndexingRuleOrderData;
+use datadog_api_client::datadogV2::model::TagIndexingRuleOrderRequest;
+use datadog_api_client::datadogV2::model::TagIndexingRuleType;
+
+#[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 = TagIndexingRuleOrderRequest::new(TagIndexingRuleOrderData::new(
+        TagIndexingRuleOrderAttributes::new().rule_ids(vec![tag_indexing_rule_data_id.clone()]),
+        TagIndexingRuleType::TAG_INDEXING_RULES,
+    ));
+    let configuration = datadog::Configuration::new();
+    let api = MetricsAPI::with_config(configuration);
+    let resp = api.reorder_tag_indexing_rules(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}