Add tag pipeline, custom allocation rule and get cloud account by id for AWS/Azure/GCP configs APIs (#912)

Co-authored-by: ci.datadog-api-spec <[email protected]>
Co-authored-by: amaskara-dd <[email protected]>
Co-authored-by: Anika Maskara <[email protected]>

Author: 3 people

.generator/schemas/v2/openapi.yaml

@@ -0,0 +1,67 @@
+// Create arbitrary cost rule returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_cloud_cost_management::CloudCostManagementAPI;
+use datadog_api_client::datadogV2::model::ArbitraryCostUpsertRequest;
+use datadog_api_client::datadogV2::model::ArbitraryCostUpsertRequestData;
+use datadog_api_client::datadogV2::model::ArbitraryCostUpsertRequestDataAttributes;
+use datadog_api_client::datadogV2::model::ArbitraryCostUpsertRequestDataAttributesCostsToAllocateItems;
+use datadog_api_client::datadogV2::model::ArbitraryCostUpsertRequestDataAttributesStrategy;
+use datadog_api_client::datadogV2::model::ArbitraryCostUpsertRequestDataAttributesStrategyBasedOnCostsItems;
+use datadog_api_client::datadogV2::model::ArbitraryCostUpsertRequestDataType;
+
+#[tokio::main]
+async fn main() {
+    let body = ArbitraryCostUpsertRequest::new().data(
+        ArbitraryCostUpsertRequestData::new(
+            ArbitraryCostUpsertRequestDataType::UPSERT_ARBITRARY_RULE,
+        )
+        .attributes(
+            ArbitraryCostUpsertRequestDataAttributes::new(
+                vec![
+                    ArbitraryCostUpsertRequestDataAttributesCostsToAllocateItems::new(
+                        "is".to_string(),
+                        "account_id".to_string(),
+                    )
+                    .value("123456789".to_string())
+                    .values(Some(vec![])),
+                    ArbitraryCostUpsertRequestDataAttributesCostsToAllocateItems::new(
+                        "in".to_string(),
+                        "environment".to_string(),
+                    )
+                    .value("".to_string())
+                    .values(Some(vec!["production".to_string(), "staging".to_string()])),
+                ],
+                vec!["aws".to_string(), "gcp".to_string()],
+                "example-arbitrary-cost-rule".to_string(),
+                ArbitraryCostUpsertRequestDataAttributesStrategy::new("proportional".to_string())
+                    .allocated_by_tag_keys(vec!["team".to_string(), "environment".to_string()])
+                    .based_on_costs(vec![
+                        ArbitraryCostUpsertRequestDataAttributesStrategyBasedOnCostsItems::new(
+                            "is".to_string(),
+                            "service".to_string(),
+                        )
+                        .value("web-api".to_string())
+                        .values(Some(vec![])),
+                        ArbitraryCostUpsertRequestDataAttributesStrategyBasedOnCostsItems::new(
+                            "not in".to_string(),
+                            "team".to_string(),
+                        )
+                        .value("".to_string())
+                        .values(Some(vec!["legacy".to_string(), "deprecated".to_string()])),
+                    ])
+                    .granularity("daily".to_string()),
+                "shared".to_string(),
+            )
+            .enabled(true)
+            .order_id(1),
+        ),
+    );
+    let configuration = datadog::Configuration::new();
+    let api = CloudCostManagementAPI::with_config(configuration);
+    let resp = api.create_arbitrary_cost_rule(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_cloud-cost-management_CreateArbitraryCostRule.rs

@@ -8,16 +8,18 @@ use datadog_api_client::datadogV2::model::AwsCURConfigPostRequestType;
 
 #[tokio::main]
 async fn main() {
-    let body = AwsCURConfigPostRequest::new(AwsCURConfigPostData::new(
-        AwsCURConfigPostRequestAttributes::new(
-            "123456789123".to_string(),
-            "dd-cost-bucket".to_string(),
-            "dd-report-name".to_string(),
-            "dd-report-prefix".to_string(),
-        )
-        .bucket_region("us-east-1".to_string()),
-        AwsCURConfigPostRequestType::AWS_CUR_CONFIG_POST_REQUEST,
-    ));
+    let body = AwsCURConfigPostRequest::new(
+        AwsCURConfigPostData::new(AwsCURConfigPostRequestType::AWS_CUR_CONFIG_POST_REQUEST)
+            .attributes(
+                AwsCURConfigPostRequestAttributes::new(
+                    "123456789123".to_string(),
+                    "dd-cost-bucket".to_string(),
+                    "dd-report-name".to_string(),
+                    "dd-report-prefix".to_string(),
+                )
+                .bucket_region("us-east-1".to_string()),
+            ),
+    );
     let configuration = datadog::Configuration::new();
     let api = CloudCostManagementAPI::with_config(configuration);
     let resp = api.create_cost_awscur_config(body).await;

examples/v2_cloud-cost-management_CreateCostAWSCURConfig.rs

@@ -9,27 +9,26 @@ use datadog_api_client::datadogV2::model::BillConfig;
 
 #[tokio::main]
 async fn main() {
-    let body = AzureUCConfigPostRequest::new(AzureUCConfigPostData::new(
-        AzureUCConfigPostRequestAttributes::new(
-            "1234abcd-1234-abcd-1234-1234abcd1234".to_string(),
-            BillConfig::new(
-                "dd-actual-export".to_string(),
-                "dd-export-path".to_string(),
-                "dd-storage-account".to_string(),
-                "dd-storage-container".to_string(),
-            ),
-            BillConfig::new(
-                "dd-actual-export".to_string(),
-                "dd-export-path".to_string(),
-                "dd-storage-account".to_string(),
-                "dd-storage-container".to_string(),
-            ),
-            "1234abcd-1234-abcd-1234-1234abcd1234".to_string(),
-            "subscriptions/1234abcd-1234-abcd-1234-1234abcd1234".to_string(),
-        )
-        .is_enabled(true),
-        AzureUCConfigPostRequestType::AZURE_UC_CONFIG_POST_REQUEST,
-    ));
+    let body = AzureUCConfigPostRequest::new(
+        AzureUCConfigPostData::new(AzureUCConfigPostRequestType::AZURE_UC_CONFIG_POST_REQUEST)
+            .attributes(AzureUCConfigPostRequestAttributes::new(
+                "1234abcd-1234-abcd-1234-1234abcd1234".to_string(),
+                BillConfig::new(
+                    "dd-actual-export".to_string(),
+                    "dd-export-path".to_string(),
+                    "dd-storage-account".to_string(),
+                    "dd-storage-container".to_string(),
+                ),
+                BillConfig::new(
+                    "dd-actual-export".to_string(),
+                    "dd-export-path".to_string(),
+                    "dd-storage-account".to_string(),
+                    "dd-storage-container".to_string(),
+                ),
+                "1234abcd-1234-abcd-1234-1234abcd1234".to_string(),
+                "subscriptions/1234abcd-1234-abcd-1234-1234abcd1234".to_string(),
+            )),
+    );
     let configuration = datadog::Configuration::new();
     let api = CloudCostManagementAPI::with_config(configuration);
     let resp = api.create_cost_azure_uc_configs(body).await;

examples/v2_cloud-cost-management_CreateCostAzureUCConfigs.rs

@@ -1,4 +1,4 @@
-// Create Cloud Cost Management GCP Usage Cost config returns "OK" response
+// Create Google Cloud Usage Cost config returns "OK" response
 use datadog_api_client::datadog;
 use datadog_api_client::datadogV2::api_cloud_cost_management::CloudCostManagementAPI;
 use datadog_api_client::datadogV2::model::GCPUsageCostConfigPostData;
@@ -8,17 +8,21 @@ use datadog_api_client::datadogV2::model::GCPUsageCostConfigPostRequestType;
 
 #[tokio::main]
 async fn main() {
-    let body = GCPUsageCostConfigPostRequest::new(GCPUsageCostConfigPostData::new(
-        GCPUsageCostConfigPostRequestAttributes::new(
-            "123456_A123BC_12AB34".to_string(),
-            "dd-cost-bucket".to_string(),
-            "billing".to_string(),
-            "dd-cloud-cost-report".to_string(),
-            "[email protected]".to_string(),
+    let body = GCPUsageCostConfigPostRequest::new(
+        GCPUsageCostConfigPostData::new(
+            GCPUsageCostConfigPostRequestType::GCP_USAGE_COST_CONFIG_POST_REQUEST,
         )
-        .export_prefix("datadog_cloud_cost_usage_export".to_string()),
-        GCPUsageCostConfigPostRequestType::GCP_USAGE_COST_CONFIG_POST_REQUEST,
-    ));
+        .attributes(
+            GCPUsageCostConfigPostRequestAttributes::new(
+                "123456_A123BC_12AB34".to_string(),
+                "dd-cost-bucket".to_string(),
+                "billing".to_string(),
+                "dd-cloud-cost-report".to_string(),
+                "[email protected]".to_string(),
+            )
+            .export_prefix("datadog_cloud_cost_usage_export".to_string()),
+        ),
+    );
     let configuration = datadog::Configuration::new();
     let api = CloudCostManagementAPI::with_config(configuration);
     let resp = api.create_cost_gcp_usage_cost_config(body).await;

examples/v2_cloud-cost-management_CreateCostGCPUsageCostConfig.rs

@@ -0,0 +1,50 @@
+// Create ruleset returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_cloud_cost_management::CloudCostManagementAPI;
+use datadog_api_client::datadogV2::model::CreateRulesetRequest;
+use datadog_api_client::datadogV2::model::CreateRulesetRequestData;
+use datadog_api_client::datadogV2::model::CreateRulesetRequestDataAttributes;
+use datadog_api_client::datadogV2::model::CreateRulesetRequestDataAttributesRulesItems;
+use datadog_api_client::datadogV2::model::CreateRulesetRequestDataAttributesRulesItemsQuery;
+use datadog_api_client::datadogV2::model::CreateRulesetRequestDataAttributesRulesItemsQueryAddition;
+use datadog_api_client::datadogV2::model::CreateRulesetRequestDataType;
+
+#[tokio::main]
+async fn main() {
+    let body = CreateRulesetRequest::new().data(
+        CreateRulesetRequestData::new(CreateRulesetRequestDataType::CREATE_RULESET)
+            .attributes(
+                CreateRulesetRequestDataAttributes::new(vec![
+                    CreateRulesetRequestDataAttributesRulesItems::new(
+                        true,
+                        "Add Cost Center Tag".to_string(),
+                    )
+                    .mapping(None)
+                    .query(Some(
+                        CreateRulesetRequestDataAttributesRulesItemsQuery::new(
+                            Some(
+                                CreateRulesetRequestDataAttributesRulesItemsQueryAddition::new(
+                                    "cost_center".to_string(),
+                                    "engineering".to_string(),
+                                ),
+                            ),
+                            true,
+                            r#"account_id:"123456789" AND service:"web-api""#.to_string(),
+                        )
+                        .case_insensitivity(false),
+                    ))
+                    .reference_table(None),
+                ])
+                .enabled(true),
+            )
+            .id("New Ruleset".to_string()),
+    );
+    let configuration = datadog::Configuration::new();
+    let api = CloudCostManagementAPI::with_config(configuration);
+    let resp = api.create_ruleset(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_cloud-cost-management_CreateRuleset.rs

@@ -0,0 +1,15 @@
+// Delete arbitrary cost rule returns "No Content" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_cloud_cost_management::CloudCostManagementAPI;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = CloudCostManagementAPI::with_config(configuration);
+    let resp = api.delete_arbitrary_cost_rule(123456).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_cloud-cost-management_DeleteArbitraryCostRule.rs

@@ -1,4 +1,4 @@
-// Delete Cloud Cost Management GCP Usage Cost config returns "No Content" response
+// Delete Google Cloud Usage Cost config returns "No Content" response
 use datadog_api_client::datadog;
 use datadog_api_client::datadogV2::api_cloud_cost_management::CloudCostManagementAPI;
 

examples/v2_cloud-cost-management_DeleteCostGCPUsageCostConfig.rs

@@ -0,0 +1,17 @@
+// Delete ruleset returns "No Content" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_cloud_cost_management::CloudCostManagementAPI;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = CloudCostManagementAPI::with_config(configuration);
+    let resp = api
+        .delete_ruleset("1c5dae14-237d-4b9a-a515-aa55b3939142".to_string())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_cloud-cost-management_DeleteRuleset.rs

@@ -0,0 +1,15 @@
+// Get arbitrary cost rule returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_cloud_cost_management::CloudCostManagementAPI;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = CloudCostManagementAPI::with_config(configuration);
+    let resp = api.get_arbitrary_cost_rule(123456).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}