Update a RUM operation

"""
Update a RUM operation returns "OK" response
"""

from os import environ
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.rum_operations_api import RUMOperationsApi
from datadog_api_client.v2.model.rum_operation_journey_composite_rule import RUMOperationJourneyCompositeRule
from datadog_api_client.v2.model.rum_operation_journey_composite_rule_kind import RUMOperationJourneyCompositeRuleKind
from datadog_api_client.v2.model.rum_operation_journey_node import RUMOperationJourneyNode
from datadog_api_client.v2.model.rum_operation_journey_predicate import RUMOperationJourneyPredicate
from datadog_api_client.v2.model.rum_operation_journey_rum import RUMOperationJourneyRum
from datadog_api_client.v2.model.rum_operation_journey_step import RUMOperationJourneyStep
from datadog_api_client.v2.model.rum_operation_journey_step_type import RUMOperationJourneyStepType
from datadog_api_client.v2.model.rum_operation_request_attributes import RUMOperationRequestAttributes
from datadog_api_client.v2.model.rum_operation_type import RUMOperationType
from datadog_api_client.v2.model.rum_operation_update_request import RUMOperationUpdateRequest
from datadog_api_client.v2.model.rum_operation_update_request_data import RUMOperationUpdateRequestData
from uuid import UUID

body = RUMOperationUpdateRequest(
    data=RUMOperationUpdateRequestData(
        attributes=RUMOperationRequestAttributes(
            application_id=UUID("abc12345-1234-5678-abcd-ef1234567890"),
            category=None,
            description=None,
            display_name="Checkout completed",
            feature_ids=[],
            journey_rum=RUMOperationJourneyRum(
                rum_steps=[
                    RUMOperationJourneyStep(
                        composite=RUMOperationJourneyCompositeRule(
                            kind=RUMOperationJourneyCompositeRuleKind.ALL_OF,
                            max_window_ms=30000,
                            predicates=[
                                RUMOperationJourneyPredicate(
                                    query="@type:action @action.type:click",
                                ),
                            ],
                        ),
                        nodes=[
                            RUMOperationJourneyNode(
                                query="@type:action @action.type:click",
                            ),
                        ],
                        type=RUMOperationJourneyStepType.START,
                    ),
                ],
            ),
            name="checkout_completed",
            tags=[
                "team:checkout",
            ],
        ),
        id="abc12345-1234-5678-abcd-ef1234567890",
        type=RUMOperationType.OPERATIONS,
    ),
)

configuration = Configuration()
configuration.access_token = environ["DD_BEARER_TOKEN"]
configuration.unstable_operations["update_rum_operation"] = True
with ApiClient(configuration) as api_client:
    api_instance = RUMOperationsApi(api_client)
    response = api_instance.update_rum_operation(rum_operation_id="rum_operation_id", body=body)

    print(response)

# Update a RUM operation returns "OK" response

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

body = DatadogAPIClient::V2::RUMOperationUpdateRequest.new({
  data: DatadogAPIClient::V2::RUMOperationUpdateRequestData.new({
    attributes: DatadogAPIClient::V2::RUMOperationRequestAttributes.new({
      application_id: "abc12345-1234-5678-abcd-ef1234567890",
      category: nil,
      description: nil,
      display_name: "Checkout completed",
      feature_ids: [],
      journey_rum: DatadogAPIClient::V2::RUMOperationJourneyRum.new({
        rum_steps: [
          DatadogAPIClient::V2::RUMOperationJourneyStep.new({
            composite: DatadogAPIClient::V2::RUMOperationJourneyCompositeRule.new({
              kind: DatadogAPIClient::V2::RUMOperationJourneyCompositeRuleKind::ALL_OF,
              max_window_ms: 30000,
              predicates: [
                DatadogAPIClient::V2::RUMOperationJourneyPredicate.new({
                  query: "@type:action @action.type:click",
                }),
              ],
            }),
            nodes: [
              DatadogAPIClient::V2::RUMOperationJourneyNode.new({
                query: "@type:action @action.type:click",
              }),
            ],
            type: DatadogAPIClient::V2::RUMOperationJourneyStepType::START,
          }),
        ],
      }),
      name: "checkout_completed",
      tags: [
        "team:checkout",
      ],
    }),
    id: "abc12345-1234-5678-abcd-ef1234567890",
    type: DatadogAPIClient::V2::RUMOperationType::OPERATIONS,
  }),
})
p api_instance.update_rum_operation("rum_operation_id", body)

// Update a RUM operation 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"
	"github.com/google/uuid"
)

