Grafana v0.0.10, May 21 23

grafana.NotificationPolicy

Explore with Pulumi AI

Sets the global notification policy for Grafana.

!> This resource manages the entire notification policy tree, and will overwrite any existing policies.

This resource requires Grafana 9.1.0 or later.

Example Usage

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Grafana = Lbrlabs.PulumiPackage.Grafana;

return await Deployment.RunAsync(() => 
{
    var aContactPoint = new Grafana.ContactPoint("aContactPoint", new()
    {
        Emails = new[]
        {
            new Grafana.Inputs.ContactPointEmailArgs
            {
                Addresses = new[]
                {
                    "one@company.org",
                    "two@company.org",
                },
                Message = "{{ len .Alerts.Firing }} firing.",
            },
        },
    });

    var aMuteTiming = new Grafana.MuteTiming("aMuteTiming", new()
    {
        Intervals = new[]
        {
            new Grafana.Inputs.MuteTimingIntervalArgs
            {
                Weekdays = new[]
                {
                    "monday",
                },
            },
        },
    });

    var myNotificationPolicy = new Grafana.NotificationPolicy("myNotificationPolicy", new()
    {
        GroupBies = new[]
        {
            "...",
        },
        ContactPoint = aContactPoint.Name,
        GroupWait = "45s",
        GroupInterval = "6m",
        RepeatInterval = "3h",
        Policies = new[]
        {
            new Grafana.Inputs.NotificationPolicyPolicyArgs
            {
                Matchers = new[]
                {
                    new Grafana.Inputs.NotificationPolicyPolicyMatcherArgs
                    {
                        Label = "mylabel",
                        Match = "=",
                        Value = "myvalue",
                    },
                },
                ContactPoint = aContactPoint.Name,
                GroupBies = new[]
                {
                    "alertname",
                },
                Continue = true,
                MuteTimings = new[]
                {
                    aMuteTiming.Name,
                },
                GroupWait = "45s",
                GroupInterval = "6m",
                RepeatInterval = "3h",
                Policies = new[]
                {
                    new Grafana.Inputs.NotificationPolicyPolicyPolicyArgs
                    {
                        Matchers = new[]
                        {
                            new Grafana.Inputs.NotificationPolicyPolicyPolicyMatcherArgs
                            {
                                Label = "sublabel",
                                Match = "=",
                                Value = "subvalue",
                            },
                        },
                        ContactPoint = aContactPoint.Name,
                        GroupBies = new[]
                        {
                            "...",
                        },
                    },
                },
            },
            new Grafana.Inputs.NotificationPolicyPolicyArgs
            {
                Matchers = new[]
                {
                    new Grafana.Inputs.NotificationPolicyPolicyMatcherArgs
                    {
                        Label = "anotherlabel",
                        Match = "=~",
                        Value = "another value.*",
                    },
                },
                ContactPoint = aContactPoint.Name,
                GroupBies = new[]
                {
                    "...",
                },
            },
        },
    });

});

package main

