oci.LogAnalytics.getLogAnalyticsCategory

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

const testLogAnalyticsCategory = oci.LogAnalytics.getLogAnalyticsCategory({
    name: logAnalyticsCategoryName,
    namespace: logAnalyticsCategoryNamespace,
});

import pulumi
import pulumi_oci as oci

test_log_analytics_category = oci.LogAnalytics.get_log_analytics_category(name=log_analytics_category_name,
    namespace=log_analytics_category_namespace)

package main

import (
	"github.com/pulumi/pulumi-oci/sdk/v2/go/oci/LogAnalytics"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := LogAnalytics.GetLogAnalyticsCategory(ctx, &loganalytics.GetLogAnalyticsCategoryArgs{
			Name:      logAnalyticsCategoryName,
			Namespace: logAnalyticsCategoryNamespace,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var testLogAnalyticsCategory = Oci.LogAnalytics.GetLogAnalyticsCategory.Invoke(new()
    {
        Name = logAnalyticsCategoryName,
        Namespace = logAnalyticsCategoryNamespace,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.oci.LogAnalytics.LogAnalyticsFunctions;
import com.pulumi.oci.LogAnalytics.inputs.GetLogAnalyticsCategoryArgs;
import java.util.List;
import java.util.ArrayList;
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 testLogAnalyticsCategory = LogAnalyticsFunctions.getLogAnalyticsCategory(GetLogAnalyticsCategoryArgs.builder()
            .name(logAnalyticsCategoryName)
            .namespace(logAnalyticsCategoryNamespace)
            .build());

    }
}

variables:
  testLogAnalyticsCategory:
    fn::invoke:
      Function: oci:LogAnalytics:getLogAnalyticsCategory
      Arguments:
        name: ${logAnalyticsCategoryName}
        namespace: ${logAnalyticsCategoryNamespace}

function getLogAnalyticsCategory(args: GetLogAnalyticsCategoryArgs, opts?: InvokeOptions): Promise<GetLogAnalyticsCategoryResult>
function getLogAnalyticsCategoryOutput(args: GetLogAnalyticsCategoryOutputArgs, opts?: InvokeOptions): Output<GetLogAnalyticsCategoryResult>

def get_log_analytics_category(name: Optional[str] = None,
                               namespace: Optional[str] = None,
                               opts: Optional[InvokeOptions] = None) -> GetLogAnalyticsCategoryResult
def get_log_analytics_category_output(name: Optional[pulumi.Input[str]] = None,
                               namespace: Optional[pulumi.Input[str]] = None,
                               opts: Optional[InvokeOptions] = None) -> Output[GetLogAnalyticsCategoryResult]

func GetLogAnalyticsCategory(ctx *Context, args *GetLogAnalyticsCategoryArgs, opts ...InvokeOption) (*GetLogAnalyticsCategoryResult, error)
func GetLogAnalyticsCategoryOutput(ctx *Context, args *GetLogAnalyticsCategoryOutputArgs, opts ...InvokeOption) GetLogAnalyticsCategoryResultOutput

public static class GetLogAnalyticsCategory 
{
    public static Task<GetLogAnalyticsCategoryResult> InvokeAsync(GetLogAnalyticsCategoryArgs args, InvokeOptions? opts = null)
    public static Output<GetLogAnalyticsCategoryResult> Invoke(GetLogAnalyticsCategoryInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetLogAnalyticsCategoryResult> getLogAnalyticsCategory(GetLogAnalyticsCategoryArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: oci:LogAnalytics/getLogAnalyticsCategory:getLogAnalyticsCategory
  arguments:
    # arguments dictionary