grafana.alerting/v0alpha1.RuleSequence

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

const rulesequenceFolder = new grafana.oss.Folder("rulesequence_folder", {title: "Rule Sequence Folder"});
const example = new grafana.alerting.v0alpha1.RecordingRule("example", {
    metadata: {
        uid: "example-seq-recording-rule",
        folderUid: rulesequenceFolder.uid,
    },
    spec: {
        title: "Example Sequence Recording Rule",
        trigger: {
            interval: "1m",
        },
        expressions: {
            A: JSON.stringify({
                model: {
                    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,
            }),
        },
        targetDatasourceUid: "target_ds_uid",
        metric: "tf-seq-metric",
    },
});
const exampleAlertRule = new grafana.alerting.v0alpha1.AlertRule("example", {
    metadata: {
        uid: "example-seq-alert-rule",
        folderUid: rulesequenceFolder.uid,
    },
    spec: {
        title: "Example Sequence Alert Rule",
        trigger: {
            interval: "1m",
        },
        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,
            }),
        },
        noDataState: "KeepLast",
        execErrState: "KeepLast",
    },
});
const exampleRuleSequence = new grafana.alerting.v0alpha1.RuleSequence("example", {
    metadata: {
        uid: "example-rule-sequence",
        folderUid: rulesequenceFolder.uid,
    },
    spec: {
        trigger: {
            interval: "1m",
        },
        recordingRules: [{
            name: example.metadata.apply(metadata => metadata?.[0]?.uid),
        }],
        alertingRules: [{
            name: exampleAlertRule.metadata.apply(metadata => metadata?.[0]?.uid),
        }],
    },
});

import pulumi
import json
import pulumiverse_grafana as grafana

rulesequence_folder = grafana.oss.Folder("rulesequence_folder", title="Rule Sequence Folder")
example = grafana.alerting.v0alpha1.RecordingRule("example",
    metadata={
        "uid": "example-seq-recording-rule",
        "folder_uid": rulesequence_folder.uid,
    },
    spec={
        "title": "Example Sequence Recording Rule",
        "trigger": {
            "interval": "1m",
        },
        "expressions": {
            "A": json.dumps({
                "model": {
                    "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,
            }),
        },
        "target_datasource_uid": "target_ds_uid",
        "metric": "tf-seq-metric",
    })
example_alert_rule = grafana.alerting.v0alpha1.AlertRule("example",
    metadata={
        "uid": "example-seq-alert-rule",
        "folder_uid": rulesequence_folder.uid,
    },
    spec={
        "title": "Example Sequence Alert Rule",
        "trigger": {
            "interval": "1m",
        },
        "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,
            }),
        },
        "no_data_state": "KeepLast",
        "exec_err_state": "KeepLast",
    })
