grafana.alerting.AlertRuleV0Alpha1

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

const alertruleFolder = new grafana.oss.Folder("alertrule_folder", {title: "Alert Rule Folder"});
const example = new grafana.alerting.v0alpha1.AlertRule("example", {
    metadata: {
        uid: "example-alert-rule",
        folderUid: alertruleFolder.uid,
    },
    spec: {
        title: "Example Alert Rule",
        trigger: {
            interval: "1m",
        },
        paused: true,
        expressions: {
            A: JSON.stringify({
                model: {
                    datasource: {
                        type: "prometheus",
                        uid: "ds_uid",
                    },
                    editorMode: "code",
                    expr: "count(up{})",
                    instant: true,
                    intervalMs: 1000,
                    legendFormat: "__auto",
                    maxDataPoints: 43200,
                    range: false,
                    refId: "A",
                },
                datasource_uid: "ds_uid",
                relative_time_range: {
                    from: "600s",
                    to: "0s",
                },
                query_type: "",
                source: true,
            }),
            B: JSON.stringify({
                model: {
                    conditions: [{
                        evaluator: {
                            params: [1],
                            type: "gt",
                        },
                        operator: {
                            type: "and",
                        },
                        query: {
                            params: ["C"],
                        },
                        reducer: {
                            params: [],
                            type: "last",
                        },
                        type: "query",
                    }],
                    datasource: {
                        type: "__expr__",
                        uid: "__expr__",
                    },
                    expression: "A",
                    intervalMs: 1000,
                    maxDataPoints: 43200,
                    refId: "C",
                    type: "threshold",
                },
                datasource_uid: "__expr__",
                query_type: "",
                source: false,
            }),
        },
        "for": "5m",
        labels: {
            severity: "critical",
        },
        annotations: {
            runbook_url: "https://example.com",
        },
        noDataState: "KeepLast",
        execErrState: "KeepLast",
        missingSeriesEvalsToResolve: 5,
        notificationSettings: {
            simplifiedRouting: {
                contactPoint: "grafana-default-email",
            },
        },
        panelRef: {
            dashboard_uid: "dashboard123",
            panel_id: "5",
        },
    },
});

import pulumi
import json
import pulumiverse_grafana as grafana

