Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi Cloud Packages Tutorials
  1. Packages
  2. Grafana Cloud
  3. API Docs
  4. NotificationPolicy
Grafana v0.16.3 published on Monday, Apr 7, 2025 by pulumiverse
pulumiverse/pulumi-grafana

grafana.NotificationPolicy

Explore with Pulumi AI

Grafana v0.16.3 published on Monday, Apr 7, 2025 by pulumiverse
pulumiverse/pulumi-grafana
Deprecated: grafana.index/notificationpolicy.NotificationPolicy has been deprecated in favor of grafana.alerting/notificationpolicy.NotificationPolicy

Sets the global notification policy for Grafana.

!> This resource manages the entire notification policy tree and overwrites its policies. However, it does not overwrite internal policies created when alert rules directly set a contact point for notifications.

This resource requires Grafana 9.1.0 or later.

Example Usage

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

const aContactPoint = new grafana.alerting.ContactPoint("a_contact_point", {
    name: "A Contact Point",
    emails: [{
        addresses: [
            "one@company.org",
            "two@company.org",
        ],
        message: "{{ len .Alerts.Firing }} firing.",
    }],
});
const aMuteTiming = new grafana.alerting.MuteTiming("a_mute_timing", {
    name: "Some Mute Timing",
    intervals: [{
        weekdays: ["monday"],
    }],
});
const myNotificationPolicy = new grafana.alerting.NotificationPolicy("my_notification_policy", {
    groupBies: ["..."],
    contactPoint: aContactPoint.name,
    groupWait: "45s",
    groupInterval: "6m",
    repeatInterval: "3h",
    policies: [
        {
            matchers: [
                {
                    label: "mylabel",
                    match: "=",
                    value: "myvalue",
                },
                {
                    label: "alertname",
                    match: "=",
                    value: "CPU Usage",
                },
                {
                    label: "Name",
                    match: "=~",
                    value: "host.*|host-b.*",
                },
            ],
            contactPoint: aContactPoint.name,
            "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: ["..."],
        },
    ],
});
Copy
import pulumi
import pulumiverse_grafana as grafana

a_contact_point = grafana.alerting.ContactPoint("a_contact_point",
    name="A Contact Point",
    emails=[{
        "addresses": [
            "one@company.org",
            "two@company.org",
        ],
        "message": "{{ len .Alerts.Firing }} firing.",
    }])
a_mute_timing = grafana.alerting.MuteTiming("a_mute_timing",
    name="Some Mute Timing",
    intervals=[{
        "weekdays": ["monday"],
    }])
my_notification_policy = grafana.alerting.NotificationPolicy("my_notification_policy",
    group_bies=["..."],
    contact_point=a_contact_point.name,
    group_wait="45s",
    group_interval="6m",
    repeat_interval="3h",
    policies=[
        {
            "matchers": [
                {
                    "label": "mylabel",
                    "match": "=",
                    "value": "myvalue",
                },
                {
                    "label": "alertname",
                    "match": "=",
                    "value": "CPU Usage",
                },
                {
                    "label": "Name",
                    "match": "=~",
                    "value": "host.*|host-b.*",
                },
            ],
            "contact_point": a_contact_point.name,
            "continue_": True,
            "mute_timings": [a_mute_timing.name],
            "group_wait": "45s",
            "group_interval": "6m",
            "repeat_interval": "3h",
            "policies": [{
                "matchers": [{
                    "label": "sublabel",
                    "match": "=",
                    "value": "subvalue",
                }],
                "contact_point": a_contact_point.name,
                "group_bies": ["..."],
            }],
        },
        {
            "matchers": [{
                "label": "anotherlabel",
                "match": "=~",
                "value": "another value.*",
            }],
            "contact_point": a_contact_point.name,
            "group_bies": ["..."],
        },
    ])
