datadog.getLogsPipelines

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

const pipelines = datadog.getLogsPipelines({});
// Using data source to set pipeline order
const lpo = new datadog.LogsPipelineOrder("lpo", {
    name: "lpo",
    pipelines: pipelines.then(pipelines => .map(pipeline => (pipeline.id))),
});

import pulumi
import pulumi_datadog as datadog

pipelines = datadog.get_logs_pipelines()
# Using data source to set pipeline order
lpo = datadog.LogsPipelineOrder("lpo",
    name="lpo",
    pipelines=[pipeline.id for pipeline in pipelines.logs_pipelines])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		pipelines, err := datadog.GetLogsPipelines(ctx, nil, nil)
		if err != nil {
			return err
		}
		// Using data source to set pipeline order
		_, err = datadog.NewLogsPipelineOrder(ctx, "lpo", &datadog.LogsPipelineOrderArgs{
			Name:      pulumi.String("lpo"),
			Pipelines: "TODO: For expression",
		})
		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 pipelines = Datadog.GetLogsPipelines.Invoke();

    // Using data source to set pipeline order
    var lpo = new Datadog.LogsPipelineOrder("lpo", new()
    {
        Name = "lpo",
        Pipelines = .Select(pipeline => 
        {
            return pipeline.Id;
        }).ToList(),
    });

});

function getLogsPipelines(args: GetLogsPipelinesArgs, opts?: InvokeOptions): Promise<GetLogsPipelinesResult>
function getLogsPipelinesOutput(args: GetLogsPipelinesOutputArgs, opts?: InvokeOptions): Output<GetLogsPipelinesResult>

def get_logs_pipelines(is_read_only: Optional[str] = None,
                       opts: Optional[InvokeOptions] = None) -> GetLogsPipelinesResult
def get_logs_pipelines_output(is_read_only: Optional[pulumi.Input[str]] = None,
                       opts: Optional[InvokeOptions] = None) -> Output[GetLogsPipelinesResult]

func GetLogsPipelines(ctx *Context, args *GetLogsPipelinesArgs, opts ...InvokeOption) (*GetLogsPipelinesResult, error)
func GetLogsPipelinesOutput(ctx *Context, args *GetLogsPipelinesOutputArgs, opts ...InvokeOption) GetLogsPipelinesResultOutput

public static class GetLogsPipelines 
{
    public static Task<GetLogsPipelinesResult> InvokeAsync(GetLogsPipelinesArgs args, InvokeOptions? opts = null)
    public static Output<GetLogsPipelinesResult> Invoke(GetLogsPipelinesInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetLogsPipelinesResult> getLogsPipelines(GetLogsPipelinesArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: datadog:index/getLogsPipelines:getLogsPipelines
  arguments:
    # arguments dictionary