alertrule_folder = grafana.oss.Folder("alertrule_folder", title="Alert Rule Folder")
example = grafana.alerting.v0alpha1.AlertRule("example",
    metadata={
        "uid": "example-alert-rule",
        "folder_uid": alertrule_folder.uid,
    },
    spec={
        "title": "Example Alert Rule",
        "trigger": {
            "interval": "1m",
        },
        "paused": True,
        "expressions": {
            "A": json.dumps({
                "model": {
                    "datasource": {
                        "type": "prometheus",
                        "uid": "ds_uid",
                    },
                    "editorMode": "code",
                    "expr": "count(up{})",
                    "instant": True,
                    "intervalMs": 1000,
                    "legendFormat": "__auto",
                    "maxDataPoints": 43200,
                    "range": False,
                    "refId": "A",
                },
                "datasource_uid": "ds_uid",
                "relative_time_range": {
                    "from": "600s",
                    "to": "0s",
                },
                "query_type": "",
                "source": True,
            }),
            "B": json.dumps({
                "model": {
                    "conditions": [{
                        "evaluator": {
                            "params": [1],
                            "type": "gt",
                        },
                        "operator": {
                            "type": "and",
                        },
                        "query": {
                            "params": ["C"],
                        },
                        "reducer": {
                            "params": [],
                            "type": "last",
                        },
                        "type": "query",
                    }],
                    "datasource": {
                        "type": "__expr__",
                        "uid": "__expr__",
                    },
                    "expression": "A",
                    "intervalMs": 1000,
                    "maxDataPoints": 43200,
                    "refId": "C",
                    "type": "threshold",
                },
                "datasource_uid": "__expr__",
                "query_type": "",
                "source": False,
            }),
        },
        "for_": "5m",
        "labels": {
            "severity": "critical",
        },
        "annotations": {
            "runbook_url": "https://example.com",
        },
        "no_data_state": "KeepLast",
        "exec_err_state": "KeepLast",
        "missing_series_evals_to_resolve": 5,
        "notification_settings": {
            "simplified_routing": {
                "contact_point": "grafana-default-email",
            },
        },
        "panel_ref": {
            "dashboard_uid": "dashboard123",
            "panel_id": "5",
        },
    })

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-grafana/sdk/v2/go/grafana/alerting"
	alertingv0alpha1 "github.com/pulumiverse/pulumi-grafana/sdk/v2/go/grafana/alerting/v0alpha1"
	"github.com/pulumiverse/pulumi-grafana/sdk/v2/go/grafana/oss"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		alertruleFolder, err := oss.NewFolder(ctx, "alertrule_folder", &oss.FolderArgs{
			Title: pulumi.String("Alert Rule Folder"),
		})
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"model": map[string]interface{}{
				"datasource": map[string]interface{}{
					"type": "prometheus",
					"uid":  "ds_uid",
				},
				"editorMode":    "code",
				"expr":          "count(up{})",
				"instant":       true,
				"intervalMs":    1000,
				"legendFormat":  "__auto",
				"maxDataPoints": 43200,
				"range":         false,
				"refId":         "A",
			},
			"datasource_uid": "ds_uid",
			"relative_time_range": map[string]interface{}{
				"from": "600s",
				"to":   "0s",
			},
			"query_type": "",
			"source":     true,
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"model": map[string]interface{}{
				"conditions": []map[string]interface{}{
					map[string]interface{}{
						"evaluator": map[string]interface{}{
							"params": []float64{
								1,
							},
							"type": "gt",
						},
						"operator": map[string]interface{}{
							"type": "and",
						},
						"query": map[string]interface{}{
							"params": []string{
								"C",
							},
						},
						"reducer": map[string]interface{}{
							"params": []interface{}{},
							"type":   "last",
						},
						"type": "query",
					},
				},
				"datasource": map[string]interface{}{
					"type": "__expr__",
					"uid":  "__expr__",
				},
				"expression":    "A",
				"intervalMs":    1000,
				"maxDataPoints": 43200,
				"refId":         "C",
				"type":          "threshold",
			},
			"datasource_uid": "__expr__",
			"query_type":     "",
			"source":         false,
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		_, err = alerting.NewAlertRule(ctx, "example", &alerting.AlertRuleArgs{
			Metadata: &alertingv0alpha1.AlertRuleMetadataArgs{
				Uid:       pulumi.String("example-alert-rule"),
				FolderUid: alertruleFolder.Uid,
			},
			Spec: &alertingv0alpha1.AlertRuleSpecArgs{
				Title: pulumi.String("Example Alert Rule"),
				Trigger: &alertingv0alpha1.AlertRuleSpecTriggerArgs{
					Interval: pulumi.String("1m"),
				},
				Paused: pulumi.Bool(true),
				Expressions: pulumi.StringMap{
					"A": pulumi.String(pulumi.String(json0)),
					"B": pulumi.String(pulumi.String(json1)),
				},
				For: pulumi.String("5m"),
				Labels: pulumi.StringMap{
					"severity": pulumi.String("critical"),
				},
				Annotations: pulumi.StringMap{
					"runbook_url": pulumi.String("https://example.com"),
				},
				NoDataState:                 pulumi.String("KeepLast"),
				ExecErrState:                pulumi.String("KeepLast"),
				MissingSeriesEvalsToResolve: pulumi.Int(5),
				NotificationSettings: &alertingv0alpha1.AlertRuleSpecNotificationSettingsArgs{
					SimplifiedRouting: &alertingv0alpha1.AlertRuleSpecNotificationSettingsSimplifiedRoutingArgs{
						ContactPoint: pulumi.String("grafana-default-email"),
					},
				},
				PanelRef: pulumi.StringMap{
					"dashboard_uid": pulumi.String("dashboard123"),
					"panel_id":      pulumi.String("5"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var alertruleFolder = new Grafana.Oss.Folder("alertrule_folder", new()
    {
        Title = "Alert Rule Folder",
    });

    var example = new Grafana.Alerting.V0Alpha1.AlertRule("example", new()
    {
        Metadata = new Grafana.Alerting.V0Alpha1.Inputs.AlertRuleMetadataArgs
        {
            Uid = "example-alert-rule",
            FolderUid = alertruleFolder.Uid,
        },
        Spec = new Grafana.Alerting.V0Alpha1.Inputs.AlertRuleSpecArgs
        {
            Title = "Example Alert Rule",
            Trigger = new Grafana.Alerting.V0Alpha1.Inputs.AlertRuleSpecTriggerArgs
            {
                Interval = "1m",
            },
            Paused = true,
            Expressions = 
            {
                { "A", JsonSerializer.Serialize(new Dictionary<string, object?>
                {
                    ["model"] = new Dictionary<string, object?>
                    {
                        ["datasource"] = new Dictionary<string, object?>
                        {
                            ["type"] = "prometheus",
                            ["uid"] = "ds_uid",
                        },
                        ["editorMode"] = "code",
                        ["expr"] = "count(up{})",
                        ["instant"] = true,
                        ["intervalMs"] = 1000,
                        ["legendFormat"] = "__auto",
                        ["maxDataPoints"] = 43200,
                        ["range"] = false,
                        ["refId"] = "A",
                    },
                    ["datasource_uid"] = "ds_uid",
                    ["relative_time_range"] = new Dictionary<string, object?>
                    {
                        ["from"] = "600s",
                        ["to"] = "0s",
                    },
                    ["query_type"] = "",
                    ["source"] = true,
                }) },
                { "B", JsonSerializer.Serialize(new Dictionary<string, object?>
                {
                    ["model"] = new Dictionary<string, object?>
                    {
                        ["conditions"] = new[]
                        {
                            new Dictionary<string, object?>
                            {
                                ["evaluator"] = new Dictionary<string, object?>
                                {
                                    ["params"] = new[]
                                    {
                                        1,
                                    },
                                    ["type"] = "gt",
                                },
                                ["operator"] = new Dictionary<string, object?>
                                {
                                    ["type"] = "and",
                                },
                                ["query"] = new Dictionary<string, object?>
                                {
                                    ["params"] = new[]
                                    {
                                        "C",
                                    },
                                },
                                ["reducer"] = new Dictionary<string, object?>
                                {
                                    ["params"] = new[]
                                    {
                                    },
                                    ["type"] = "last",
                                },
                                ["type"] = "query",
                            },
                        },
                        ["datasource"] = new Dictionary<string, object?>
                        {
                            ["type"] = "__expr__",
                            ["uid"] = "__expr__",
                        },
                        ["expression"] = "A",
                        ["intervalMs"] = 1000,
                        ["maxDataPoints"] = 43200,
                        ["refId"] = "C",
                        ["type"] = "threshold",
                    },
                    ["datasource_uid"] = "__expr__",
                    ["query_type"] = "",
                    ["source"] = false,
                }) },
            },
            For = "5m",
            Labels = 
            {
                { "severity", "critical" },
            },
            Annotations = 
            {
                { "runbook_url", "https://example.com" },
            },
            NoDataState = "KeepLast",
            ExecErrState = "KeepLast",
            MissingSeriesEvalsToResolve = 5,
            NotificationSettings = new Grafana.Alerting.V0Alpha1.Inputs.AlertRuleSpecNotificationSettingsArgs
            {
                SimplifiedRouting = new Grafana.Alerting.V0Alpha1.Inputs.AlertRuleSpecNotificationSettingsSimplifiedRoutingArgs
                {
                    ContactPoint = "grafana-default-email",
                },
            },
            PanelRef = 
            {
                { "dashboard_uid", "dashboard123" },
                { "panel_id", "5" },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.grafana.oss.Folder;
import com.pulumi.grafana.oss.FolderArgs;
import com.pulumi.grafana.alerting_v0alpha1.AlertRule;
import com.pulumi.grafana.alerting_v0alpha1.AlertRuleArgs;
import com.pulumi.grafana.alerting.inputs.AlertRuleMetadataArgs;
import com.pulumi.grafana.alerting.inputs.AlertRuleSpecArgs;
import com.pulumi.grafana.alerting.inputs.AlertRuleSpecTriggerArgs;
import com.pulumi.grafana.alerting.inputs.AlertRuleSpecNotificationSettingsArgs;
import com.pulumi.grafana.alerting.inputs.AlertRuleSpecNotificationSettingsSimplifiedRoutingArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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 alertruleFolder = new Folder("alertruleFolder", FolderArgs.builder()
            .title("Alert Rule Folder")
            .build());

        var example = new AlertRule("example", AlertRuleArgs.builder()
            .metadata(AlertRuleMetadataArgs.builder()
                .uid("example-alert-rule")
                .folderUid(alertruleFolder.uid())
                .build())
            .spec(AlertRuleSpecArgs.builder()
                .title("Example Alert Rule")
                .trigger(AlertRuleSpecTriggerArgs.builder()
                    .interval("1m")
                    .build())
                .paused(true)
                .expressions(Map.ofEntries(
                    Map.entry("A", serializeJson(
                        jsonObject(
                            jsonProperty("model", jsonObject(
                                jsonProperty("datasource", jsonObject(
                                    jsonProperty("type", "prometheus"),
                                    jsonProperty("uid", "ds_uid")
                                )),
                                jsonProperty("editorMode", "code"),
                                jsonProperty("expr", "count(up{})"),
                                jsonProperty("instant", true),
                                jsonProperty("intervalMs", 1000),
                                jsonProperty("legendFormat", "__auto"),
                                jsonProperty("maxDataPoints", 43200),
                                jsonProperty("range", false),
                                jsonProperty("refId", "A")
                            )),
                            jsonProperty("datasource_uid", "ds_uid"),
                            jsonProperty("relative_time_range", jsonObject(
                                jsonProperty("from", "600s"),
                                jsonProperty("to", "0s")
                            )),
                            jsonProperty("query_type", ""),
                            jsonProperty("source", true)
                        ))),
                    Map.entry("B", serializeJson(
                        jsonObject(
                            jsonProperty("model", jsonObject(
                                jsonProperty("conditions", jsonArray(jsonObject(
                                    jsonProperty("evaluator", jsonObject(
                                        jsonProperty("params", jsonArray(1)),
                                        jsonProperty("type", "gt")
                                    )),
                                    jsonProperty("operator", jsonObject(
                                        jsonProperty("type", "and")
                                    )),
                                    jsonProperty("query", jsonObject(
                                        jsonProperty("params", jsonArray("C"))
                                    )),
                                    jsonProperty("reducer", jsonObject(
                                        jsonProperty("params", jsonArray(
                                        )),
                                        jsonProperty("type", "last")
                                    )),
                                    jsonProperty("type", "query")
                                ))),
                                jsonProperty("datasource", jsonObject(
                                    jsonProperty("type", "__expr__"),
                                    jsonProperty("uid", "__expr__")
                                )),
                                jsonProperty("expression", "A"),
                                jsonProperty("intervalMs", 1000),
                                jsonProperty("maxDataPoints", 43200),
                                jsonProperty("refId", "C"),
                                jsonProperty("type", "threshold")
                            )),
                            jsonProperty("datasource_uid", "__expr__"),
                            jsonProperty("query_type", ""),
                            jsonProperty("source", false)
                        )))
                ))
                .for_("5m")
                .labels(Map.of("severity", "critical"))
                .annotations(Map.of("runbook_url", "https://example.com"))
                .noDataState("KeepLast")
                .execErrState("KeepLast")
                .missingSeriesEvalsToResolve(5)
                .notificationSettings(AlertRuleSpecNotificationSettingsArgs.builder()
                    .simplifiedRouting(AlertRuleSpecNotificationSettingsSimplifiedRoutingArgs.builder()
                        .contactPoint("grafana-default-email")
                        .build())
                    .build())
                .panelRef(Map.ofEntries(
                    Map.entry("dashboard_uid", "dashboard123"),
                    Map.entry("panel_id", "5")
                ))
                .build())
            .build());

    }
}

resources:
  alertruleFolder:
    type: grafana:oss:Folder
    name: alertrule_folder
    properties:
      title: Alert Rule Folder
  example:
    type: grafana:alerting/v0alpha1:AlertRule
    properties:
      metadata:
        uid: example-alert-rule
        folderUid: ${alertruleFolder.uid}
      spec:
        title: Example Alert Rule
        trigger:
          interval: 1m
        paused: true
        expressions:
          A:
            fn::toJSON:
              model:
                datasource:
                  type: prometheus
                  uid: ds_uid
                editorMode: code
                expr: count(up{})
                instant: true
                intervalMs: 1000
                legendFormat: __auto
                maxDataPoints: 43200
                range: false
                refId: A
              datasource_uid: ds_uid
              relative_time_range:
                from: 600s
                to: 0s
              query_type: ""
              source: true
          B:
            fn::toJSON:
              model:
                conditions:
                  - evaluator:
                      params:
                        - 1
                      type: gt
                    operator:
                      type: and
                    query:
                      params:
                        - C
                    reducer:
                      params: []
                      type: last
                    type: query
                datasource:
                  type: __expr__
                  uid: __expr__
                expression: A
                intervalMs: 1000
                maxDataPoints: 43200
                refId: C
                type: threshold
              datasource_uid: __expr__
              query_type: ""
              source: false
        for: 5m
        labels:
          severity: critical
        annotations:
          runbook_url: https://example.com
        noDataState: KeepLast
        execErrState: KeepLast
        missingSeriesEvalsToResolve: 5
        notificationSettings:
          simplifiedRouting:
            contactPoint: grafana-default-email
        panelRef:
          dashboard_uid: dashboard123
          panel_id: '5'