import (
	"github.com/lbrlabs/pulumi-grafana/sdk/go/grafana"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		aContactPoint, err := grafana.NewContactPoint(ctx, "aContactPoint", &grafana.ContactPointArgs{
			Emails: grafana.ContactPointEmailArray{
				&grafana.ContactPointEmailArgs{
					Addresses: pulumi.StringArray{
						pulumi.String("one@company.org"),
						pulumi.String("two@company.org"),
					},
					Message: pulumi.String("{{ len .Alerts.Firing }} firing."),
				},
			},
		})
		if err != nil {
			return err
		}
		aMuteTiming, err := grafana.NewMuteTiming(ctx, "aMuteTiming", &grafana.MuteTimingArgs{
			Intervals: grafana.MuteTimingIntervalArray{
				&grafana.MuteTimingIntervalArgs{
					Weekdays: pulumi.StringArray{
						pulumi.String("monday"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = grafana.NewNotificationPolicy(ctx, "myNotificationPolicy", &grafana.NotificationPolicyArgs{
			GroupBies: pulumi.StringArray{
				pulumi.String("..."),
			},
			ContactPoint:   aContactPoint.Name,
			GroupWait:      pulumi.String("45s"),
			GroupInterval:  pulumi.String("6m"),
			RepeatInterval: pulumi.String("3h"),
			Policies: grafana.NotificationPolicyPolicyArray{
				&grafana.NotificationPolicyPolicyArgs{
					Matchers: grafana.NotificationPolicyPolicyMatcherArray{
						&grafana.NotificationPolicyPolicyMatcherArgs{
							Label: pulumi.String("mylabel"),
							Match: pulumi.String("="),
							Value: pulumi.String("myvalue"),
						},
					},
					ContactPoint: aContactPoint.Name,
					GroupBies: pulumi.StringArray{
						pulumi.String("alertname"),
					},
					Continue: pulumi.Bool(true),
					MuteTimings: pulumi.StringArray{
						aMuteTiming.Name,
					},
					GroupWait:      pulumi.String("45s"),
					GroupInterval:  pulumi.String("6m"),
					RepeatInterval: pulumi.String("3h"),
					Policies: grafana.NotificationPolicyPolicyPolicyArray{
						&grafana.NotificationPolicyPolicyPolicyArgs{
							Matchers: grafana.NotificationPolicyPolicyPolicyMatcherArray{
								&grafana.NotificationPolicyPolicyPolicyMatcherArgs{
									Label: pulumi.String("sublabel"),
									Match: pulumi.String("="),
									Value: pulumi.String("subvalue"),
								},
							},
							ContactPoint: aContactPoint.Name,
							GroupBies: pulumi.StringArray{
								pulumi.String("..."),
							},
						},
					},
				},
				&grafana.NotificationPolicyPolicyArgs{
					Matchers: grafana.NotificationPolicyPolicyMatcherArray{
						&grafana.NotificationPolicyPolicyMatcherArgs{
							Label: pulumi.String("anotherlabel"),
							Match: pulumi.String("=~"),
							Value: pulumi.String("another value.*"),
						},
					},
					ContactPoint: aContactPoint.Name,
					GroupBies: pulumi.StringArray{
						pulumi.String("..."),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.grafana.ContactPoint;
import com.pulumi.grafana.ContactPointArgs;
import com.pulumi.grafana.inputs.ContactPointEmailArgs;
import com.pulumi.grafana.MuteTiming;
import com.pulumi.grafana.MuteTimingArgs;
import com.pulumi.grafana.inputs.MuteTimingIntervalArgs;
import com.pulumi.grafana.NotificationPolicy;
import com.pulumi.grafana.NotificationPolicyArgs;
import com.pulumi.grafana.inputs.NotificationPolicyPolicyArgs;
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 aContactPoint = new ContactPoint("aContactPoint", ContactPointArgs.builder()        
            .emails(ContactPointEmailArgs.builder()
                .addresses(                
                    "one@company.org",
                    "two@company.org")
                .message("{{ len .Alerts.Firing }} firing.")
                .build())
            .build());

        var aMuteTiming = new MuteTiming("aMuteTiming", MuteTimingArgs.builder()        
            .intervals(MuteTimingIntervalArgs.builder()
                .weekdays("monday")
                .build())
            .build());

        var myNotificationPolicy = new NotificationPolicy("myNotificationPolicy", NotificationPolicyArgs.builder()        
            .groupBies("...")
            .contactPoint(aContactPoint.name())
            .groupWait("45s")
            .groupInterval("6m")
            .repeatInterval("3h")
            .policies(            
                NotificationPolicyPolicyArgs.builder()
                    .matchers(NotificationPolicyPolicyMatcherArgs.builder()
                        .label("mylabel")
                        .match("=")
                        .value("myvalue")
                        .build())
                    .contactPoint(aContactPoint.name())
                    .groupBies("alertname")
                    .continue_(true)
                    .muteTimings(aMuteTiming.name())
                    .groupWait("45s")
                    .groupInterval("6m")
                    .repeatInterval("3h")
                    .policies(NotificationPolicyPolicyPolicyArgs.builder()
                        .matchers(NotificationPolicyPolicyPolicyMatcherArgs.builder()
                            .label("sublabel")
                            .match("=")
                            .value("subvalue")
                            .build())
                        .contactPoint(aContactPoint.name())
                        .groupBies("...")
                        .build())
                    .build(),
                NotificationPolicyPolicyArgs.builder()
                    .matchers(NotificationPolicyPolicyMatcherArgs.builder()
                        .label("anotherlabel")
                        .match("=~")
                        .value("another value.*")
                        .build())
                    .contactPoint(aContactPoint.name())
                    .groupBies("...")
                    .build())
            .build());

    }
}

import pulumi
import lbrlabs_pulumi_grafana as grafana

a_contact_point = grafana.ContactPoint("aContactPoint", emails=[grafana.ContactPointEmailArgs(
    addresses=[
        "one@company.org",
        "two@company.org",
    ],
    message="{{ len .Alerts.Firing }} firing.",
)])
a_mute_timing = grafana.MuteTiming("aMuteTiming", intervals=[grafana.MuteTimingIntervalArgs(
    weekdays=["monday"],
)])
my_notification_policy = grafana.NotificationPolicy("myNotificationPolicy",
    group_bies=["..."],
    contact_point=a_contact_point.name,
    group_wait="45s",
    group_interval="6m",
    repeat_interval="3h",
    policies=[
        grafana.NotificationPolicyPolicyArgs(
            matchers=[grafana.NotificationPolicyPolicyMatcherArgs(
                label="mylabel",
                match="=",
                value="myvalue",
            )],
            contact_point=a_contact_point.name,
            group_bies=["alertname"],
            continue_=True,
            mute_timings=[a_mute_timing.name],
            group_wait="45s",
            group_interval="6m",
            repeat_interval="3h",
            policies=[grafana.NotificationPolicyPolicyPolicyArgs(
                matchers=[grafana.NotificationPolicyPolicyPolicyMatcherArgs(
                    label="sublabel",
                    match="=",
                    value="subvalue",
                )],
                contact_point=a_contact_point.name,
                group_bies=["..."],
            )],
        ),
        grafana.NotificationPolicyPolicyArgs(
            matchers=[grafana.NotificationPolicyPolicyMatcherArgs(
                label="anotherlabel",
                match="=~",
                value="another value.*",
            )],
            contact_point=a_contact_point.name,
            group_bies=["..."],
        ),
    ])

import * as pulumi from "@pulumi/pulumi";
import * as grafana from "@lbrlabs/pulumi-grafana";

const aContactPoint = new grafana.ContactPoint("aContactPoint", {emails: [{
    addresses: [
        "one@company.org",
        "two@company.org",
    ],
    message: "{{ len .Alerts.Firing }} firing.",
}]});
const aMuteTiming = new grafana.MuteTiming("aMuteTiming", {intervals: [{
    weekdays: ["monday"],
}]});
const myNotificationPolicy = new grafana.NotificationPolicy("myNotificationPolicy", {
    groupBies: ["..."],
    contactPoint: aContactPoint.name,
    groupWait: "45s",
    groupInterval: "6m",
    repeatInterval: "3h",
    policies: [
        {
            matchers: [{
                label: "mylabel",
                match: "=",
                value: "myvalue",
            }],
            contactPoint: aContactPoint.name,
            groupBies: ["alertname"],
            "continue": true,
            muteTimings: [aMuteTiming.name],
            groupWait: "45s",
            groupInterval: "6m",
            repeatInterval: "3h",
            policies: [{
                matchers: [{
                    label: "sublabel",
                    match: "=",
                    value: "subvalue",
                }],
                contactPoint: aContactPoint.name,
                groupBies: ["..."],
            }],
        },
        {
            matchers: [{
                label: "anotherlabel",
                match: "=~",
                value: "another value.*",
            }],
            contactPoint: aContactPoint.name,
            groupBies: ["..."],
        },
    ],
});

resources:
  aContactPoint:
    type: grafana:ContactPoint
    properties:
      emails:
        - addresses:
            - one@company.org
            - two@company.org
          message: '{{ len .Alerts.Firing }} firing.'
  aMuteTiming:
    type: grafana:MuteTiming
    properties:
      intervals:
        - weekdays:
            - monday
  myNotificationPolicy:
    type: grafana:NotificationPolicy
    properties:
      groupBies:
        - '...'
      contactPoint: ${aContactPoint.name}
      groupWait: 45s
      groupInterval: 6m
      repeatInterval: 3h
      policies:
        - matchers:
            - label: mylabel
              match: =
              value: myvalue
          contactPoint: ${aContactPoint.name}
          groupBies:
            - alertname
          continue: true
          muteTimings:
            - ${aMuteTiming.name}
          groupWait: 45s
          groupInterval: 6m
          repeatInterval: 3h
          policies:
            - matchers:
                - label: sublabel
                  match: =
                  value: subvalue
              contactPoint: ${aContactPoint.name}
              groupBies:
                - '...'
        - matchers:
            - label: anotherlabel
              match: =~
              value: another value.*
          contactPoint: ${aContactPoint.name}
          groupBies:
            - '...'

Create NotificationPolicy Resource

new NotificationPolicy(name: string, args: NotificationPolicyArgs, opts?: CustomResourceOptions);

@overload
def NotificationPolicy(resource_name: str,
                       opts: Optional[ResourceOptions] = None,
                       contact_point: Optional[str] = None,
                       group_bies: Optional[Sequence[str]] = None,
                       group_interval: Optional[str] = None,
                       group_wait: Optional[str] = None,
                       policies: Optional[Sequence[NotificationPolicyPolicyArgs]] = None,
                       repeat_interval: Optional[str] = None)
@overload
def NotificationPolicy(resource_name: str,
                       args: NotificationPolicyArgs,
                       opts: Optional[ResourceOptions] = None)

func NewNotificationPolicy(ctx *Context, name string, args NotificationPolicyArgs, opts ...ResourceOption) (*NotificationPolicy, error)

public NotificationPolicy(string name, NotificationPolicyArgs args, CustomResourceOptions? opts = null)

public NotificationPolicy(String name, NotificationPolicyArgs args)
public NotificationPolicy(String name, NotificationPolicyArgs args, CustomResourceOptions options)

type: grafana:NotificationPolicy
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

name string: The unique name of the resource.
args NotificationPolicyArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

resource_name str: The unique name of the resource.
args NotificationPolicyArgs: The arguments to resource properties.
opts ResourceOptions: Bag of options to control resource's behavior.

ctx Context: Context object for the current deployment.
name string: The unique name of the resource.
args NotificationPolicyArgs: The arguments to resource properties.
opts ResourceOption: Bag of options to control resource's behavior.

name string: The unique name of the resource.
args NotificationPolicyArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

name String: The unique name of the resource.
args NotificationPolicyArgs: The arguments to resource properties.
options CustomResourceOptions: Bag of options to control resource's behavior.

NotificationPolicy Resource Properties

To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

Inputs

The NotificationPolicy resource accepts the following input properties:

ContactPoint string: The default contact point to route all unmatched notifications to.
GroupBies List<string>: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
GroupInterval string: Minimum time interval between two notifications for the same group. Default is 5 minutes.
GroupWait string: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
Policies List<Lbrlabs.PulumiPackage.Grafana.Inputs.NotificationPolicyPolicyArgs>: Routing rules for specific label sets.
RepeatInterval string: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

ContactPoint string: The default contact point to route all unmatched notifications to.
GroupBies []string: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
GroupInterval string: Minimum time interval between two notifications for the same group. Default is 5 minutes.
GroupWait string: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
Policies []NotificationPolicyPolicyArgs: Routing rules for specific label sets.
RepeatInterval string: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contactPoint String: The default contact point to route all unmatched notifications to.
groupBies List<String>: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
groupInterval String: Minimum time interval between two notifications for the same group. Default is 5 minutes.
groupWait String: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
policies List<NotificationPolicyPolicyArgs>: Routing rules for specific label sets.
repeatInterval String: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contactPoint string: The default contact point to route all unmatched notifications to.
groupBies string[]: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
groupInterval string: Minimum time interval between two notifications for the same group. Default is 5 minutes.
groupWait string: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
policies NotificationPolicyPolicyArgs[]: Routing rules for specific label sets.
repeatInterval string: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contact_point str: The default contact point to route all unmatched notifications to.
group_bies Sequence[str]: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
group_interval str: Minimum time interval between two notifications for the same group. Default is 5 minutes.
group_wait str: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
policies Sequence[NotificationPolicyPolicyArgs]: Routing rules for specific label sets.
repeat_interval str: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contactPoint String: The default contact point to route all unmatched notifications to.
groupBies List<String>: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
groupInterval String: Minimum time interval between two notifications for the same group. Default is 5 minutes.
groupWait String: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
policies List<Property Map>: Routing rules for specific label sets.
repeatInterval String: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

Outputs

All input properties are implicitly available as output properties. Additionally, the NotificationPolicy resource produces the following output properties:

Id string: The provider-assigned unique ID for this managed resource.

Id string: The provider-assigned unique ID for this managed resource.

id String: The provider-assigned unique ID for this managed resource.

id string: The provider-assigned unique ID for this managed resource.

id str: The provider-assigned unique ID for this managed resource.

id String: The provider-assigned unique ID for this managed resource.

Look up Existing NotificationPolicy Resource

Get an existing NotificationPolicy resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

public static get(name: string, id: Input<ID>, state?: NotificationPolicyState, opts?: CustomResourceOptions): NotificationPolicy

@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        contact_point: Optional[str] = None,
        group_bies: Optional[Sequence[str]] = None,
        group_interval: Optional[str] = None,
        group_wait: Optional[str] = None,
        policies: Optional[Sequence[NotificationPolicyPolicyArgs]] = None,
        repeat_interval: Optional[str] = None) -> NotificationPolicy

func GetNotificationPolicy(ctx *Context, name string, id IDInput, state *NotificationPolicyState, opts ...ResourceOption) (*NotificationPolicy, error)

public static NotificationPolicy Get(string name, Input<string> id, NotificationPolicyState? state, CustomResourceOptions? opts = null)

public static NotificationPolicy get(String name, Output<String> id, NotificationPolicyState state, CustomResourceOptions options)

Resource lookup is not supported in YAML

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

resource_name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

The following state arguments are supported:

ContactPoint string: The default contact point to route all unmatched notifications to.
GroupBies List<string>: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
GroupInterval string: Minimum time interval between two notifications for the same group. Default is 5 minutes.
GroupWait string: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
Policies List<Lbrlabs.PulumiPackage.Grafana.Inputs.NotificationPolicyPolicyArgs>: Routing rules for specific label sets.
RepeatInterval string: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

ContactPoint string: The default contact point to route all unmatched notifications to.
GroupBies []string: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
GroupInterval string: Minimum time interval between two notifications for the same group. Default is 5 minutes.
GroupWait string: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
Policies []NotificationPolicyPolicyArgs: Routing rules for specific label sets.
RepeatInterval string: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contactPoint String: The default contact point to route all unmatched notifications to.
groupBies List<String>: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
groupInterval String: Minimum time interval between two notifications for the same group. Default is 5 minutes.
groupWait String: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
policies List<NotificationPolicyPolicyArgs>: Routing rules for specific label sets.
repeatInterval String: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contactPoint string: The default contact point to route all unmatched notifications to.
groupBies string[]: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
groupInterval string: Minimum time interval between two notifications for the same group. Default is 5 minutes.
groupWait string: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
policies NotificationPolicyPolicyArgs[]: Routing rules for specific label sets.
repeatInterval string: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contact_point str: The default contact point to route all unmatched notifications to.
group_bies Sequence[str]: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
group_interval str: Minimum time interval between two notifications for the same group. Default is 5 minutes.
group_wait str: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
policies Sequence[NotificationPolicyPolicyArgs]: Routing rules for specific label sets.
repeat_interval str: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contactPoint String: The default contact point to route all unmatched notifications to.
groupBies List<String>: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
groupInterval String: Minimum time interval between two notifications for the same group. Default is 5 minutes.
groupWait String: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
policies List<Property Map>: Routing rules for specific label sets.
repeatInterval String: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

Supporting Types

NotificationPolicyPolicy

ContactPoint string: The contact point to route notifications that match this rule to.
GroupBies List<string>: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
Continue bool: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
GroupInterval string: Minimum time interval between two notifications for the same group. Default is 5 minutes.
GroupWait string: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
Matchers List<Lbrlabs.PulumiPackage.Grafana.Inputs.NotificationPolicyPolicyMatcher>: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
MuteTimings List<string>: A list of mute timing names to apply to alerts that match this policy.
Policies List<Lbrlabs.PulumiPackage.Grafana.Inputs.NotificationPolicyPolicyPolicy>: Routing rules for specific label sets.
RepeatInterval string: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

ContactPoint string: The contact point to route notifications that match this rule to.
GroupBies []string: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
Continue bool: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
GroupInterval string: Minimum time interval between two notifications for the same group. Default is 5 minutes.
GroupWait string: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
Matchers []NotificationPolicyPolicyMatcher: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
MuteTimings []string: A list of mute timing names to apply to alerts that match this policy.
Policies []NotificationPolicyPolicyPolicy: Routing rules for specific label sets.
RepeatInterval string: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contactPoint String: The contact point to route notifications that match this rule to.
groupBies List<String>: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
continue_ Boolean: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
groupInterval String: Minimum time interval between two notifications for the same group. Default is 5 minutes.
groupWait String: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
matchers List<NotificationPolicyPolicyMatcher>: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
muteTimings List<String>: A list of mute timing names to apply to alerts that match this policy.
policies List<NotificationPolicyPolicyPolicy>: Routing rules for specific label sets.
repeatInterval String: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contactPoint string: The contact point to route notifications that match this rule to.
groupBies string[]: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
continue boolean: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
groupInterval string: Minimum time interval between two notifications for the same group. Default is 5 minutes.
groupWait string: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
matchers NotificationPolicyPolicyMatcher[]: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
muteTimings string[]: A list of mute timing names to apply to alerts that match this policy.
policies NotificationPolicyPolicyPolicy[]: Routing rules for specific label sets.
repeatInterval string: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contact_point str: The contact point to route notifications that match this rule to.
group_bies Sequence[str]: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
continue_ bool: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
group_interval str: Minimum time interval between two notifications for the same group. Default is 5 minutes.
group_wait str: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
matchers Sequence[NotificationPolicyPolicyMatcher]: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
mute_timings Sequence[str]: A list of mute timing names to apply to alerts that match this policy.
policies Sequence[NotificationPolicyPolicyPolicy]: Routing rules for specific label sets.
repeat_interval str: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contactPoint String: The contact point to route notifications that match this rule to.
groupBies List<String>: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
continue Boolean: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
groupInterval String: Minimum time interval between two notifications for the same group. Default is 5 minutes.
groupWait String: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
matchers List<Property Map>: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
muteTimings List<String>: A list of mute timing names to apply to alerts that match this policy.
policies List<Property Map>: Routing rules for specific label sets.
repeatInterval String: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

NotificationPolicyPolicyMatcher

Label string
Match string
Value string

Label string
Match string
Value string

label String
match String
value String

label string
match string
value string

label str
match str
value str

label String
match String
value String

NotificationPolicyPolicyPolicy

ContactPoint string: The contact point to route notifications that match this rule to.
GroupBies List<string>: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
Continue bool: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
GroupInterval string: Minimum time interval between two notifications for the same group. Default is 5 minutes.
GroupWait string: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
Matchers List<Lbrlabs.PulumiPackage.Grafana.Inputs.NotificationPolicyPolicyPolicyMatcher>: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
MuteTimings List<string>: A list of mute timing names to apply to alerts that match this policy.
Policies List<Lbrlabs.PulumiPackage.Grafana.Inputs.NotificationPolicyPolicyPolicyPolicy>: Routing rules for specific label sets.
RepeatInterval string: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

ContactPoint string: The contact point to route notifications that match this rule to.
GroupBies []string: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
Continue bool: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
GroupInterval string: Minimum time interval between two notifications for the same group. Default is 5 minutes.
GroupWait string: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
Matchers []NotificationPolicyPolicyPolicyMatcher: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
MuteTimings []string: A list of mute timing names to apply to alerts that match this policy.
Policies []NotificationPolicyPolicyPolicyPolicy: Routing rules for specific label sets.
RepeatInterval string: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contactPoint String: The contact point to route notifications that match this rule to.
groupBies List<String>: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
continue_ Boolean: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
groupInterval String: Minimum time interval between two notifications for the same group. Default is 5 minutes.
groupWait String: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
matchers List<NotificationPolicyPolicyPolicyMatcher>: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
muteTimings List<String>: A list of mute timing names to apply to alerts that match this policy.
policies List<NotificationPolicyPolicyPolicyPolicy>: Routing rules for specific label sets.
repeatInterval String: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contactPoint string: The contact point to route notifications that match this rule to.
groupBies string[]: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
continue boolean: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
groupInterval string: Minimum time interval between two notifications for the same group. Default is 5 minutes.
groupWait string: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
matchers NotificationPolicyPolicyPolicyMatcher[]: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
muteTimings string[]: A list of mute timing names to apply to alerts that match this policy.
policies NotificationPolicyPolicyPolicyPolicy[]: Routing rules for specific label sets.
repeatInterval string: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contact_point str: The contact point to route notifications that match this rule to.
group_bies Sequence[str]: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
continue_ bool: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
group_interval str: Minimum time interval between two notifications for the same group. Default is 5 minutes.
group_wait str: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
matchers Sequence[NotificationPolicyPolicyPolicyMatcher]: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
mute_timings Sequence[str]: A list of mute timing names to apply to alerts that match this policy.
policies Sequence[NotificationPolicyPolicyPolicyPolicy]: Routing rules for specific label sets.
repeat_interval str: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contactPoint String: The contact point to route notifications that match this rule to.
groupBies List<String>: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
continue Boolean: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
groupInterval String: Minimum time interval between two notifications for the same group. Default is 5 minutes.
groupWait String: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
matchers List<Property Map>: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
muteTimings List<String>: A list of mute timing names to apply to alerts that match this policy.
policies List<Property Map>: Routing rules for specific label sets.
repeatInterval String: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

NotificationPolicyPolicyPolicyMatcher

Label string
Match string
Value string

Label string
Match string
Value string

label String
match String
value String

label string
match string
value string

label str
match str
value str

label String
match String
value String

NotificationPolicyPolicyPolicyPolicy

ContactPoint string: The contact point to route notifications that match this rule to.
GroupBies List<string>: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
Continue bool: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
GroupInterval string: Minimum time interval between two notifications for the same group. Default is 5 minutes.
GroupWait string: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
Matchers List<Lbrlabs.PulumiPackage.Grafana.Inputs.NotificationPolicyPolicyPolicyPolicyMatcher>: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
MuteTimings List<string>: A list of mute timing names to apply to alerts that match this policy.
Policies List<Lbrlabs.PulumiPackage.Grafana.Inputs.NotificationPolicyPolicyPolicyPolicyPolicy>: Routing rules for specific label sets.
RepeatInterval string: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

ContactPoint string: The contact point to route notifications that match this rule to.
GroupBies []string: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
Continue bool: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
GroupInterval string: Minimum time interval between two notifications for the same group. Default is 5 minutes.
GroupWait string: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
Matchers []NotificationPolicyPolicyPolicyPolicyMatcher: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
MuteTimings []string: A list of mute timing names to apply to alerts that match this policy.
Policies []NotificationPolicyPolicyPolicyPolicyPolicy: Routing rules for specific label sets.
RepeatInterval string: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contactPoint String: The contact point to route notifications that match this rule to.
groupBies List<String>: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
continue_ Boolean: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
groupInterval String: Minimum time interval between two notifications for the same group. Default is 5 minutes.
groupWait String: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
matchers List<NotificationPolicyPolicyPolicyPolicyMatcher>: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
muteTimings List<String>: A list of mute timing names to apply to alerts that match this policy.
policies List<NotificationPolicyPolicyPolicyPolicyPolicy>: Routing rules for specific label sets.
repeatInterval String: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contactPoint string: The contact point to route notifications that match this rule to.
groupBies string[]: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
continue boolean: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
groupInterval string: Minimum time interval between two notifications for the same group. Default is 5 minutes.
groupWait string: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
matchers NotificationPolicyPolicyPolicyPolicyMatcher[]: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
muteTimings string[]: A list of mute timing names to apply to alerts that match this policy.
policies NotificationPolicyPolicyPolicyPolicyPolicy[]: Routing rules for specific label sets.
repeatInterval string: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contact_point str: The contact point to route notifications that match this rule to.
group_bies Sequence[str]: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
continue_ bool: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
group_interval str: Minimum time interval between two notifications for the same group. Default is 5 minutes.
group_wait str: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
matchers Sequence[NotificationPolicyPolicyPolicyPolicyMatcher]: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
mute_timings Sequence[str]: A list of mute timing names to apply to alerts that match this policy.
policies Sequence[NotificationPolicyPolicyPolicyPolicyPolicy]: Routing rules for specific label sets.
repeat_interval str: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contactPoint String: The contact point to route notifications that match this rule to.
groupBies List<String>: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
continue Boolean: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
groupInterval String: Minimum time interval between two notifications for the same group. Default is 5 minutes.
groupWait String: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
matchers List<Property Map>: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
muteTimings List<String>: A list of mute timing names to apply to alerts that match this policy.
policies List<Property Map>: Routing rules for specific label sets.
repeatInterval String: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

NotificationPolicyPolicyPolicyPolicyMatcher

Label string
Match string
Value string

Label string
Match string
Value string

label String
match String
value String

label string
match string
value string

label str
match str
value str

label String
match String
value String

NotificationPolicyPolicyPolicyPolicyPolicy

ContactPoint string: The contact point to route notifications that match this rule to.
GroupBies List<string>: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
Continue bool: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
GroupInterval string: Minimum time interval between two notifications for the same group. Default is 5 minutes.
GroupWait string: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
Matchers List<Lbrlabs.PulumiPackage.Grafana.Inputs.NotificationPolicyPolicyPolicyPolicyPolicyMatcher>: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
MuteTimings List<string>: A list of mute timing names to apply to alerts that match this policy.
RepeatInterval string: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

ContactPoint string: The contact point to route notifications that match this rule to.
GroupBies []string: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
Continue bool: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
GroupInterval string: Minimum time interval between two notifications for the same group. Default is 5 minutes.
GroupWait string: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
Matchers []NotificationPolicyPolicyPolicyPolicyPolicyMatcher: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
MuteTimings []string: A list of mute timing names to apply to alerts that match this policy.
RepeatInterval string: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contactPoint String: The contact point to route notifications that match this rule to.
groupBies List<String>: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
continue_ Boolean: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
groupInterval String: Minimum time interval between two notifications for the same group. Default is 5 minutes.
groupWait String: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
matchers List<NotificationPolicyPolicyPolicyPolicyPolicyMatcher>: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
muteTimings List<String>: A list of mute timing names to apply to alerts that match this policy.
repeatInterval String: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contactPoint string: The contact point to route notifications that match this rule to.
groupBies string[]: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
continue boolean: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
groupInterval string: Minimum time interval between two notifications for the same group. Default is 5 minutes.
groupWait string: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
matchers NotificationPolicyPolicyPolicyPolicyPolicyMatcher[]: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
muteTimings string[]: A list of mute timing names to apply to alerts that match this policy.
repeatInterval string: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contact_point str: The contact point to route notifications that match this rule to.
group_bies Sequence[str]: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
continue_ bool: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
group_interval str: Minimum time interval between two notifications for the same group. Default is 5 minutes.
group_wait str: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
matchers Sequence[NotificationPolicyPolicyPolicyPolicyPolicyMatcher]: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
mute_timings Sequence[str]: A list of mute timing names to apply to alerts that match this policy.
repeat_interval str: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

contactPoint String: The contact point to route notifications that match this rule to.
groupBies List<String>: A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping.
continue Boolean: Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
groupInterval String: Minimum time interval between two notifications for the same group. Default is 5 minutes.
groupWait String: Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
matchers List<Property Map>: Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
muteTimings List<String>: A list of mute timing names to apply to alerts that match this policy.
repeatInterval String: Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

NotificationPolicyPolicyPolicyPolicyPolicyMatcher

Label string
Match string
Value string

Label string
Match string
Value string

label String
match String
value String

label string
match string
value string

label str
match str
value str

label String
match String
value String

Import

The policy is a singleton, so the ID is a constant “policy” value.

 $ pulumi import grafana:index/notificationPolicy:NotificationPolicy notification_policy_name "policy"

Package Details

Repository: grafana lbrlabs/pulumi-grafana
License: Apache-2.0
Notes: This Pulumi package is based on the grafana Terraform Provider.