example_rule_sequence = grafana.alerting.v0alpha1.RuleSequence("example",
    metadata={
        "uid": "example-rule-sequence",
        "folder_uid": rulesequence_folder.uid,
    },
    spec={
        "trigger": {
            "interval": "1m",
        },
        "recording_rules": [{
            "name": example.metadata[0]["uid"],
        }],
        "alerting_rules": [{
            "name": example_alert_rule.metadata[0]["uid"],
        }],
    })

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 {
rulesequenceFolder, err := oss.NewFolder(ctx, "rulesequence_folder", &oss.FolderArgs{
Title: pulumi.String("Rule Sequence Folder"),
})
if err != nil {
return err
}
tmpJSON0, err := json.Marshal(map[string]interface{}{
"model": map[string]interface{}{
"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)
example, err := alerting.NewRecordingRule(ctx, "example", &alerting.RecordingRuleArgs{
Metadata: &alertingv0alpha1.RecordingRuleMetadataArgs{
Uid: pulumi.String("example-seq-recording-rule"),
FolderUid: rulesequenceFolder.Uid,
},
Spec: &alertingv0alpha1.RecordingRuleSpecArgs{
Title: pulumi.String("Example Sequence Recording Rule"),
Trigger: &alertingv0alpha1.RecordingRuleSpecTriggerArgs{
Interval: pulumi.String("1m"),
},
Expressions: pulumi.StringMap{
"A": pulumi.String(pulumi.String(json0)),
},
TargetDatasourceUid: pulumi.String("target_ds_uid"),
Metric: pulumi.String("tf-seq-metric"),
},
})
if err != nil {
return err
}
tmpJSON1, 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
}
json1 := string(tmpJSON1)
exampleAlertRule, err := alerting.NewAlertRule(ctx, "example", &alerting.AlertRuleArgs{
Metadata: &alertingv0alpha1.AlertRuleMetadataArgs{
Uid: pulumi.String("example-seq-alert-rule"),
FolderUid: rulesequenceFolder.Uid,
},
Spec: &alertingv0alpha1.AlertRuleSpecArgs{
Title: pulumi.String("Example Sequence Alert Rule"),
Trigger: &alertingv0alpha1.AlertRuleSpecTriggerArgs{
Interval: pulumi.String("1m"),
},
Expressions: pulumi.StringMap{
"A": pulumi.String(pulumi.String(json1)),
},
NoDataState: pulumi.String("KeepLast"),
ExecErrState: pulumi.String("KeepLast"),
},
})
if err != nil {
return err
}
_, err = alerting.NewRuleSequence(ctx, "example", &alerting.RuleSequenceArgs{
Metadata: &alertingv0alpha1.RuleSequenceMetadataArgs{
Uid: pulumi.String("example-rule-sequence"),
FolderUid: rulesequenceFolder.Uid,
},
Spec: &alertingv0alpha1.RuleSequenceSpecArgs{
Trigger: &alertingv0alpha1.RuleSequenceSpecTriggerArgs{
Interval: pulumi.String("1m"),
},
RecordingRules: alertingv0alpha1.RuleSequenceSpecRecordingRuleArray{
&alertingv0alpha1.RuleSequenceSpecRecordingRuleArgs{
Name: pulumi.String(example.Metadata.ApplyT(func(metadata alertingv0alpha1.RecordingRuleMetadata) (*interface{}, error) {
return &metadata[0].Uid, nil
}).(pulumi.Interface{}PtrOutput)),
},
},
AlertingRules: alertingv0alpha1.RuleSequenceSpecAlertingRuleArray{
&alertingv0alpha1.RuleSequenceSpecAlertingRuleArgs{
Name: pulumi.String(exampleAlertRule.Metadata.ApplyT(func(metadata alertingv0alpha1.AlertRuleMetadata) (*interface{}, error) {
return &metadata[0].Uid, nil
}).(pulumi.Interface{}PtrOutput)),
},
},
},
})
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 rulesequenceFolder = new Grafana.Oss.Folder("rulesequence_folder", new()
    {
        Title = "Rule Sequence Folder",
    });

    var example = new Grafana.Alerting.V0Alpha1.RecordingRule("example", new()
    {
        Metadata = new Grafana.Alerting.V0Alpha1.Inputs.RecordingRuleMetadataArgs
        {
            Uid = "example-seq-recording-rule",
            FolderUid = rulesequenceFolder.Uid,
        },
        Spec = new Grafana.Alerting.V0Alpha1.Inputs.RecordingRuleSpecArgs
        {
            Title = "Example Sequence Recording Rule",
            Trigger = new Grafana.Alerting.V0Alpha1.Inputs.RecordingRuleSpecTriggerArgs
            {
                Interval = "1m",
            },
            Expressions = 
            {
                { "A", JsonSerializer.Serialize(new Dictionary<string, object?>
                {
                    ["model"] = new Dictionary<string, object?>
                    {
                        ["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,
                }) },
            },
            TargetDatasourceUid = "target_ds_uid",
            Metric = "tf-seq-metric",
        },
    });

    var exampleAlertRule = new Grafana.Alerting.V0Alpha1.AlertRule("example", new()
    {
        Metadata = new Grafana.Alerting.V0Alpha1.Inputs.AlertRuleMetadataArgs
        {
            Uid = "example-seq-alert-rule",
            FolderUid = rulesequenceFolder.Uid,
        },
        Spec = new Grafana.Alerting.V0Alpha1.Inputs.AlertRuleSpecArgs
        {
            Title = "Example Sequence Alert Rule",
            Trigger = new Grafana.Alerting.V0Alpha1.Inputs.AlertRuleSpecTriggerArgs
            {
                Interval = "1m",
            },
            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,
                }) },
            },
            NoDataState = "KeepLast",
            ExecErrState = "KeepLast",
        },
    });

    var exampleRuleSequence = new Grafana.Alerting.V0Alpha1.RuleSequence("example", new()
    {
        Metadata = new Grafana.Alerting.V0Alpha1.Inputs.RuleSequenceMetadataArgs
        {
            Uid = "example-rule-sequence",
            FolderUid = rulesequenceFolder.Uid,
        },
        Spec = new Grafana.Alerting.V0Alpha1.Inputs.RuleSequenceSpecArgs
        {
            Trigger = new Grafana.Alerting.V0Alpha1.Inputs.RuleSequenceSpecTriggerArgs
            {
                Interval = "1m",
            },
            RecordingRules = new[]
            {
                new Grafana.Alerting.V0Alpha1.Inputs.RuleSequenceSpecRecordingRuleArgs
                {
                    Name = example.Metadata.Apply(metadata => metadata[0]?.Uid),
                },
            },
            AlertingRules = new[]
            {
                new Grafana.Alerting.V0Alpha1.Inputs.RuleSequenceSpecAlertingRuleArgs
                {
                    Name = exampleAlertRule.Metadata.Apply(metadata => metadata[0]?.Uid),
                },
            },
        },
    });

});

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.RecordingRule;
import com.pulumi.grafana.alerting_v0alpha1.RecordingRuleArgs;
import com.pulumi.grafana.alerting.inputs.RecordingRuleMetadataArgs;
import com.pulumi.grafana.alerting.inputs.RecordingRuleSpecArgs;
import com.pulumi.grafana.alerting.inputs.RecordingRuleSpecTriggerArgs;
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_v0alpha1.RuleSequence;
import com.pulumi.grafana.alerting_v0alpha1.RuleSequenceArgs;
import com.pulumi.grafana.alerting.inputs.RuleSequenceMetadataArgs;
import com.pulumi.grafana.alerting.inputs.RuleSequenceSpecArgs;
import com.pulumi.grafana.alerting.inputs.RuleSequenceSpecTriggerArgs;
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 rulesequenceFolder = new Folder("rulesequenceFolder", FolderArgs.builder()
            .title("Rule Sequence Folder")
            .build());

        var example = new RecordingRule("example", RecordingRuleArgs.builder()
            .metadata(RecordingRuleMetadataArgs.builder()
                .uid("example-seq-recording-rule")
                .folderUid(rulesequenceFolder.uid())
                .build())
            .spec(RecordingRuleSpecArgs.builder()
                .title("Example Sequence Recording Rule")
                .trigger(RecordingRuleSpecTriggerArgs.builder()
                    .interval("1m")
                    .build())
                .expressions(Map.of("A", serializeJson(
                    jsonObject(
                        jsonProperty("model", jsonObject(
                            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)
                    ))))
                .targetDatasourceUid("target_ds_uid")
                .metric("tf-seq-metric")
                .build())
            .build());

        var exampleAlertRule = new AlertRule("exampleAlertRule", AlertRuleArgs.builder()
            .metadata(AlertRuleMetadataArgs.builder()
                .uid("example-seq-alert-rule")
                .folderUid(rulesequenceFolder.uid())
                .build())
            .spec(AlertRuleSpecArgs.builder()
                .title("Example Sequence Alert Rule")
                .trigger(AlertRuleSpecTriggerArgs.builder()
                    .interval("1m")
                    .build())
                .expressions(Map.of("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)
                    ))))
                .noDataState("KeepLast")
                .execErrState("KeepLast")
                .build())
            .build());

        var exampleRuleSequence = new RuleSequence("exampleRuleSequence", RuleSequenceArgs.builder()
            .metadata(RuleSequenceMetadataArgs.builder()
                .uid("example-rule-sequence")
                .folderUid(rulesequenceFolder.uid())
                .build())
            .spec(RuleSequenceSpecArgs.builder()
                .trigger(RuleSequenceSpecTriggerArgs.builder()
                    .interval("1m")
                    .build())
                .recordingRules(RuleSequenceSpecRecordingRuleArgs.builder()
                    .name(example.metadata().applyValue(_metadata -> _metadata[0].uid()))
                    .build())
                .alertingRules(RuleSequenceSpecAlertingRuleArgs.builder()
                    .name(exampleAlertRule.metadata().applyValue(_metadata -> _metadata[0].uid()))
                    .build())
                .build())
            .build());

    }
}

