Create a RUM operation

// Create 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.RUMOperationCreateRequest{
		Data: datadogV2.RUMOperationCreateRequestData{
			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",
				},
			},
			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.CreateRUMOperation", true)
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewRUMOperationsApi(apiClient)
	resp, r, err := api.CreateRUMOperation(ctx, body)

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

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

// Create 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.RUMOperationCreateRequest;
import com.datadog.api.client.v2.model.RUMOperationCreateRequestData;
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 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.createRUMOperation", true);
    RumOperationsApi apiInstance = new RumOperationsApi(defaultClient);

    RUMOperationCreateRequest body =
        new RUMOperationCreateRequest()
            .data(
                new RUMOperationCreateRequestData()
                    .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")))
                    .type(RUMOperationType.OPERATIONS));

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

"""
Create 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_create_request import RUMOperationCreateRequest
from datadog_api_client.v2.model.rum_operation_create_request_data import RUMOperationCreateRequestData
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 uuid import UUID

body = RUMOperationCreateRequest(
    data=RUMOperationCreateRequestData(
        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",
            ],
        ),
        type=RUMOperationType.OPERATIONS,
    ),
)

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

    print(response)

# Create 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.create_rum_operation".to_sym] = true
end
api_instance = DatadogAPIClient::V2::RUMOperationsAPI.new

body = DatadogAPIClient::V2::RUMOperationCreateRequest.new({
  data: DatadogAPIClient::V2::RUMOperationCreateRequestData.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",
      ],
    }),
    type: DatadogAPIClient::V2::RUMOperationType::OPERATIONS,
  }),
})
p api_instance.create_rum_operation(body)

// Create a RUM operation returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_rum_operations::RUMOperationsAPI;
use datadog_api_client::datadogV2::model::RUMOperationCreateRequest;
use datadog_api_client::datadogV2::model::RUMOperationCreateRequestData;
use datadog_api_client::datadogV2::model::RUMOperationJourneyCompositeRule;
use datadog_api_client::datadogV2::model::RUMOperationJourneyCompositeRuleKind;
use datadog_api_client::datadogV2::model::RUMOperationJourneyNode;
use datadog_api_client::datadogV2::model::RUMOperationJourneyPredicate;
use datadog_api_client::datadogV2::model::RUMOperationJourneyRum;
use datadog_api_client::datadogV2::model::RUMOperationJourneyStep;
use datadog_api_client::datadogV2::model::RUMOperationJourneyStepType;
use datadog_api_client::datadogV2::model::RUMOperationRequestAttributes;
use datadog_api_client::datadogV2::model::RUMOperationType;
use uuid::Uuid;

#[tokio::main]
async fn main() {
    let body = RUMOperationCreateRequest::new(RUMOperationCreateRequestData::new(
        RUMOperationRequestAttributes::new(
            RUMOperationJourneyRum::new(vec![RUMOperationJourneyStep::new(
                RUMOperationJourneyStepType::START,
            )
            .composite(
                RUMOperationJourneyCompositeRule::new(
                    RUMOperationJourneyCompositeRuleKind::ALL_OF,
                    vec![RUMOperationJourneyPredicate::new(
                        "@type:action @action.type:click".to_string(),
                    )],
                )
                .max_window_ms(30000),
            )
            .nodes(vec![RUMOperationJourneyNode::new(
                "@type:action @action.type:click".to_string(),
            )])]),
            "checkout_completed".to_string(),
            vec!["team:checkout".to_string()],
        )
        .application_id(
            Uuid::parse_str("abc12345-1234-5678-abcd-ef1234567890").expect("invalid UUID"),
        )
        .category(None)
        .description(None)
        .display_name("Checkout completed".to_string())
        .feature_ids(vec![]),
        RUMOperationType::OPERATIONS,
    ));
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled("v2.create_rum_operation", true);
    let api = RUMOperationsAPI::with_config(configuration);
    let resp = api.create_rum_operation(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

/**
 * Create a RUM operation returns "OK" 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.createRUMOperation"] = true;
const apiInstance = new v2.RUMOperationsApi(configuration);

const params: v2.RUMOperationsApiCreateRUMOperationRequest = {
  body: {
    data: {
      attributes: {
        applicationId: "abc12345-1234-5678-abcd-ef1234567890",
        category: undefined,
        description: undefined,
        displayName: "Checkout completed",
        featureIds: [],
        journeyRum: {
          rumSteps: [
            {
              composite: {
                kind: "all_of",
                maxWindowMs: 30000,
                predicates: [
                  {
                    query: "@type:action @action.type:click",
                  },
                ],
              },
              nodes: [
                {
                  query: "@type:action @action.type:click",
                },
              ],
              type: "start",
            },
          ],
        },
        name: "checkout_completed",
        tags: ["team:checkout"],
      },
      type: "operations",
    },
  },
};

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