Copy
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		aContactPoint, err := alerting.NewContactPoint(ctx, "a_contact_point", &alerting.ContactPointArgs{
			Name: pulumi.String("A Contact Point"),
			Emails: alerting.ContactPointEmailArray{
				&alerting.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 := alerting.NewMuteTiming(ctx, "a_mute_timing", &alerting.MuteTimingArgs{
			Name: pulumi.String("Some Mute Timing"),
			Intervals: alerting.MuteTimingIntervalArray{
				&alerting.MuteTimingIntervalArgs{
					Weekdays: pulumi.StringArray{
						pulumi.String("monday"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = alerting.NewNotificationPolicy(ctx, "my_notification_policy", &alerting.NotificationPolicyArgs{
			GroupBies: pulumi.StringArray{
				pulumi.String("..."),
			},
			ContactPoint:   aContactPoint.Name,
			GroupWait:      pulumi.String("45s"),
			GroupInterval:  pulumi.String("6m"),
			RepeatInterval: pulumi.String("3h"),
			Policies: alerting.NotificationPolicyPolicyArray{
				&alerting.NotificationPolicyPolicyArgs{
					Matchers: alerting.NotificationPolicyPolicyMatcherArray{
						&alerting.NotificationPolicyPolicyMatcherArgs{
							Label: pulumi.String("mylabel"),
							Match: pulumi.String("="),
							Value: pulumi.String("myvalue"),
						},
						&alerting.NotificationPolicyPolicyMatcherArgs{
							Label: pulumi.String("alertname"),
							Match: pulumi.String("="),
							Value: pulumi.String("CPU Usage"),
						},
						&alerting.NotificationPolicyPolicyMatcherArgs{
							Label: pulumi.String("Name"),
							Match: pulumi.String("=~"),
							Value: pulumi.String("host.*|host-b.*"),
						},
					},
					ContactPoint: aContactPoint.Name,
					Continue:     pulumi.Bool(true),
					MuteTimings: pulumi.StringArray{
						aMuteTiming.Name,
					},
					GroupWait:      pulumi.String("45s"),
					GroupInterval:  pulumi.String("6m"),
					RepeatInterval: pulumi.String("3h"),
					Policies: alerting.NotificationPolicyPolicyPolicyArray{
						&alerting.NotificationPolicyPolicyPolicyArgs{
							Matchers: alerting.NotificationPolicyPolicyPolicyMatcherArray{
								&alerting.NotificationPolicyPolicyPolicyMatcherArgs{
									Label: pulumi.String("sublabel"),
									Match: pulumi.String("="),
									Value: pulumi.String("subvalue"),
								},
							},
							ContactPoint: aContactPoint.Name,
							GroupBies: pulumi.StringArray{
								pulumi.String("..."),
							},
						},
					},
				},
				&alerting.NotificationPolicyPolicyArgs{
					Matchers: alerting.NotificationPolicyPolicyMatcherArray{
						&alerting.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
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Grafana = Pulumiverse.Grafana;

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

    var aMuteTiming = new Grafana.Alerting.MuteTiming("a_mute_timing", new()
    {
        Name = "Some Mute Timing",
        Intervals = new[]
        {
            new Grafana.Alerting.Inputs.MuteTimingIntervalArgs
            {
                Weekdays = new[]
                {
                    "monday",
                },
            },
        },
    });

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

});
Copy
package generated_program;

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

        var aMuteTiming = new MuteTiming("aMuteTiming", MuteTimingArgs.builder()
            .name("Some Mute Timing")
            .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(),
                        NotificationPolicyPolicyMatcherArgs.builder()
                            .label("alertname")
                            .match("=")
                            .value("CPU Usage")
                            .build(),
                        NotificationPolicyPolicyMatcherArgs.builder()
                            .label("Name")
                            .match("=~")
                            .value("host.*|host-b.*")
                            .build())
                    .contactPoint(aContactPoint.name())
                    .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());

    }
}
Copy
resources:
  aContactPoint:
    type: grafana:alerting:ContactPoint
    name: a_contact_point
    properties:
      name: A Contact Point
      emails:
        - addresses:
            - one@company.org
            - two@company.org
          message: '{{ len .Alerts.Firing }} firing.'
  aMuteTiming:
    type: grafana:alerting:MuteTiming
    name: a_mute_timing
    properties:
      name: Some Mute Timing
      intervals:
        - weekdays:
            - monday
  myNotificationPolicy:
    type: grafana:alerting:NotificationPolicy
    name: my_notification_policy
    properties:
      groupBies:
        - '...'
      contactPoint: ${aContactPoint.name}
      groupWait: 45s
      groupInterval: 6m
      repeatInterval: 3h
      policies:
        - matchers:
            - label: mylabel
              match: =
              value: myvalue
            - label: alertname
              match: =
              value: CPU Usage
            - label: Name
              match: =~
              value: host.*|host-b.*
          contactPoint: ${aContactPoint.name}
          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:
            - '...'
Copy

Create NotificationPolicy Resource

Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

Constructor syntax

new NotificationPolicy(name: string, args: NotificationPolicyArgs, opts?: CustomResourceOptions);
@overload
def NotificationPolicy(resource_name: str,
                       args: NotificationPolicyArgs,
                       opts: Optional[ResourceOptions] = None)

@overload
def NotificationPolicy(resource_name: str,
                       opts: Optional[ResourceOptions] = None,
                       contact_point: Optional[str] = None,
                       disable_provenance: Optional[bool] = None,
                       group_bies: Optional[Sequence[str]] = None,
                       group_interval: Optional[str] = None,
                       group_wait: Optional[str] = None,
                       org_id: Optional[str] = None,
                       policies: Optional[Sequence[NotificationPolicyPolicyArgs]] = None,
                       repeat_interval: Optional[str] = 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.

Parameters

name This property is required. string
The unique name of the resource.
args This property is required. NotificationPolicyArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
resource_name This property is required. str
The unique name of the resource.
args This property is required. 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 This property is required. string
The unique name of the resource.
args This property is required. NotificationPolicyArgs
The arguments to resource properties.
opts ResourceOption
Bag of options to control resource's behavior.
name This property is required. string
The unique name of the resource.
args This property is required. NotificationPolicyArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
name This property is required. String
The unique name of the resource.
args This property is required. 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

In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

The NotificationPolicy resource accepts the following input properties:

ContactPoint This property is required. string
The default contact point to route all unmatched notifications to.
GroupBies This property is required. 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.
DisableProvenance bool
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.
OrgId Changes to this property will trigger replacement. string
The Organization ID. If not set, the Org ID defined in the provider block will be used.
Policies List<Pulumiverse.Grafana.Inputs.NotificationPolicyPolicy>
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 This property is required. string
The default contact point to route all unmatched notifications to.
GroupBies This property is required. []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.
DisableProvenance bool
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.
OrgId Changes to this property will trigger replacement. string
The Organization ID. If not set, the Org ID defined in the provider block will be used.
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 This property is required. String
The default contact point to route all unmatched notifications to.
groupBies This property is required. 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.
disableProvenance Boolean
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.
orgId Changes to this property will trigger replacement. String
The Organization ID. If not set, the Org ID defined in the provider block will be used.
policies List<NotificationPolicyPolicy>
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 This property is required. string
The default contact point to route all unmatched notifications to.
groupBies This property is required. 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.
disableProvenance boolean
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.
orgId Changes to this property will trigger replacement. string
The Organization ID. If not set, the Org ID defined in the provider block will be used.
policies NotificationPolicyPolicy[]
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 This property is required. str
The default contact point to route all unmatched notifications to.
group_bies This property is required. 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.
disable_provenance bool
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.
org_id Changes to this property will trigger replacement. str
The Organization ID. If not set, the Org ID defined in the provider block will be used.
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 This property is required. String
The default contact point to route all unmatched notifications to.
groupBies This property is required. 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.
disableProvenance Boolean
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.
orgId Changes to this property will trigger replacement. String
The Organization ID. If not set, the Org ID defined in the provider block will be used.
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,
        disable_provenance: Optional[bool] = None,
        group_bies: Optional[Sequence[str]] = None,
        group_interval: Optional[str] = None,
        group_wait: Optional[str] = None,
        org_id: 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)
resources:  _:    type: grafana:NotificationPolicy    get:      id: ${id}
name This property is required.
The unique name of the resulting resource.
id This property is required.
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 This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
name This property is required.
The unique name of the resulting resource.
id This property is required.
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 This property is required.
The unique name of the resulting resource.
id This property is required.
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 This property is required.
The unique name of the resulting resource.
id This property is required.
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.
DisableProvenance bool
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.
OrgId Changes to this property will trigger replacement. string
The Organization ID. If not set, the Org ID defined in the provider block will be used.
Policies List<Pulumiverse.Grafana.Inputs.NotificationPolicyPolicy>
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.
DisableProvenance bool
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.
OrgId Changes to this property will trigger replacement. string
The Organization ID. If not set, the Org ID defined in the provider block will be used.
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.
disableProvenance Boolean
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.
orgId Changes to this property will trigger replacement. String
The Organization ID. If not set, the Org ID defined in the provider block will be used.
policies List<NotificationPolicyPolicy>
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.
disableProvenance boolean
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.
orgId Changes to this property will trigger replacement. string
The Organization ID. If not set, the Org ID defined in the provider block will be used.
policies NotificationPolicyPolicy[]
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.
disable_provenance bool
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.
org_id Changes to this property will trigger replacement. str
The Organization ID. If not set, the Org ID defined in the provider block will be used.
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.
disableProvenance Boolean
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.
orgId Changes to this property will trigger replacement. String
The Organization ID. If not set, the Org ID defined in the provider block will be used.
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
, NotificationPolicyPolicyArgs

ContactPoint string
The contact point to route notifications that match this rule to.
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.
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. Required for root policy only. If empty, the parent grouping is used.
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<Pulumiverse.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<Pulumiverse.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.
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.
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. Required for root policy only. If empty, the parent grouping is used.
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.
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.
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. Required for root policy only. If empty, the parent grouping is used.
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.
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.
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. Required for root policy only. If empty, the parent grouping is used.
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.
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_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. Required for root policy only. If empty, the parent grouping is used.
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.
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.
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. Required for root policy only. If empty, the parent grouping is used.
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
, NotificationPolicyPolicyMatcherArgs

Label This property is required. string
The name of the label to match against.
Match This property is required. string
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
Value This property is required. string
The label value to match against.
Label This property is required. string
The name of the label to match against.
Match This property is required. string
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
Value This property is required. string
The label value to match against.
label This property is required. String
The name of the label to match against.
match This property is required. String
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
value This property is required. String
The label value to match against.
label This property is required. string
The name of the label to match against.
match This property is required. string
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
value This property is required. string
The label value to match against.
label This property is required. str
The name of the label to match against.
match This property is required. str
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
value This property is required. str
The label value to match against.
label This property is required. String
The name of the label to match against.
match This property is required. String
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
value This property is required. String
The label value to match against.

NotificationPolicyPolicyPolicy
, NotificationPolicyPolicyPolicyArgs

ContactPoint string
The contact point to route notifications that match this rule to.
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.
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. Required for root policy only. If empty, the parent grouping is used.
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<Pulumiverse.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<Pulumiverse.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.
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.
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. Required for root policy only. If empty, the parent grouping is used.
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.
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.
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. Required for root policy only. If empty, the parent grouping is used.
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.
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.
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. Required for root policy only. If empty, the parent grouping is used.
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.
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_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. Required for root policy only. If empty, the parent grouping is used.
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.
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.
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. Required for root policy only. If empty, the parent grouping is used.
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
, NotificationPolicyPolicyPolicyMatcherArgs

Label This property is required. string
The name of the label to match against.
Match This property is required. string
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
Value This property is required. string
The label value to match against.
Label This property is required. string
The name of the label to match against.
Match This property is required. string
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
Value This property is required. string
The label value to match against.
label This property is required. String
The name of the label to match against.
match This property is required. String
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
value This property is required. String
The label value to match against.
label This property is required. string
The name of the label to match against.
match This property is required. string
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
value This property is required. string
The label value to match against.
label This property is required. str
The name of the label to match against.
match This property is required. str
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
value This property is required. str
The label value to match against.
label This property is required. String
The name of the label to match against.
match This property is required. String
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
value This property is required. String
The label value to match against.

NotificationPolicyPolicyPolicyPolicy
, NotificationPolicyPolicyPolicyPolicyArgs

ContactPoint string
The contact point to route notifications that match this rule to.
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.
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. Required for root policy only. If empty, the parent grouping is used.
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<Pulumiverse.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<Pulumiverse.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.
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.
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. Required for root policy only. If empty, the parent grouping is used.
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.
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.
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. Required for root policy only. If empty, the parent grouping is used.
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.
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.
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. Required for root policy only. If empty, the parent grouping is used.
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.
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_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. Required for root policy only. If empty, the parent grouping is used.
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.
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.
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. Required for root policy only. If empty, the parent grouping is used.
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
, NotificationPolicyPolicyPolicyPolicyMatcherArgs

Label This property is required. string
The name of the label to match against.
Match This property is required. string
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
Value This property is required. string
The label value to match against.
Label This property is required. string
The name of the label to match against.
Match This property is required. string
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
Value This property is required. string
The label value to match against.
label This property is required. String
The name of the label to match against.
match This property is required. String
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
value This property is required. String
The label value to match against.
label This property is required. string
The name of the label to match against.
match This property is required. string
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
value This property is required. string
The label value to match against.
label This property is required. str
The name of the label to match against.
match This property is required. str
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
value This property is required. str
The label value to match against.
label This property is required. String
The name of the label to match against.
match This property is required. String
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
value This property is required. String
The label value to match against.

NotificationPolicyPolicyPolicyPolicyPolicy
, NotificationPolicyPolicyPolicyPolicyPolicyArgs

GroupBies This property is required. 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. Required for root policy only. If empty, the parent grouping is used.
ContactPoint string
The contact point to route notifications that match this rule to.
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<Pulumiverse.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.
GroupBies This property is required. []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. Required for root policy only. If empty, the parent grouping is used.
ContactPoint string
The contact point to route notifications that match this rule to.
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.
groupBies This property is required. 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. Required for root policy only. If empty, the parent grouping is used.
contactPoint String
The contact point to route notifications that match this rule to.
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.
groupBies This property is required. 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. Required for root policy only. If empty, the parent grouping is used.
contactPoint string
The contact point to route notifications that match this rule to.
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.
group_bies This property is required. 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. Required for root policy only. If empty, the parent grouping is used.
contact_point str
The contact point to route notifications that match this rule to.
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.
groupBies This property is required. 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. Required for root policy only. If empty, the parent grouping is used.
contactPoint String
The contact point to route notifications that match this rule to.
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
, NotificationPolicyPolicyPolicyPolicyPolicyMatcherArgs

Label This property is required. string
The name of the label to match against.
Match This property is required. string
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
Value This property is required. string
The label value to match against.
Label This property is required. string
The name of the label to match against.
Match This property is required. string
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
Value This property is required. string
The label value to match against.
label This property is required. String
The name of the label to match against.
match This property is required. String
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
value This property is required. String
The label value to match against.
label This property is required. string
The name of the label to match against.
match This property is required. string
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
value This property is required. string
The label value to match against.
label This property is required. str
The name of the label to match against.
match This property is required. str
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
value This property is required. str
The label value to match against.
label This property is required. String
The name of the label to match against.
match This property is required. String
The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
value This property is required. String
The label value to match against.

Import

$ pulumi import grafana:index/notificationPolicy:NotificationPolicy name "{{ anyString }}"
Copy
$ pulumi import grafana:index/notificationPolicy:NotificationPolicy name "{{ orgID }}:{{ anyString }}"
Copy

To learn more about importing existing cloud resources, see Importing resources.

Package Details

Repository
grafana pulumiverse/pulumi-grafana
License
Apache-2.0
Notes
This Pulumi package is based on the grafana Terraform Provider.
Grafana v0.16.3 published on Monday, Apr 7, 2025 by pulumiverse
pulumiverse/pulumi-grafana