signalfx.getBuiltinDashboards

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

export = async () => {
    const example = await signalfx.getBuiltinDashboards({});
    //# A simple example making a reference to a specific dashboard group and dashboard. 
    const my_service_dashboard_group = new signalfx.DashboardGroup("my-service-dashboard-group", {
        name: "Example Dashboard Group",
        dashboards: [{
            dashboardId: example.results?.AWS_ECS?.eCSService,
            nameOverride: "My Awesome Service ECS Dashboard",
        }],
    });
    return {
        "all-dashboards": example,
    };
}

import pulumi
import pulumi_signalfx as signalfx

example = signalfx.get_builtin_dashboards()
pulumi.export("all-dashboards", example)
## A simple example making a reference to a specific dashboard group and dashboard. 
my_service_dashboard_group = signalfx.DashboardGroup("my-service-dashboard-group",
    name="Example Dashboard Group",
    dashboards=[{
        "dashboard_id": example.results["AWS_ECS"]["eCSService"],
        "name_override": "My Awesome Service ECS Dashboard",
    }])

package main

import (
	"github.com/pulumi/pulumi-signalfx/sdk/v7/go/signalfx"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := signalfx.GetBuiltinDashboards(ctx, map[string]interface{}{}, nil)
		if err != nil {
			return err
		}
		ctx.Export("all-dashboards", example)
		// # A simple example making a reference to a specific dashboard group and dashboard.
		_, err = signalfx.NewDashboardGroup(ctx, "my-service-dashboard-group", &signalfx.DashboardGroupArgs{
			Name: pulumi.String("Example Dashboard Group"),
			Dashboards: signalfx.DashboardGroupDashboardArray{
				&signalfx.DashboardGroupDashboardArgs{
					DashboardId:  pulumi.String(example.Results.AWS_ECS.ECSService),
					NameOverride: pulumi.String("My Awesome Service ECS Dashboard"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = SignalFx.GetBuiltinDashboards.Invoke();

    //# A simple example making a reference to a specific dashboard group and dashboard. 
    var my_service_dashboard_group = new SignalFx.DashboardGroup("my-service-dashboard-group", new()
    {
        Name = "Example Dashboard Group",
        Dashboards = new[]
        {
            new SignalFx.Inputs.DashboardGroupDashboardArgs
            {
                DashboardId = example.Apply(getBuiltinDashboardsResult => getBuiltinDashboardsResult.Results?.AWS_ECS?.ECSService),
                NameOverride = "My Awesome Service ECS Dashboard",
            },
        },
    });

    return new Dictionary<string, object?>
    {
        ["all-dashboards"] = example,
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.signalfx.SignalfxFunctions;
import com.pulumi.signalfx.DashboardGroup;
import com.pulumi.signalfx.DashboardGroupArgs;
import com.pulumi.signalfx.inputs.DashboardGroupDashboardArgs;
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 example = SignalfxFunctions.getBuiltinDashboards(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference);

        ctx.export("all-dashboards", example);
        //# A simple example making a reference to a specific dashboard group and dashboard. 
        var my_service_dashboard_group = new DashboardGroup("my-service-dashboard-group", DashboardGroupArgs.builder()
            .name("Example Dashboard Group")
            .dashboards(DashboardGroupDashboardArgs.builder()
                .dashboardId(example.results().AWS_ECS().eCSService())
                .nameOverride("My Awesome Service ECS Dashboard")
                .build())
            .build());

    }
}

resources:
  ## A simple example making a reference to a specific dashboard group and dashboard.
  my-service-dashboard-group:
    type: signalfx:DashboardGroup
    properties:
      name: Example Dashboard Group
      dashboards:
        - dashboardId: ${example.results.AWS_ECS.eCSService}
          nameOverride: My Awesome Service ECS Dashboard
variables:
  example:
    fn::invoke:
      function: signalfx:getBuiltinDashboards
      arguments: {}
outputs:
  all-dashboards: ${example}

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

data "signalfx_getbuiltindashboards" "example" {
}

## A simple example making a reference to a specific dashboard group and dashboard. 
resource "signalfx_dashboardgroup" "my-service-dashboard-group" {
  name = "Example Dashboard Group"
  dashboards {
    dashboard_id  = data.signalfx_getbuiltindashboards.example.results.AWS_ECS.eCSService
    name_override = "My Awesome Service ECS Dashboard"
  }
}
output "all-dashboards" {
  value = data.signalfx_getbuiltindashboards.example
}

function getBuiltinDashboards(opts?: InvokeOptions): Promise<GetBuiltinDashboardsResult>
function getBuiltinDashboardsOutput(opts?: InvokeOutputOptions): Output<GetBuiltinDashboardsResult>

def get_builtin_dashboards(opts: Optional[InvokeOptions] = None) -> GetBuiltinDashboardsResult
def get_builtin_dashboards_output(opts: Optional[InvokeOutputOptions] = None) -> Output[GetBuiltinDashboardsResult]

func GetBuiltinDashboards(ctx *Context, opts ...InvokeOption) (*GetBuiltinDashboardsResult, error)
func GetBuiltinDashboardsOutput(ctx *Context, opts ...InvokeOption) GetBuiltinDashboardsResultOutput

public static class GetBuiltinDashboards 
{
    public static Task<GetBuiltinDashboardsResult> InvokeAsync(InvokeOptions? opts = null)
    public static Output<GetBuiltinDashboardsResult> Invoke(InvokeOptions? opts = null)
    public static Output<GetBuiltinDashboardsResult> Invoke(InvokeOutputOptions opts)
}

public static CompletableFuture<GetBuiltinDashboardsResult> getBuiltinDashboards(InvokeOptions options)
public static Output<GetBuiltinDashboardsResult> getBuiltinDashboards(InvokeOptions options)
public static Output<GetBuiltinDashboardsResult> getBuiltinDashboards(InvokeOutputOptions options)

fn::invoke:
  function: signalfx:index/getBuiltinDashboards:getBuiltinDashboards
  arguments:
    # arguments dictionary

data "signalfx_get_builtin_dashboards" "name" {
    # arguments
}