grafana.slo.getSlos

import * as pulumi from "@pulumi/pulumi";
import * as grafana from "@pulumiverse/grafana";

const test = new grafana.slo.SLO("test", {
    name: "Terraform Testing",
    description: "Terraform Description",
    queries: [{
        freeform: {
            query: "sum(rate(apiserver_request_total{code!=\"500\"}[$__rate_interval])) / sum(rate(apiserver_request_total[$__rate_interval]))",
        },
        type: "freeform",
    }],
    objectives: [{
        value: 0.995,
        window: "30d",
    }],
    destinationDatasource: {
        uid: "grafanacloud-prom",
    },
    labels: [{
        key: "custom",
        value: "value",
    }],
    alerting: {
        fastburn: {
            annotations: [{
                key: "name",
                value: "Critical - SLO Burn Rate Alert",
            }],
            labels: [{
                key: "type",
                value: "slo",
            }],
        },
        slowburn: {
            annotations: [{
                key: "name",
                value: "Warning - SLO Burn Rate Alert",
            }],
            labels: [{
                key: "type",
                value: "slo",
            }],
        },
    },
});
const slos = grafana.slo.getSlos({});

import pulumi
import pulumi_grafana as grafana
import pulumiverse_grafana as grafana

test = grafana.slo.SLO("test",
    name="Terraform Testing",
    description="Terraform Description",
    queries=[{
        "freeform": {
            "query": "sum(rate(apiserver_request_total{code!=\"500\"}[$__rate_interval])) / sum(rate(apiserver_request_total[$__rate_interval]))",
        },
        "type": "freeform",
    }],
    objectives=[{
        "value": 0.995,
        "window": "30d",
    }],
    destination_datasource={
        "uid": "grafanacloud-prom",
    },
    labels=[{
        "key": "custom",
        "value": "value",
    }],
    alerting={
        "fastburn": {
            "annotations": [{
                "key": "name",
                "value": "Critical - SLO Burn Rate Alert",
            }],
            "labels": [{
                "key": "type",
                "value": "slo",
            }],
        },
        "slowburn": {
            "annotations": [{
                "key": "name",
                "value": "Warning - SLO Burn Rate Alert",
            }],
            "labels": [{
                "key": "type",
                "value": "slo",
            }],
        },
    })