func main() {
	body := datadogV2.RUMOperationUpdateRequest{
		Data: datadogV2.RUMOperationUpdateRequestData{
			Attributes: datadogV2.RUMOperationRequestAttributes{
				ApplicationId: datadog.PtrUUID(uuid.MustParse("abc12345-1234-5678-abcd-ef1234567890")),
				Category:      *datadog.NewNullableString(nil),
				Description:   *datadog.NewNullableString(nil),
				DisplayName:   datadog.PtrString("Checkout completed"),
				FeatureIds:    []string{},
				JourneyRum: datadogV2.RUMOperationJourneyRum{
					RumSteps: []datadogV2.RUMOperationJourneyStep{
						{
							Composite: &datadogV2.RUMOperationJourneyCompositeRule{
								Kind:        datadogV2.RUMOPERATIONJOURNEYCOMPOSITERULEKIND_ALL_OF,
								MaxWindowMs: datadog.PtrInt64(30000),
								Predicates: []datadogV2.RUMOperationJourneyPredicate{
									{
										Query: "@type:action @action.type:click",
									},
								},
							},
							Nodes: []datadogV2.RUMOperationJourneyNode{
								{
									Query: "@type:action @action.type:click",
								},
							},
							Type: datadogV2.RUMOPERATIONJOURNEYSTEPTYPE_START,
						},
					},
				},
				Name: "checkout_completed",
				Tags: []string{
					"team:checkout",
				},
			},
			Id:   "abc12345-1234-5678-abcd-ef1234567890",
			Type: datadogV2.RUMOPERATIONTYPE_OPERATIONS,
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	ctx = context.WithValue(ctx, datadog.ContextAccessToken, os.Getenv("DD_BEARER_TOKEN"))
	configuration := datadog.NewConfiguration()
	configuration.SetUnstableOperationEnabled("v2.UpdateRUMOperation", true)
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewRUMOperationsApi(apiClient)
	resp, r, err := api.UpdateRUMOperation(ctx, "rum_operation_id", body)

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

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

// Update a RUM operation returns "OK" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.RumOperationsApi;
import com.datadog.api.client.v2.model.RUMOperationJourneyCompositeRule;
import com.datadog.api.client.v2.model.RUMOperationJourneyCompositeRuleKind;
import com.datadog.api.client.v2.model.RUMOperationJourneyNode;
import com.datadog.api.client.v2.model.RUMOperationJourneyPredicate;
import com.datadog.api.client.v2.model.RUMOperationJourneyRum;
import com.datadog.api.client.v2.model.RUMOperationJourneyStep;
import com.datadog.api.client.v2.model.RUMOperationJourneyStepType;
import com.datadog.api.client.v2.model.RUMOperationRequestAttributes;
import com.datadog.api.client.v2.model.RUMOperationResponse;
import com.datadog.api.client.v2.model.RUMOperationType;
import com.datadog.api.client.v2.model.RUMOperationUpdateRequest;
import com.datadog.api.client.v2.model.RUMOperationUpdateRequestData;
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.updateRUMOperation", true);
    RumOperationsApi apiInstance = new RumOperationsApi(defaultClient);

    RUMOperationUpdateRequest body =
        new RUMOperationUpdateRequest()
            .data(
                new RUMOperationUpdateRequestData()
                    .attributes(
                        new RUMOperationRequestAttributes()
                            .applicationId(UUID.fromString("abc12345-1234-5678-abcd-ef1234567890"))
                            .category(null)
                            .description(null)
                            .displayName("Checkout completed")
                            .journeyRum(
                                new RUMOperationJourneyRum()
                                    .rumSteps(
                                        Collections.singletonList(
                                            new RUMOperationJourneyStep()
                                                .composite(
                                                    new RUMOperationJourneyCompositeRule()
                                                        .kind(
                                                            RUMOperationJourneyCompositeRuleKind
                                                                .ALL_OF)
                                                        .maxWindowMs(30000L)
                                                        .predicates(
                                                            Collections.singletonList(
                                                                new RUMOperationJourneyPredicate()
                                                                    .query(
                                                                        "@type:action"
                                                                            + " @action.type:click"))))
                                                .nodes(
                                                    Collections.singletonList(
                                                        new RUMOperationJourneyNode()
                                                            .query(
                                                                "@type:action @action.type:click")))
                                                .type(RUMOperationJourneyStepType.START))))
                            .name("checkout_completed")
                            .tags(Collections.singletonList("team:checkout")))
                    .id("abc12345-1234-5678-abcd-ef1234567890")
                    .type(RUMOperationType.OPERATIONS));

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