Sign in Dashboard Get started
  1. Registry
  2. Packages
  3. Datadog Provider
  4. API Docs
  5. RumOperation
Viewing docs for Datadog v5.17.1
published on Tuesday, Oct 27, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-datadog

datadog.RumOperation

datadog logo
Viewing docs for Datadog v5.17.1
published on Tuesday, Oct 27, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-datadog

    Provides a Datadog RUM Operation resource. This can be used to create and manage RUM operations. When automatic SLO creation is enabled for the organization, creating an operation also creates an availability SLO tagged feature_operation:<name>, and deleting it deletes the SLOs carrying that tag for the operation’s application. Renaming the operation or changing its application leaves the previous SLO in place.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
import * as datadog from "@pulumi/datadog";

const checkout = new datadog.RumOperation("checkout", {
    name: "checkout",
    displayName: "Checkout",
    applicationId: "00000000-0000-0000-0000-000000000000",
    description: "From the cart to the order confirmation page.",
    category: "form_submission",
    tags: ["team:payments"],
    steps: [
        {
            type: "start",
            nodes: [{
                query: "@view.name:/cart @action.name:checkout",
            }],
        },
        {
            type: "stop",
            nodes: [{
                query: "@view.name:/order/confirmation",
            }],
        },
        {
            type: "error",
            composite: {
                kind: "in_order",
                maxWindowMs: 60000,
                predicates: [
                    {
                        query: "@type:action @action.name:pay",
                    },
                    {
                        query: "@type:error @error.message:*declined*",
                    },
                ],
            },
        },
    ],
});

    import pulumi
import pulumi_datadog as datadog

checkout = datadog.RumOperation("checkout",
    name="checkout",
    display_name="Checkout",
    application_id="00000000-0000-0000-0000-000000000000",
    description="From the cart to the order confirmation page.",
    category="form_submission",
    tags=["team:payments"],
    steps=[
        {
            "type": "start",
            "nodes": [{
                "query": "@view.name:/cart @action.name:checkout",
            }],
        },
        {
            "type": "stop",
            "nodes": [{
                "query": "@view.name:/order/confirmation",
            }],
        },
        {
            "type": "error",
            "composite": {
                "kind": "in_order",
                "max_window_ms": 60000,
                "predicates": [
                    {
                        "query": "@type:action @action.name:pay",
                    },
                    {
                        "query": "@type:error @error.message:*declined*",
                    },
                ],
            },
        },
    ])

    package main