slos = grafana.slo.get_slos()

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-grafana/sdk/v2/go/grafana/slo"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := slo.NewSLO(ctx, "test", &slo.SLOArgs{
			Name:        pulumi.String("Terraform Testing"),
			Description: pulumi.String("Terraform Description"),
			Queries: slo.SLOQueryArray{
				&slo.SLOQueryArgs{
					Freeform: &slo.SLOQueryFreeformArgs{
						Query: pulumi.String("sum(rate(apiserver_request_total{code!=\"500\"}[$__rate_interval])) / sum(rate(apiserver_request_total[$__rate_interval]))"),
					},
					Type: pulumi.String("freeform"),
				},
			},
			Objectives: slo.SLOObjectiveArray{
				&slo.SLOObjectiveArgs{
					Value:  pulumi.Float64(0.995),
					Window: pulumi.String("30d"),
				},
			},
			DestinationDatasource: &slo.SLODestinationDatasourceArgs{
				Uid: pulumi.String("grafanacloud-prom"),
			},
			Labels: slo.SLOLabelArray{
				&slo.SLOLabelArgs{
					Key:   pulumi.String("custom"),
					Value: pulumi.String("value"),
				},
			},
			Alerting: &slo.SLOAlertingArgs{
				Fastburn: &slo.SLOAlertingFastburnArgs{
					Annotations: slo.SLOAlertingFastburnAnnotationArray{
						&slo.SLOAlertingFastburnAnnotationArgs{
							Key:   pulumi.String("name"),
							Value: pulumi.String("Critical - SLO Burn Rate Alert"),
						},
					},
					Labels: slo.SLOAlertingFastburnLabelArray{
						&slo.SLOAlertingFastburnLabelArgs{
							Key:   pulumi.String("type"),
							Value: pulumi.String("slo"),
						},
					},
				},
				Slowburn: &slo.SLOAlertingSlowburnArgs{
					Annotations: slo.SLOAlertingSlowburnAnnotationArray{
						&slo.SLOAlertingSlowburnAnnotationArgs{
							Key:   pulumi.String("name"),
							Value: pulumi.String("Warning - SLO Burn Rate Alert"),
						},
					},
					Labels: slo.SLOAlertingSlowburnLabelArray{
						&slo.SLOAlertingSlowburnLabelArgs{
							Key:   pulumi.String("type"),
							Value: pulumi.String("slo"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = slo.GetSlos(ctx, &slo.GetSlosArgs{}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Grafana = Pulumiverse.Grafana;

return await Deployment.RunAsync(() => 
{
    var test = new Grafana.Slo.SLO("test", new()
    {
        Name = "Terraform Testing",
        Description = "Terraform Description",
        Queries = new[]
        {
            new Grafana.Slo.Inputs.SLOQueryArgs
            {
                Freeform = new Grafana.Slo.Inputs.SLOQueryFreeformArgs
                {
                    Query = "sum(rate(apiserver_request_total{code!=\"500\"}[$__rate_interval])) / sum(rate(apiserver_request_total[$__rate_interval]))",
                },
                Type = "freeform",
            },
        },
        Objectives = new[]
        {
            new Grafana.Slo.Inputs.SLOObjectiveArgs
            {
                Value = 0.995,
                Window = "30d",
            },
        },
        DestinationDatasource = new Grafana.Slo.Inputs.SLODestinationDatasourceArgs
        {
            Uid = "grafanacloud-prom",
        },
        Labels = new[]
        {
            new Grafana.Slo.Inputs.SLOLabelArgs
            {
                Key = "custom",
                Value = "value",
            },
        },
        Alerting = new Grafana.Slo.Inputs.SLOAlertingArgs
        {
            Fastburn = new Grafana.Slo.Inputs.SLOAlertingFastburnArgs
            {
                Annotations = new[]
                {
                    new Grafana.Slo.Inputs.SLOAlertingFastburnAnnotationArgs
                    {
                        Key = "name",
                        Value = "Critical - SLO Burn Rate Alert",
                    },
                },
                Labels = new[]
                {
                    new Grafana.Slo.Inputs.SLOAlertingFastburnLabelArgs
                    {
                        Key = "type",
                        Value = "slo",
                    },
                },
            },
            Slowburn = new Grafana.Slo.Inputs.SLOAlertingSlowburnArgs
            {
                Annotations = new[]
                {
                    new Grafana.Slo.Inputs.SLOAlertingSlowburnAnnotationArgs
                    {
                        Key = "name",
                        Value = "Warning - SLO Burn Rate Alert",
                    },
                },
                Labels = new[]
                {
                    new Grafana.Slo.Inputs.SLOAlertingSlowburnLabelArgs
                    {
                        Key = "type",
                        Value = "slo",
                    },
                },
            },
        },
    });

    var slos = Grafana.Slo.GetSlos.Invoke();

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.grafana.slo.SLO;
import com.pulumi.grafana.slo.SLOArgs;
import com.pulumi.grafana.slo.inputs.SLOQueryArgs;
import com.pulumi.grafana.slo.inputs.SLOQueryFreeformArgs;
import com.pulumi.grafana.slo.inputs.SLOObjectiveArgs;
import com.pulumi.grafana.slo.inputs.SLODestinationDatasourceArgs;
import com.pulumi.grafana.slo.inputs.SLOLabelArgs;
import com.pulumi.grafana.slo.inputs.SLOAlertingArgs;
import com.pulumi.grafana.slo.inputs.SLOAlertingFastburnArgs;
import com.pulumi.grafana.slo.inputs.SLOAlertingSlowburnArgs;
import com.pulumi.grafana.slo.SloFunctions;
import com.pulumi.grafana.slo.inputs.GetSlosArgs;
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) {
        var test = new SLO("test", SLOArgs.builder()
            .name("Terraform Testing")
            .description("Terraform Description")
            .queries(SLOQueryArgs.builder()
                .freeform(SLOQueryFreeformArgs.builder()
                    .query("sum(rate(apiserver_request_total{code!=\"500\"}[$__rate_interval])) / sum(rate(apiserver_request_total[$__rate_interval]))")
                    .build())
                .type("freeform")
                .build())
            .objectives(SLOObjectiveArgs.builder()
                .value(0.995)
                .window("30d")
                .build())
            .destinationDatasource(SLODestinationDatasourceArgs.builder()
                .uid("grafanacloud-prom")
                .build())
            .labels(SLOLabelArgs.builder()
                .key("custom")
                .value("value")
                .build())
            .alerting(SLOAlertingArgs.builder()
                .fastburn(SLOAlertingFastburnArgs.builder()
                    .annotations(SLOAlertingFastburnAnnotationArgs.builder()
                        .key("name")
                        .value("Critical - SLO Burn Rate Alert")
                        .build())
                    .labels(SLOAlertingFastburnLabelArgs.builder()
                        .key("type")
                        .value("slo")
                        .build())
                    .build())
                .slowburn(SLOAlertingSlowburnArgs.builder()
                    .annotations(SLOAlertingSlowburnAnnotationArgs.builder()
                        .key("name")
                        .value("Warning - SLO Burn Rate Alert")
                        .build())
                    .labels(SLOAlertingSlowburnLabelArgs.builder()
                        .key("type")
                        .value("slo")
                        .build())
                    .build())
                .build())
            .build());

        final var slos = SloFunctions.getSlos(GetSlosArgs.builder()
            .build());

    }
}

resources:
  test:
    type: grafana:slo:SLO
    properties:
      name: Terraform Testing
      description: Terraform Description
      queries:
        - freeform:
            query: sum(rate(apiserver_request_total{code!="500"}[$__rate_interval])) / sum(rate(apiserver_request_total[$__rate_interval]))
          type: freeform
      objectives:
        - value: 0.995
          window: 30d
      destinationDatasource:
        uid: grafanacloud-prom
      labels:
        - key: custom
          value: value
      alerting:
        fastburn:
          annotations:
            - key: name
              value: Critical - SLO Burn Rate Alert
          labels:
            - key: type
              value: slo
        slowburn:
          annotations:
            - key: name
              value: Warning - SLO Burn Rate Alert
          labels:
            - key: type
              value: slo
variables:
  slos:
    fn::invoke:
      function: grafana:slo:getSlos
      arguments: {}

function getSlos(args: GetSlosArgs, opts?: InvokeOptions): Promise<GetSlosResult>
function getSlosOutput(args: GetSlosOutputArgs, opts?: InvokeOptions): Output<GetSlosResult>

def get_slos(slos: Optional[Sequence[GetSlosSlo]] = None,
             opts: Optional[InvokeOptions] = None) -> GetSlosResult
def get_slos_output(slos: pulumi.Input[Optional[Sequence[pulumi.Input[GetSlosSloArgs]]]] = None,
             opts: Optional[InvokeOptions] = None) -> Output[GetSlosResult]

func GetSlos(ctx *Context, args *GetSlosArgs, opts ...InvokeOption) (*GetSlosResult, error)
func GetSlosOutput(ctx *Context, args *GetSlosOutputArgs, opts ...InvokeOption) GetSlosResultOutput

public static class GetSlos 
{
    public static Task<GetSlosResult> InvokeAsync(GetSlosArgs args, InvokeOptions? opts = null)
    public static Output<GetSlosResult> Invoke(GetSlosInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetSlosResult> getSlos(GetSlosArgs args, InvokeOptions options)
public static Output<GetSlosResult> getSlos(GetSlosArgs args, InvokeOptions options)

fn::invoke:
  function: grafana:slo/getSlos:getSlos
  arguments:
    # arguments dictionary