datadog.RumRetentionFiltersOrder

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

// Create a new rum_application resource.
const myRumApplication = new datadog.RumApplication("my_rum_application", {
    name: "my-rum-application-test",
    type: "browser",
});
// Retrieve rum_retention_filters for the rum_application created above.
const myRetentionFilters = datadog.getRumRetentionFilters({
    applicationId: datadogRumApplication.myRumApplication.id,
});
// Create a new rum_retention_filter resource.
const newRumRetentionFilter = new datadog.RumRetentionFilter("new_rum_retention_filter", {
    applicationId: datadogRumApplication.myRumApplication.id,
    name: "testing.rum.retention_filter",
    eventType: "action",
    sampleRate: 60,
    query: "@session.has_replay:true",
    enabled: true,
});
// Create a new rum_retention_filters_order resource for reordering.
// Please note that the IDs of all default retention filters have the prefix 'default', and you need to populate the retention_filter_ids field with all retention filter IDs.
const myRumRetentionFiltersOrder = new datadog.RumRetentionFiltersOrder("my_rum_retention_filters_order", {
    applicationId: datadogRumApplication.myRumApplication.id,
    retentionFilterIds: std.index.concat({
        input: [
            myRetentionFilters.then(myRetentionFilters => .filter(rf => std.index.startswith({
                input: rf.id,
                prefix: "default",
            }).result).map(rf => (rf.id))),
            [newRumRetentionFilter.id],
            pulumi.all([myRetentionFilters, newRumRetentionFilter.id]).apply(([myRetentionFilters, id]) => .filter(rf => !std.index.startswith({
                input: rf.id,
                prefix: "default",
            }).result && rf.id != id).map(rf => (rf.id))),
        ],
    }).result,
});

import pulumi
import pulumi_datadog as datadog
import pulumi_std as std

# Create a new rum_application resource.
my_rum_application = datadog.RumApplication("my_rum_application",
    name="my-rum-application-test",
    type="browser")
# Retrieve rum_retention_filters for the rum_application created above.
my_retention_filters = datadog.get_rum_retention_filters(application_id=datadog_rum_application["myRumApplication"]["id"])
# Create a new rum_retention_filter resource.
new_rum_retention_filter = datadog.RumRetentionFilter("new_rum_retention_filter",
    application_id=datadog_rum_application["myRumApplication"]["id"],
    name="testing.rum.retention_filter",
    event_type="action",
    sample_rate=60,
    query="@session.has_replay:true",
    enabled=True)
# Create a new rum_retention_filters_order resource for reordering.
# Please note that the IDs of all default retention filters have the prefix 'default', and you need to populate the retention_filter_ids field with all retention filter IDs.
my_rum_retention_filters_order = datadog.RumRetentionFiltersOrder("my_rum_retention_filters_order",
    application_id=datadog_rum_application["myRumApplication"]["id"],
    retention_filter_ids=std.index.concat(input=[
        [rf.id for rf in my_retention_filters.retention_filters if std.index.startswith(input=rf.id,
            prefix="default")["result"]],
        [new_rum_retention_filter.id],
        [rf.id for rf in my_retention_filters.retention_filters if not std.index.startswith(input=rf.id,
            prefix="default")["result"] and rf.id != _arg0_],
    ])["result"])

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

return await Deployment.RunAsync(() => 
{
    // Create a new rum_application resource.
    var myRumApplication = new Datadog.RumApplication("my_rum_application", new()
    {
        Name = "my-rum-application-test",
        Type = "browser",
    });

    // Retrieve rum_retention_filters for the rum_application created above.
    var myRetentionFilters = Datadog.GetRumRetentionFilters.Invoke(new()
    {
        ApplicationId = datadogRumApplication.MyRumApplication.Id,
    });

    // Create a new rum_retention_filter resource.
    var newRumRetentionFilter = new Datadog.RumRetentionFilter("new_rum_retention_filter", new()
    {
        ApplicationId = datadogRumApplication.MyRumApplication.Id,
        Name = "testing.rum.retention_filter",
        EventType = "action",
        SampleRate = 60,
        Query = "@session.has_replay:true",
        Enabled = true,
    });

    // Create a new rum_retention_filters_order resource for reordering.
    // Please note that the IDs of all default retention filters have the prefix 'default', and you need to populate the retention_filter_ids field with all retention filter IDs.
    var myRumRetentionFiltersOrder = new Datadog.RumRetentionFiltersOrder("my_rum_retention_filters_order", new()
    {
        ApplicationId = datadogRumApplication.MyRumApplication.Id,
        RetentionFilterIds = Std.Index.Concat.Invoke(new()
        {
            Input = new[]
            {
                .Where(rf => Std.Index.Startswith.Invoke(new()
                {
                    Input = rf.Id,
                    Prefix = "default",
                }).Result).Select(rf => 
                {
                    return rf.Id;
                }).ToList(),
                new[]
                {
                    newRumRetentionFilter.Id,
                },
                Output.Tuple(myRetentionFilters, newRumRetentionFilter.Id).Apply(values =>
                {
                    var myRetentionFilters = values.Item1;
                    var id = values.Item2;
                    return .Where(rf => !Std.Index.Startswith.Invoke(new()
                    {
                        Input = rf.Id,
                        Prefix = "default",
                    }).Result && rf.Id != id).Select(rf => 
                    {
                        return rf.Id;
                    }).ToList();
                }),
            },
        }).Result,
    });

});

var rumRetentionFiltersOrderResource = new Datadog.RumRetentionFiltersOrder("rumRetentionFiltersOrderResource", new()
{
    ApplicationId = "string",
    RetentionFilterIds = new[]
    {
        "string",
    },
});

example, err := datadog.NewRumRetentionFiltersOrder(ctx, "rumRetentionFiltersOrderResource", &datadog.RumRetentionFiltersOrderArgs{
	ApplicationId: pulumi.String("string"),
	RetentionFilterIds: pulumi.StringArray{
		pulumi.String("string"),
	},
})

var rumRetentionFiltersOrderResource = new RumRetentionFiltersOrder("rumRetentionFiltersOrderResource", RumRetentionFiltersOrderArgs.builder()
    .applicationId("string")
    .retentionFilterIds("string")
    .build());

rum_retention_filters_order_resource = datadog.RumRetentionFiltersOrder("rumRetentionFiltersOrderResource",
    application_id="string",
    retention_filter_ids=["string"])

const rumRetentionFiltersOrderResource = new datadog.RumRetentionFiltersOrder("rumRetentionFiltersOrderResource", {
    applicationId: "string",
    retentionFilterIds: ["string"],
});

type: datadog:RumRetentionFiltersOrder
properties:
    applicationId: string
    retentionFilterIds:
        - string