resources:
  rulesequenceFolder:
    type: grafana:oss:Folder
    name: rulesequence_folder
    properties:
      title: Rule Sequence Folder
  example:
    type: grafana:alerting/v0alpha1:RecordingRule
    properties:
      metadata:
        uid: example-seq-recording-rule
        folderUid: ${rulesequenceFolder.uid}
      spec:
        title: Example Sequence Recording Rule
        trigger:
          interval: 1m
        expressions:
          A:
            fn::toJSON:
              model:
                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
        targetDatasourceUid: target_ds_uid
        metric: tf-seq-metric
  exampleAlertRule:
    type: grafana:alerting/v0alpha1:AlertRule
    name: example
    properties:
      metadata:
        uid: example-seq-alert-rule
        folderUid: ${rulesequenceFolder.uid}
      spec:
        title: Example Sequence Alert Rule
        trigger:
          interval: 1m
        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
        noDataState: KeepLast
        execErrState: KeepLast
  exampleRuleSequence:
    type: grafana:alerting/v0alpha1:RuleSequence
    name: example
    properties:
      metadata:
        uid: example-rule-sequence
        folderUid: ${rulesequenceFolder.uid}
      spec:
        trigger:
          interval: 1m
        recordingRules:
          - name: ${example.metadata[0].uid}
        alertingRules:
          - name: ${exampleAlertRule.metadata[0].uid}