심각도 수정자 규칙 업데이트

// Update a severity modifier rule returns "Successfully updated the severity modifier rule" 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"
	"github.com/google/uuid"
)

func main() {
	// there is a valid "valid_severity_modifier_rule" in the system
	ValidSeverityModifierRuleDataID := uuid.MustParse(os.Getenv("VALID_SEVERITY_MODIFIER_RULE_DATA_ID"))

	body := datadogV2.SeverityModifierRuleUpdateRequest{
		Data: datadogV2.SeverityModifierRuleDataUpdate{
			Attributes: datadogV2.SeverityModifierRuleAttributesCreate{
				Action: datadogV2.SeverityModifierRuleAction{
					SeverityModifierRuleSetAction: &datadogV2.SeverityModifierRuleSetAction{
						Description: datadog.PtrString("Lower severity for dev environment noise"),
						Severity:    datadogV2.SEVERITYMODIFIERSEVERITY_LOW,
						Type:        datadogV2.SEVERITYMODIFIERRULESETACTIONTYPE_SET,
					}},
				Enabled: datadog.PtrBool(true),
				Name:    "Downgrade misconfigurations in dev",
				Rule: datadogV2.AutomationRuleScope{
					FindingTypes: []datadogV2.SecurityFindingType{
						datadogV2.SECURITYFINDINGTYPE_MISCONFIGURATION,
					},
					Query: datadog.PtrString("env:prod team:platform"),
				},
			},
			Id:   ValidSeverityModifierRuleDataID,
			Type: datadogV2.SEVERITYMODIFIERRULETYPE_SEVERITY_MODIFIER_RULES,
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	ctx = context.WithValue(ctx, datadog.ContextAccessToken, os.Getenv("DD_BEARER_TOKEN"))
	configuration := datadog.NewConfiguration()
	configuration.SetUnstableOperationEnabled("v2.UpdateSecurityFindingsAutomationSeverityModifierRule", true)
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewSecurityMonitoringApi(apiClient)
	resp, r, err := api.UpdateSecurityFindingsAutomationSeverityModifierRule(ctx, ValidSeverityModifierRuleDataID, body)

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

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

// Update a severity modifier rule returns "Successfully updated the severity modifier rule"
// response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.SecurityMonitoringApi;
import com.datadog.api.client.v2.model.AutomationRuleScope;
import com.datadog.api.client.v2.model.SecurityFindingType;
import com.datadog.api.client.v2.model.SeverityModifierRuleAction;
import com.datadog.api.client.v2.model.SeverityModifierRuleAttributesCreate;
import com.datadog.api.client.v2.model.SeverityModifierRuleDataUpdate;
import com.datadog.api.client.v2.model.SeverityModifierRuleResponse;
import com.datadog.api.client.v2.model.SeverityModifierRuleSetAction;
import com.datadog.api.client.v2.model.SeverityModifierRuleSetActionType;
import com.datadog.api.client.v2.model.SeverityModifierRuleType;
import com.datadog.api.client.v2.model.SeverityModifierRuleUpdateRequest;
import com.datadog.api.client.v2.model.SeverityModifierSeverity;
import java.util.Collections;
import java.util.UUID;

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

    // there is a valid "valid_severity_modifier_rule" in the system
    UUID VALID_SEVERITY_MODIFIER_RULE_DATA_ID = null;
    try {
      VALID_SEVERITY_MODIFIER_RULE_DATA_ID =
          UUID.fromString(System.getenv("VALID_SEVERITY_MODIFIER_RULE_DATA_ID"));
    } catch (IllegalArgumentException e) {
      System.err.println("Error parsing UUID: " + e.getMessage());
    }

    SeverityModifierRuleUpdateRequest body =
        new SeverityModifierRuleUpdateRequest()
            .data(
                new SeverityModifierRuleDataUpdate()
                    .attributes(
                        new SeverityModifierRuleAttributesCreate()
                            .action(
                                new SeverityModifierRuleAction(
                                    new SeverityModifierRuleSetAction()
                                        .description("Lower severity for dev environment noise")
                                        .severity(SeverityModifierSeverity.LOW)
                                        .type(SeverityModifierRuleSetActionType.SET)))
                            .enabled(true)
                            .name("Downgrade misconfigurations in dev")
                            .rule(
                                new AutomationRuleScope()
                                    .findingTypes(
                                        Collections.singletonList(
                                            SecurityFindingType.MISCONFIGURATION))
                                    .query("env:prod team:platform")))
                    .id(VALID_SEVERITY_MODIFIER_RULE_DATA_ID)
                    .type(SeverityModifierRuleType.SEVERITY_MODIFIER_RULES));

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

"""
Update a severity modifier rule returns "Successfully updated the severity modifier rule" response
"""

from os import environ
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.security_monitoring_api import SecurityMonitoringApi
from datadog_api_client.v2.model.automation_rule_scope import AutomationRuleScope
from datadog_api_client.v2.model.security_finding_type import SecurityFindingType
from datadog_api_client.v2.model.severity_modifier_rule_attributes_create import SeverityModifierRuleAttributesCreate
from datadog_api_client.v2.model.severity_modifier_rule_data_update import SeverityModifierRuleDataUpdate
from datadog_api_client.v2.model.severity_modifier_rule_set_action import SeverityModifierRuleSetAction
from datadog_api_client.v2.model.severity_modifier_rule_set_action_type import SeverityModifierRuleSetActionType
from datadog_api_client.v2.model.severity_modifier_rule_type import SeverityModifierRuleType
from datadog_api_client.v2.model.severity_modifier_rule_update_request import SeverityModifierRuleUpdateRequest
from datadog_api_client.v2.model.severity_modifier_severity import SeverityModifierSeverity

# there is a valid "valid_severity_modifier_rule" in the system
VALID_SEVERITY_MODIFIER_RULE_DATA_ID = environ["VALID_SEVERITY_MODIFIER_RULE_DATA_ID"]

body = SeverityModifierRuleUpdateRequest(
    data=SeverityModifierRuleDataUpdate(
        attributes=SeverityModifierRuleAttributesCreate(
            action=SeverityModifierRuleSetAction(
                description="Lower severity for dev environment noise",
                severity=SeverityModifierSeverity.LOW,
                type=SeverityModifierRuleSetActionType.SET,
            ),
            enabled=True,
            name="Downgrade misconfigurations in dev",
            rule=AutomationRuleScope(
                finding_types=[
                    SecurityFindingType.MISCONFIGURATION,
                ],
                query="env:prod team:platform",
            ),
        ),
        id=VALID_SEVERITY_MODIFIER_RULE_DATA_ID,
        type=SeverityModifierRuleType.SEVERITY_MODIFIER_RULES,
    ),
)

configuration = Configuration()
configuration.access_token = environ["DD_BEARER_TOKEN"]
configuration.unstable_operations["update_security_findings_automation_severity_modifier_rule"] = True
with ApiClient(configuration) as api_client:
    api_instance = SecurityMonitoringApi(api_client)
    response = api_instance.update_security_findings_automation_severity_modifier_rule(
        rule_id=VALID_SEVERITY_MODIFIER_RULE_DATA_ID, body=body
    )

    print(response)

# Update a severity modifier rule returns "Successfully updated the severity modifier rule" response

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

# there is a valid "valid_severity_modifier_rule" in the system
VALID_SEVERITY_MODIFIER_RULE_DATA_ID = ENV["VALID_SEVERITY_MODIFIER_RULE_DATA_ID"]

body = DatadogAPIClient::V2::SeverityModifierRuleUpdateRequest.new({
  data: DatadogAPIClient::V2::SeverityModifierRuleDataUpdate.new({
    attributes: DatadogAPIClient::V2::SeverityModifierRuleAttributesCreate.new({
      action: DatadogAPIClient::V2::SeverityModifierRuleSetAction.new({
        description: "Lower severity for dev environment noise",
        severity: DatadogAPIClient::V2::SeverityModifierSeverity::LOW,
        type: DatadogAPIClient::V2::SeverityModifierRuleSetActionType::SET,
      }),
      enabled: true,
      name: "Downgrade misconfigurations in dev",
      rule: DatadogAPIClient::V2::AutomationRuleScope.new({
        finding_types: [
          DatadogAPIClient::V2::SecurityFindingType::MISCONFIGURATION,
        ],
        query: "env:prod team:platform",
      }),
    }),
    id: VALID_SEVERITY_MODIFIER_RULE_DATA_ID,
    type: DatadogAPIClient::V2::SeverityModifierRuleType::SEVERITY_MODIFIER_RULES,
  }),
})
p api_instance.update_security_findings_automation_severity_modifier_rule(VALID_SEVERITY_MODIFIER_RULE_DATA_ID, body)

// Update a severity modifier rule returns "Successfully updated the severity
// modifier rule" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
use datadog_api_client::datadogV2::model::AutomationRuleScope;
use datadog_api_client::datadogV2::model::SecurityFindingType;
use datadog_api_client::datadogV2::model::SeverityModifierRuleAction;
use datadog_api_client::datadogV2::model::SeverityModifierRuleAttributesCreate;
use datadog_api_client::datadogV2::model::SeverityModifierRuleDataUpdate;
use datadog_api_client::datadogV2::model::SeverityModifierRuleSetAction;
use datadog_api_client::datadogV2::model::SeverityModifierRuleSetActionType;
use datadog_api_client::datadogV2::model::SeverityModifierRuleType;
use datadog_api_client::datadogV2::model::SeverityModifierRuleUpdateRequest;
use datadog_api_client::datadogV2::model::SeverityModifierSeverity;

#[tokio::main]
async fn main() {
    // there is a valid "valid_severity_modifier_rule" in the system
    let valid_severity_modifier_rule_data_id =
        uuid::Uuid::parse_str(&std::env::var("VALID_SEVERITY_MODIFIER_RULE_DATA_ID").unwrap())
            .expect("Invalid UUID");
    let body = SeverityModifierRuleUpdateRequest::new(SeverityModifierRuleDataUpdate::new(
        SeverityModifierRuleAttributesCreate::new(
            SeverityModifierRuleAction::SeverityModifierRuleSetAction(Box::new(
                SeverityModifierRuleSetAction::new(
                    SeverityModifierSeverity::LOW,
                    SeverityModifierRuleSetActionType::SET,
                )
                .description("Lower severity for dev environment noise".to_string()),
            )),
            "Downgrade misconfigurations in dev".to_string(),
            AutomationRuleScope::new(vec![SecurityFindingType::MISCONFIGURATION])
                .query("env:prod team:platform".to_string()),
        )
        .enabled(true),
        valid_severity_modifier_rule_data_id.clone(),
        SeverityModifierRuleType::SEVERITY_MODIFIER_RULES,
    ));
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled(
        "v2.update_security_findings_automation_severity_modifier_rule",
        true,
    );
    let api = SecurityMonitoringAPI::with_config(configuration);
    let resp = api
        .update_security_findings_automation_severity_modifier_rule(
            valid_severity_modifier_rule_data_id.clone(),
            body,
        )
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

/**
 * Update a severity modifier rule returns "Successfully updated the severity modifier rule" 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.updateSecurityFindingsAutomationSeverityModifierRule"
] = true;
const apiInstance = new v2.SecurityMonitoringApi(configuration);

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

const params: v2.SecurityMonitoringApiUpdateSecurityFindingsAutomationSeverityModifierRuleRequest =
  {
    body: {
      data: {
        attributes: {
          action: {
            description: "Lower severity for dev environment noise",
            severity: "low",
            type: "set",
          },
          enabled: true,
          name: "Downgrade misconfigurations in dev",
          rule: {
            findingTypes: ["misconfiguration"],
            query: "env:prod team:platform",
          },
        },
        type: "severity_modifier_rules",
      },
    },
    ruleId: VALID_SEVERITY_MODIFIER_RULE_DATA_ID,
  };

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