linode.getMonitorLogsStreams

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

const all = linode.getMonitorLogsStreams({});

import pulumi
import pulumi_linode as linode

all = linode.get_monitor_logs_streams()

package main

import (
	"github.com/pulumi/pulumi-linode/sdk/v6/go/linode"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := linode.GetMonitorLogsStreams(ctx, &linode.GetMonitorLogsStreamsArgs{}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var all = Linode.GetMonitorLogsStreams.Invoke();

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.linode.LinodeFunctions;
import com.pulumi.linode.inputs.GetMonitorLogsStreamsArgs;
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) {
        final var all = LinodeFunctions.getMonitorLogsStreams(GetMonitorLogsStreamsArgs.builder()
            .build());

    }
}

variables:
  all:
    fn::invoke:
      function: linode:getMonitorLogsStreams
      arguments: {}

pulumi {
  required_providers {
    linode = {
      source = "pulumi/linode"
    }
  }
}

data "linode_getmonitorlogsstreams" "all" {
}

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

const activeAudit = linode.getMonitorLogsStreams({
    filters: [
        {
            name: "type",
            values: ["audit_logs"],
        },
        {
            name: "status",
            values: ["active"],
        },
    ],
});

import pulumi
import pulumi_linode as linode

active_audit = linode.get_monitor_logs_streams(filters=[
    {
        "name": "type",
        "values": ["audit_logs"],
    },
    {
        "name": "status",
        "values": ["active"],
    },
])

package main

import (
	"github.com/pulumi/pulumi-linode/sdk/v6/go/linode"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := linode.GetMonitorLogsStreams(ctx, &linode.GetMonitorLogsStreamsArgs{
			Filters: []linode.GetMonitorLogsStreamsFilter{
				{
					Name: "type",
					Values: []string{
						"audit_logs",
					},
				},
				{
					Name: "status",
					Values: []string{
						"active",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var activeAudit = Linode.GetMonitorLogsStreams.Invoke(new()
    {
        Filters = new[]
        {
            new Linode.Inputs.GetMonitorLogsStreamsFilterInputArgs
            {
                Name = "type",
                Values = new[]
                {
                    "audit_logs",
                },
            },
            new Linode.Inputs.GetMonitorLogsStreamsFilterInputArgs
            {
                Name = "status",
                Values = new[]
                {
                    "active",
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.linode.LinodeFunctions;
import com.pulumi.linode.inputs.GetMonitorLogsStreamsArgs;
import com.pulumi.linode.inputs.GetMonitorLogsStreamsFilterArgs;
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) {
        final var activeAudit = LinodeFunctions.getMonitorLogsStreams(GetMonitorLogsStreamsArgs.builder()
            .filters(            
                GetMonitorLogsStreamsFilterArgs.builder()
                    .name("type")
                    .values("audit_logs")
                    .build(),
                GetMonitorLogsStreamsFilterArgs.builder()
                    .name("status")
                    .values("active")
                    .build())
            .build());

    }
}

variables:
  activeAudit:
    fn::invoke:
      function: linode:getMonitorLogsStreams
      arguments:
        filters:
          - name: type
            values:
              - audit_logs
          - name: status
            values:
              - active

pulumi {
  required_providers {
    linode = {
      source = "pulumi/linode"
    }
  }
}

data "linode_getmonitorlogsstreams" "activeAudit" {
  filters {
    name   = "type"
    values = ["audit_logs"]
  }
  filters {
    name   = "status"
    values = ["active"]
  }
}

function getMonitorLogsStreams(args: GetMonitorLogsStreamsArgs, opts?: InvokeOptions): Promise<GetMonitorLogsStreamsResult>
function getMonitorLogsStreamsOutput(args: GetMonitorLogsStreamsOutputArgs, opts?: InvokeOutputOptions): Output<GetMonitorLogsStreamsResult>

def get_monitor_logs_streams(filters: Optional[Sequence[GetMonitorLogsStreamsFilter]] = None,
                             order: Optional[str] = None,
                             order_by: Optional[str] = None,
                             opts: Optional[InvokeOptions] = None) -> GetMonitorLogsStreamsResult
def get_monitor_logs_streams_output(filters: pulumi.Input[Optional[Sequence[pulumi.Input[GetMonitorLogsStreamsFilterArgs]]]] = None,
                             order: pulumi.Input[Optional[str]] = None,
                             order_by: pulumi.Input[Optional[str]] = None,
                             opts: Optional[InvokeOutputOptions] = None) -> Output[GetMonitorLogsStreamsResult]

func GetMonitorLogsStreams(ctx *Context, args *GetMonitorLogsStreamsArgs, opts ...InvokeOption) (*GetMonitorLogsStreamsResult, error)
func GetMonitorLogsStreamsOutput(ctx *Context, args *GetMonitorLogsStreamsOutputArgs, opts ...InvokeOption) GetMonitorLogsStreamsResultOutput

public static class GetMonitorLogsStreams 
{
    public static Task<GetMonitorLogsStreamsResult> InvokeAsync(GetMonitorLogsStreamsArgs args, InvokeOptions? opts = null)
    public static Output<GetMonitorLogsStreamsResult> Invoke(GetMonitorLogsStreamsInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetMonitorLogsStreamsResult> Invoke(GetMonitorLogsStreamsInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetMonitorLogsStreamsResult> getMonitorLogsStreams(GetMonitorLogsStreamsArgs args, InvokeOptions options)
public static Output<GetMonitorLogsStreamsResult> getMonitorLogsStreams(GetMonitorLogsStreamsArgs args, InvokeOptions options)
public static Output<GetMonitorLogsStreamsResult> getMonitorLogsStreams(GetMonitorLogsStreamsArgs args, InvokeOutputOptions options)

fn::invoke:
  function: linode:index/getMonitorLogsStreams:getMonitorLogsStreams
  arguments:
    # arguments dictionary

data "linode_get_monitor_logs_streams" "name" {
    # arguments
}