import (
	"github.com/pulumi/pulumi-datadog/sdk/v5/go/datadog"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := datadog.NewRumOperation(ctx, "checkout", &datadog.RumOperationArgs{
			Name:          pulumi.String("checkout"),
			DisplayName:   pulumi.String("Checkout"),
			ApplicationId: pulumi.String("00000000-0000-0000-0000-000000000000"),
			Description:   pulumi.String("From the cart to the order confirmation page."),
			Category:      pulumi.String("form_submission"),
			Tags: pulumi.StringArray{
				pulumi.String("team:payments"),
			},
			Steps: datadog.RumOperationStepArray{
				&datadog.RumOperationStepArgs{
					Type: pulumi.String("start"),
					Nodes: datadog.RumOperationStepNodeArray{
						&datadog.RumOperationStepNodeArgs{
							Query: pulumi.String("@view.name:/cart @action.name:checkout"),
						},
					},
				},
				&datadog.RumOperationStepArgs{
					Type: pulumi.String("stop"),
					Nodes: datadog.RumOperationStepNodeArray{
						&datadog.RumOperationStepNodeArgs{
							Query: pulumi.String("@view.name:/order/confirmation"),
						},
					},
				},
				&datadog.RumOperationStepArgs{
					Type: pulumi.String("error"),
					Composite: &datadog.RumOperationStepCompositeArgs{
						Kind:        pulumi.String("in_order"),
						MaxWindowMs: pulumi.Int(60000),
						Predicates: datadog.RumOperationStepCompositePredicateArray{
							&datadog.RumOperationStepCompositePredicateArgs{
								Query: pulumi.String("@type:action @action.name:pay"),
							},
							&datadog.RumOperationStepCompositePredicateArgs{
								Query: pulumi.String("@type:error @error.message:*declined*"),
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Datadog = Pulumi.Datadog;

return await Deployment.RunAsync(() => 
{
    var checkout = new Datadog.RumOperation("checkout", new()
    {
        Name = "checkout",
        DisplayName = "Checkout",
        ApplicationId = "00000000-0000-0000-0000-000000000000",
        Description = "From the cart to the order confirmation page.",
        Category = "form_submission",
        Tags = new[]
        {
            "team:payments",
        },
        Steps = new[]
        {
            new Datadog.Inputs.RumOperationStepArgs
            {
                Type = "start",
                Nodes = new[]
                {
                    new Datadog.Inputs.RumOperationStepNodeArgs
                    {
                        Query = "@view.name:/cart @action.name:checkout",
                    },
                },
            },
            new Datadog.Inputs.RumOperationStepArgs
            {
                Type = "stop",
                Nodes = new[]
                {
                    new Datadog.Inputs.RumOperationStepNodeArgs
                    {
                        Query = "@view.name:/order/confirmation",
                    },
                },
            },
            new Datadog.Inputs.RumOperationStepArgs
            {
                Type = "error",
                Composite = new Datadog.Inputs.RumOperationStepCompositeArgs
                {
                    Kind = "in_order",
                    MaxWindowMs = 60000,
                    Predicates = new[]
                    {
                        new Datadog.Inputs.RumOperationStepCompositePredicateArgs
                        {
                            Query = "@type:action @action.name:pay",
                        },
                        new Datadog.Inputs.RumOperationStepCompositePredicateArgs
                        {
                            Query = "@type:error @error.message:*declined*",
                        },
                    },
                },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.datadog.RumOperation;
import com.pulumi.datadog.RumOperationArgs;
import com.pulumi.datadog.inputs.RumOperationStepArgs;
import com.pulumi.datadog.inputs.RumOperationStepNodeArgs;
import com.pulumi.datadog.inputs.RumOperationStepCompositeArgs;
import com.pulumi.datadog.inputs.RumOperationStepCompositePredicateArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var checkout = new RumOperation("checkout", RumOperationArgs.builder()
            .name("checkout")
            .displayName("Checkout")
            .applicationId("00000000-0000-0000-0000-000000000000")
            .description("From the cart to the order confirmation page.")
            .category("form_submission")
            .tags("team:payments")
            .steps(            
                RumOperationStepArgs.builder()
                    .type("start")
                    .nodes(RumOperationStepNodeArgs.builder()
                        .query("@view.name:/cart @action.name:checkout")
                        .build())
                    .build(),
                RumOperationStepArgs.builder()
                    .type("stop")
                    .nodes(RumOperationStepNodeArgs.builder()
                        .query("@view.name:/order/confirmation")
                        .build())
                    .build(),
                RumOperationStepArgs.builder()
                    .type("error")
                    .composite(RumOperationStepCompositeArgs.builder()
                        .kind("in_order")
                        .maxWindowMs(60000)
                        .predicates(                        
                            RumOperationStepCompositePredicateArgs.builder()
                                .query("@type:action @action.name:pay")
                                .build(),
                            RumOperationStepCompositePredicateArgs.builder()
                                .query("@type:error @error.message:*declined*")
                                .build())
                        .build())
                    .build())
            .build());

    }
}

    resources:
  checkout:
    type: datadog:RumOperation
    properties:
      name: checkout
      displayName: Checkout
      applicationId: 00000000-0000-0000-0000-000000000000
      description: From the cart to the order confirmation page.
      category: form_submission
      tags:
        - team:payments
      steps:
        - type: start
          nodes:
            - query: '@view.name:/cart @action.name:checkout'
        - type: stop
          nodes:
            - query: '@view.name:/order/confirmation'
        - type: error
          composite:
            kind: in_order
            maxWindowMs: 60000
            predicates:
              - query: '@type:action @action.name:pay'
              - query: '@type:error @error.message:*declined*'

    terraform {
  required_providers {
    datadog = {
      source = "pulumi/datadog"
    }
  }
}

resource "datadog_rum_operation" "checkout" {
  lifecycle {
    create_before_destroy = true
  }
  name           = "checkout"
  display_name   = "Checkout"
  application_id = "00000000-0000-0000-0000-000000000000"
  description    = "From the cart to the order confirmation page."
  category       = "form_submission"
  tags           = ["team:payments"]
  steps = [{
    type = "start"
    nodes = [{
      query = "@view.name:/cart @action.name:checkout"
    }]
    }, {
    type = "stop"
    nodes = [{
      query = "@view.name:/order/confirmation"
    }]
    }, {
    type = "error"
    composite = {
      kind          = "in_order"
      max_window_ms = 60000
      predicates = [{
        query = "@type:action @action.name:pay"
        }, {
        query = "@type:error @error.message:*declined*"
      }]
    }
  }]
}

    Create RumOperation Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new RumOperation(name: string, args: RumOperationArgs, opts?: CustomResourceOptions);
    @overload
def RumOperation(resource_name: str,
                 args: RumOperationArgs,
                 opts: Optional[ResourceOptions] = None)

@overload
def RumOperation(resource_name: str,
                 opts: Optional[ResourceOptions] = None,
                 application_id: Optional[str] = None,
                 name: Optional[str] = None,
                 steps: Optional[Sequence[RumOperationStepArgs]] = None,
                 category: Optional[str] = None,
                 description: Optional[str] = None,
                 display_name: Optional[str] = None,
                 tags: Optional[Sequence[str]] = None)
    func NewRumOperation(ctx *Context, name string, args RumOperationArgs, opts ...ResourceOption) (*RumOperation, error)
    public RumOperation(string name, RumOperationArgs args, CustomResourceOptions? opts = null)
    public RumOperation(String name, RumOperationArgs args)
public RumOperation(String name, RumOperationArgs args, CustomResourceOptions options)

    type: datadog:RumOperation
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.


    resource "datadog_rum_operation" "name" {
    # resource properties
}

    Parameters

    name string
    The unique name of the resource.
    args RumOperationArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args RumOperationArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args RumOperationArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args RumOperationArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args RumOperationArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var rumOperationResource = new Datadog.RumOperation("rumOperationResource", new()
{
    ApplicationId = "string",
    Name = "string",
    Steps = new[]
    {
        new Datadog.Inputs.RumOperationStepArgs
        {
            Type = "string",
            Composite = new Datadog.Inputs.RumOperationStepCompositeArgs
            {
                Kind = "string",
                Predicates = new[]
                {
                    new Datadog.Inputs.RumOperationStepCompositePredicateArgs
                    {
                        Query = "string",
                    },
                },
                MaxWindowMs = 0,
            },
            Nodes = new[]
            {
                new Datadog.Inputs.RumOperationStepNodeArgs
                {
                    Query = "string",
                },
            },
        },
    },
    Category = "string",
    Description = "string",
    DisplayName = "string",
    Tags = new[]
    {
        "string",
    },
});

    example, err := datadog.NewRumOperation(ctx, "rumOperationResource", &datadog.RumOperationArgs{
	ApplicationId: pulumi.String("string"),
	Name:          pulumi.String("string"),
	Steps: datadog.RumOperationStepArray{
		&datadog.RumOperationStepArgs{
			Type: pulumi.String("string"),
			Composite: &datadog.RumOperationStepCompositeArgs{
				Kind: pulumi.String("string"),
				Predicates: datadog.RumOperationStepCompositePredicateArray{
					&datadog.RumOperationStepCompositePredicateArgs{
						Query: pulumi.String("string"),
					},
				},
				MaxWindowMs: pulumi.Int(0),
			},
			Nodes: datadog.RumOperationStepNodeArray{
				&datadog.RumOperationStepNodeArgs{
					Query: pulumi.String("string"),
				},
			},
		},
	},
	Category:    pulumi.String("string"),
	Description: pulumi.String("string"),
	DisplayName: pulumi.String("string"),
	Tags: pulumi.StringArray{
		pulumi.String("string"),
	},
})

    resource "datadog_rum_operation" "rumOperationResource" {
  lifecycle {
    create_before_destroy = true
  }
  application_id = "string"
  name           = "string"
  steps {
    type = "string"
    composite = {
      kind = "string"
      predicates = [{
        query = "string"
      }]
      max_window_ms = 0
    }
    nodes {
      query = "string"
    }
  }
  category     = "string"
  description  = "string"
  display_name = "string"
  tags         = ["string"]
}

    var rumOperationResource = new RumOperation("rumOperationResource", RumOperationArgs.builder()
    .applicationId("string")
    .name("string")
    .steps(RumOperationStepArgs.builder()
        .type("string")
        .composite(RumOperationStepCompositeArgs.builder()
            .kind("string")
            .predicates(RumOperationStepCompositePredicateArgs.builder()
                .query("string")
                .build())
            .maxWindowMs(0)
            .build())
        .nodes(RumOperationStepNodeArgs.builder()
            .query("string")
            .build())
        .build())
    .category("string")
    .description("string")
    .displayName("string")
    .tags("string")
    .build());

    rum_operation_resource = datadog.RumOperation("rumOperationResource",
    application_id="string",
    name="string",
    steps=[{
        "type": "string",
        "composite": {
            "kind": "string",
            "predicates": [{
                "query": "string",
            }],
            "max_window_ms": 0,
        },
        "nodes": [{
            "query": "string",
        }],
    }],
    category="string",
    description="string",
    display_name="string",
    tags=["string"])

    const rumOperationResource = new datadog.RumOperation("rumOperationResource", {
    applicationId: "string",
    name: "string",
    steps: [{
        type: "string",
        composite: {
            kind: "string",
            predicates: [{
                query: "string",
            }],
            maxWindowMs: 0,
        },
        nodes: [{
            query: "string",
        }],
    }],
    category: "string",
    description: "string",
    displayName: "string",
    tags: ["string"],
});

    type: datadog:RumOperation
properties:
    applicationId: string
    category: string
    description: string
    displayName: string
    name: string
    steps:
        - composite:
            kind: string
            maxWindowMs: 0
            predicates:
                - query: string
          nodes:
            - query: string
          type: string
    tags:
        - string

    RumOperation Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The RumOperation resource accepts the following input properties:

    ApplicationId string
    ID of the RUM application the operation belongs to.
    Name string
    Unique name of the operation within the organization. Must not contain spaces. Changing it recreates the operation.
    Steps List<RumOperationStep>
    Ordered steps defining how RUM events drive the operation lifecycle.
    Category string
    Category of the operation.
    Description string
    Description of the operation.
    DisplayName string
    Human readable name of the operation. Defaults to name.
    Tags List<string>
    Tags attached to the operation.
    ApplicationId string
    ID of the RUM application the operation belongs to.
    Name string
    Unique name of the operation within the organization. Must not contain spaces. Changing it recreates the operation.
    Steps []RumOperationStepArgs
    Ordered steps defining how RUM events drive the operation lifecycle.
    Category string
    Category of the operation.
    Description string
    Description of the operation.
    DisplayName string
    Human readable name of the operation. Defaults to name.
    Tags []string
    Tags attached to the operation.
    application_id string
    ID of the RUM application the operation belongs to.
    name string
    Unique name of the operation within the organization. Must not contain spaces. Changing it recreates the operation.
    steps list(object)
    Ordered steps defining how RUM events drive the operation lifecycle.
    category string
    Category of the operation.
    description string
    Description of the operation.
    display_name string
    Human readable name of the operation. Defaults to name.
    tags list(string)
    Tags attached to the operation.
    applicationId String
    ID of the RUM application the operation belongs to.
    name String
    Unique name of the operation within the organization. Must not contain spaces. Changing it recreates the operation.
    steps List<RumOperationStep>
    Ordered steps defining how RUM events drive the operation lifecycle.
    category String
    Category of the operation.
    description String
    Description of the operation.
    displayName String
    Human readable name of the operation. Defaults to name.
    tags List<String>
    Tags attached to the operation.
    applicationId string
    ID of the RUM application the operation belongs to.
    name string
    Unique name of the operation within the organization. Must not contain spaces. Changing it recreates the operation.
    steps RumOperationStep[]
    Ordered steps defining how RUM events drive the operation lifecycle.
    category string
    Category of the operation.
    description string
    Description of the operation.
    displayName string
    Human readable name of the operation. Defaults to name.
    tags string[]
    Tags attached to the operation.
    application_id str
    ID of the RUM application the operation belongs to.
    name str
    Unique name of the operation within the organization. Must not contain spaces. Changing it recreates the operation.
    steps Sequence[RumOperationStepArgs]
    Ordered steps defining how RUM events drive the operation lifecycle.
    category str
    Category of the operation.
    description str
    Description of the operation.
    display_name str
    Human readable name of the operation. Defaults to name.
    tags Sequence[str]
    Tags attached to the operation.
    applicationId String
    ID of the RUM application the operation belongs to.
    name String
    Unique name of the operation within the organization. Must not contain spaces. Changing it recreates the operation.
    steps List<Property Map>
    Ordered steps defining how RUM events drive the operation lifecycle.
    category String
    Category of the operation.
    description String
    Description of the operation.
    displayName String
    Human readable name of the operation. Defaults to name.
    tags List<String>
    Tags attached to the operation.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the RumOperation resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing RumOperation Resource

    Get an existing RumOperation resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: RumOperationState, opts?: CustomResourceOptions): RumOperation
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        application_id: Optional[str] = None,
        category: Optional[str] = None,
        description: Optional[str] = None,
        display_name: Optional[str] = None,
        name: Optional[str] = None,
        steps: Optional[Sequence[RumOperationStepArgs]] = None,
        tags: Optional[Sequence[str]] = None) -> RumOperation
    func GetRumOperation(ctx *Context, name string, id IDInput, state *RumOperationState, opts ...ResourceOption) (*RumOperation, error)
    public static RumOperation Get(string name, Input<string> id, RumOperationState? state, CustomResourceOptions? opts = null)
    public static RumOperation get(String name, Output<String> id, RumOperationState state, CustomResourceOptions options)
    resources:  _:    type: datadog:RumOperation    get:      id: ${id}
    import {
  to = datadog_rum_operation.example
  id = "${id}"
}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    ApplicationId string
    ID of the RUM application the operation belongs to.
    Category string
    Category of the operation.
    Description string
    Description of the operation.
    DisplayName string
    Human readable name of the operation. Defaults to name.
    Name string
    Unique name of the operation within the organization. Must not contain spaces. Changing it recreates the operation.
    Steps List<RumOperationStep>
    Ordered steps defining how RUM events drive the operation lifecycle.
    Tags List<string>
    Tags attached to the operation.
    ApplicationId string
    ID of the RUM application the operation belongs to.
    Category string
    Category of the operation.
    Description string
    Description of the operation.
    DisplayName string
    Human readable name of the operation. Defaults to name.
    Name string
    Unique name of the operation within the organization. Must not contain spaces. Changing it recreates the operation.
    Steps []RumOperationStepArgs
    Ordered steps defining how RUM events drive the operation lifecycle.
    Tags []string
    Tags attached to the operation.
    application_id string
    ID of the RUM application the operation belongs to.
    category string
    Category of the operation.
    description string
    Description of the operation.
    display_name string
    Human readable name of the operation. Defaults to name.
    name string
    Unique name of the operation within the organization. Must not contain spaces. Changing it recreates the operation.
    steps list(object)
    Ordered steps defining how RUM events drive the operation lifecycle.
    tags list(string)
    Tags attached to the operation.
    applicationId String
    ID of the RUM application the operation belongs to.
    category String
    Category of the operation.
    description String
    Description of the operation.
    displayName String
    Human readable name of the operation. Defaults to name.
    name String
    Unique name of the operation within the organization. Must not contain spaces. Changing it recreates the operation.
    steps List<RumOperationStep>
    Ordered steps defining how RUM events drive the operation lifecycle.
    tags List<String>
    Tags attached to the operation.
    applicationId string
    ID of the RUM application the operation belongs to.
    category string
    Category of the operation.
    description string
    Description of the operation.
    displayName string
    Human readable name of the operation. Defaults to name.
    name string
    Unique name of the operation within the organization. Must not contain spaces. Changing it recreates the operation.
    steps RumOperationStep[]
    Ordered steps defining how RUM events drive the operation lifecycle.
    tags string[]
    Tags attached to the operation.
    application_id str
    ID of the RUM application the operation belongs to.
    category str
    Category of the operation.
    description str
    Description of the operation.
    display_name str
    Human readable name of the operation. Defaults to name.
    name str
    Unique name of the operation within the organization. Must not contain spaces. Changing it recreates the operation.
    steps Sequence[RumOperationStepArgs]
    Ordered steps defining how RUM events drive the operation lifecycle.
    tags Sequence[str]
    Tags attached to the operation.
    applicationId String
    ID of the RUM application the operation belongs to.
    category String
    Category of the operation.
    description String
    Description of the operation.
    displayName String
    Human readable name of the operation. Defaults to name.
    name String
    Unique name of the operation within the organization. Must not contain spaces. Changing it recreates the operation.
    steps List<Property Map>
    Ordered steps defining how RUM events drive the operation lifecycle.
    tags List<String>
    Tags attached to the operation.

    Supporting Types

    RumOperationStep, RumOperationStepArgs

    Type string
    Lifecycle transition triggered by this step. Valid values are start, update, stop, error, abandoned.
    Composite RumOperationStepComposite
    Rule combining several predicates into this step. Exactly one of nodes or composite must be set.
    Nodes List<RumOperationStepNode>
    Queries matched by this step. Exactly one of nodes or composite must be set.
    Type string
    Lifecycle transition triggered by this step. Valid values are start, update, stop, error, abandoned.
    Composite RumOperationStepComposite
    Rule combining several predicates into this step. Exactly one of nodes or composite must be set.
    Nodes []RumOperationStepNode
    Queries matched by this step. Exactly one of nodes or composite must be set.
    type string
    Lifecycle transition triggered by this step. Valid values are start, update, stop, error, abandoned.
    composite object
    Rule combining several predicates into this step. Exactly one of nodes or composite must be set.
    nodes list(object)
    Queries matched by this step. Exactly one of nodes or composite must be set.
    type String
    Lifecycle transition triggered by this step. Valid values are start, update, stop, error, abandoned.
    composite RumOperationStepComposite
    Rule combining several predicates into this step. Exactly one of nodes or composite must be set.
    nodes List<RumOperationStepNode>
    Queries matched by this step. Exactly one of nodes or composite must be set.
    type string
    Lifecycle transition triggered by this step. Valid values are start, update, stop, error, abandoned.
    composite RumOperationStepComposite
    Rule combining several predicates into this step. Exactly one of nodes or composite must be set.
    nodes RumOperationStepNode[]
    Queries matched by this step. Exactly one of nodes or composite must be set.
    type str
    Lifecycle transition triggered by this step. Valid values are start, update, stop, error, abandoned.
    composite RumOperationStepComposite
    Rule combining several predicates into this step. Exactly one of nodes or composite must be set.
    nodes Sequence[RumOperationStepNode]
    Queries matched by this step. Exactly one of nodes or composite must be set.
    type String
    Lifecycle transition triggered by this step. Valid values are start, update, stop, error, abandoned.
    composite Property Map
    Rule combining several predicates into this step. Exactly one of nodes or composite must be set.
    nodes List<Property Map>
    Queries matched by this step. Exactly one of nodes or composite must be set.

    RumOperationStepComposite, RumOperationStepCompositeArgs

    Kind string
    How the predicates combine. Valid values are allOf, inOrder.
    Predicates List<RumOperationStepCompositePredicate>
    Predicates combined by the rule.
    MaxWindowMs int
    Maximum time window, in milliseconds, in which all predicates must match. Value must be between 0 and 1800000.
    Kind string
    How the predicates combine. Valid values are allOf, inOrder.
    Predicates []RumOperationStepCompositePredicate
    Predicates combined by the rule.
    MaxWindowMs int
    Maximum time window, in milliseconds, in which all predicates must match. Value must be between 0 and 1800000.
    kind string
    How the predicates combine. Valid values are allOf, inOrder.
    predicates list(object)
    Predicates combined by the rule.
    max_window_ms number
    Maximum time window, in milliseconds, in which all predicates must match. Value must be between 0 and 1800000.
    kind String
    How the predicates combine. Valid values are allOf, inOrder.
    predicates List<RumOperationStepCompositePredicate>
    Predicates combined by the rule.
    maxWindowMs Integer
    Maximum time window, in milliseconds, in which all predicates must match. Value must be between 0 and 1800000.
    kind string
    How the predicates combine. Valid values are allOf, inOrder.
    predicates RumOperationStepCompositePredicate[]
    Predicates combined by the rule.
    maxWindowMs number
    Maximum time window, in milliseconds, in which all predicates must match. Value must be between 0 and 1800000.
    kind str
    How the predicates combine. Valid values are allOf, inOrder.
    predicates Sequence[RumOperationStepCompositePredicate]
    Predicates combined by the rule.
    max_window_ms int
    Maximum time window, in milliseconds, in which all predicates must match. Value must be between 0 and 1800000.
    kind String
    How the predicates combine. Valid values are allOf, inOrder.
    predicates List<Property Map>
    Predicates combined by the rule.
    maxWindowMs Number
    Maximum time window, in milliseconds, in which all predicates must match. Value must be between 0 and 1800000.

    RumOperationStepCompositePredicate, RumOperationStepCompositePredicateArgs

    Query string
    RUM event search query.
    Query string
    RUM event search query.
    query string
    RUM event search query.
    query String
    RUM event search query.
    query string
    RUM event search query.
    query str
    RUM event search query.
    query String
    RUM event search query.

    RumOperationStepNode, RumOperationStepNodeArgs

    Query string
    RUM event search query.
    Query string
    RUM event search query.
    query string
    RUM event search query.
    query String
    RUM event search query.
    query string
    RUM event search query.
    query str
    RUM event search query.
    query String
    RUM event search query.

    Import

    The pulumi import command can be used, for example:

    $ pulumi import datadog:index/rumOperation:RumOperation checkout "<operation_id>"

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    Datadog pulumi/pulumi-datadog
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the datadog Terraform Provider.
    datadog logo
    Viewing docs for Datadog v5.17.1
    published on Tuesday, Oct 27, 2026 by Pulumi
    Schema (JSON)
    pulumi/pulumi-datadog

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial