Sign in Dashboard Get started
  1. Registry
  2. Packages
  3. Vercel Provider
  4. API Docs
  5. CustomAlertRule
Viewing docs for Vercel v5.21.1
published on Thursday, Oct 15, 2026 by Pulumiverse
Schema (JSON)
pulumiverse/pulumi-vercel

vercel.CustomAlertRule

vercel logo vercel logo
Viewing docs for Vercel v5.21.1
published on Thursday, Oct 15, 2026 by Pulumiverse
Schema (JSON)
pulumiverse/pulumi-vercel

    Creates a project-scoped custom Vercel alert rule using the Alerts v3 API. Supports threshold and anomaly conditions on a metric or same-event ratio. Custom alerts must be enabled for the team. Manage Slack and webhook links with vercel.AlertRuleSlackNotification and vercel.AlertRuleWebhookNotification.

    Example Usage

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

const checkout = vercel.getProject({
    name: "checkout",
});
const checkoutErrors = new vercel.CustomAlertRule("checkout_errors", {
    name: "Checkout server errors",
    projectId: checkout.then(checkout => checkout.id),
    severity: "high",
    tags: [
        "checkout",
        "payments",
    ],
    evaluation: {
        window: "5m",
        query: {
            metrics: {
                errors: {
                    metric: "vercel.request.count",
                    aggregation: "count",
                    filter: "httpStatus >= 500",
                },
            },
            outputs: ["errors"],
        },
    },
    trigger: {
        type: "threshold",
        output: "errors",
        operator: "gt",
        threshold: 20,
    },
    notificationSettings: {
        enableTeamOwnerNotifications: true,
    },
});
const checkoutErrorsAlertRuleSlackNotification = new vercel.AlertRuleSlackNotification("checkout_errors", {
    alertRuleId: checkoutErrors.id,
    slackChannelId: "C0123456789",
});
// Page on-call only when the agent investigation classifies the alert as Critical.
const checkoutErrorsOncall = new vercel.AlertRuleSlackNotification("checkout_errors_oncall", {
    alertRuleId: checkoutErrors.id,
    slackChannelId: "C0ONCALL00",
    minimumSeverityLevel: "critical",
});
const alerts = new vercel.Webhook("alerts", {
    endpoint: "https://example.com/vercel-alerts",
    events: ["alerts.triggered"],
});
const checkoutErrorsAlertRuleWebhookNotification = new vercel.AlertRuleWebhookNotification("checkout_errors", {
    alertRuleId: checkoutErrors.id,
    webhookId: alerts.id,
});

    import pulumi
import pulumi_vercel as vercel
import pulumiverse_vercel as vercel

checkout = vercel.get_project(name="checkout")
checkout_errors = vercel.CustomAlertRule("checkout_errors",
    name="Checkout server errors",
    project_id=checkout.id,
    severity="high",
    tags=[
        "checkout",
        "payments",
    ],
    evaluation={
        "window": "5m",
        "query": {
            "metrics": {
                "errors": {
                    "metric": "vercel.request.count",
                    "aggregation": "count",
                    "filter": "httpStatus >= 500",
                },
            },
            "outputs": ["errors"],
        },
    },
    trigger={
        "type": "threshold",
        "output": "errors",
        "operator": "gt",
        "threshold": 20,
    },
    notification_settings={
        "enable_team_owner_notifications": True,
    })
checkout_errors_alert_rule_slack_notification = vercel.AlertRuleSlackNotification("checkout_errors",
    alert_rule_id=checkout_errors.id,
    slack_channel_id="C0123456789")
# Page on-call only when the agent investigation classifies the alert as Critical.
checkout_errors_oncall = vercel.AlertRuleSlackNotification("checkout_errors_oncall",
    alert_rule_id=checkout_errors.id,
    slack_channel_id="C0ONCALL00",
    minimum_severity_level="critical")
alerts = vercel.Webhook("alerts",
    endpoint="https://example.com/vercel-alerts",
    events=["alerts.triggered"])
checkout_errors_alert_rule_webhook_notification = vercel.AlertRuleWebhookNotification("checkout_errors",
    alert_rule_id=checkout_errors.id,
    webhook_id=alerts.id)

    package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-vercel/sdk/v5/go/vercel"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		checkout, err := vercel.LookupProject(ctx, &vercel.LookupProjectArgs{
			Name: "checkout",
		}, nil)
		if err != nil {
			return err
		}
		checkoutErrors, err := vercel.NewCustomAlertRule(ctx, "checkout_errors", &vercel.CustomAlertRuleArgs{
			Name:      pulumi.String("Checkout server errors"),
			ProjectId: pulumi.String(checkout.Id),
			Severity:  pulumi.String("high"),
			Tags: pulumi.StringArray{
				pulumi.String("checkout"),
				pulumi.String("payments"),
			},
			Evaluation: &vercel.CustomAlertRuleEvaluationArgs{
				Window: pulumi.String("5m"),
				Query: &vercel.CustomAlertRuleEvaluationQueryArgs{
					Metrics: vercel.CustomAlertRuleEvaluationQueryMetricsMap{
						"errors": &vercel.CustomAlertRuleEvaluationQueryMetricsArgs{
							Metric:      pulumi.String("vercel.request.count"),
							Aggregation: pulumi.String("count"),
							Filter:      pulumi.String("httpStatus >= 500"),
						},
					},
					Outputs: pulumi.StringArray{
						pulumi.String("errors"),
					},
				},
			},
			Trigger: &vercel.CustomAlertRuleTriggerArgs{
				Type:      pulumi.String("threshold"),
				Output:    pulumi.String("errors"),
				Operator:  pulumi.String("gt"),
				Threshold: pulumi.Float64(20),
			},
			NotificationSettings: &vercel.CustomAlertRuleNotificationSettingsArgs{
				EnableTeamOwnerNotifications: pulumi.Bool(true),
			},
		})
		if err != nil {
			return err
		}
		_, err = vercel.NewAlertRuleSlackNotification(ctx, "checkout_errors", &vercel.AlertRuleSlackNotificationArgs{
			AlertRuleId:    checkoutErrors.ID(),
			SlackChannelId: pulumi.String("C0123456789"),
		})
		if err != nil {
			return err
		}
		// Page on-call only when the agent investigation classifies the alert as Critical.
		_, err = vercel.NewAlertRuleSlackNotification(ctx, "checkout_errors_oncall", &vercel.AlertRuleSlackNotificationArgs{
			AlertRuleId:          checkoutErrors.ID(),
			SlackChannelId:       pulumi.String("C0ONCALL00"),
			MinimumSeverityLevel: pulumi.String("critical"),
		})
		if err != nil {
			return err
		}
		alerts, err := vercel.NewWebhook(ctx, "alerts", &vercel.WebhookArgs{
			Endpoint: pulumi.String("https://example.com/vercel-alerts"),
			Events: pulumi.StringArray{
				pulumi.String("alerts.triggered"),
			},
		})
		if err != nil {
			return err
		}
		_, err = vercel.NewAlertRuleWebhookNotification(ctx, "checkout_errors", &vercel.AlertRuleWebhookNotificationArgs{
			AlertRuleId: checkoutErrors.ID(),
			WebhookId:   alerts.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var checkout = Vercel.GetProject.Invoke(new()
    {
        Name = "checkout",
    });

    var checkoutErrors = new Vercel.CustomAlertRule("checkout_errors", new()
    {
        Name = "Checkout server errors",
        ProjectId = checkout.Apply(getProjectResult => getProjectResult.Id),
        Severity = "high",
        Tags = new[]
        {
            "checkout",
            "payments",
        },
        Evaluation = new Vercel.Inputs.CustomAlertRuleEvaluationArgs
        {
            Window = "5m",
            Query = new Vercel.Inputs.CustomAlertRuleEvaluationQueryArgs
            {
                Metrics = 
                {
                    { "errors", new Vercel.Inputs.CustomAlertRuleEvaluationQueryMetricsArgs
                    {
                        Metric = "vercel.request.count",
                        Aggregation = "count",
                        Filter = "httpStatus >= 500",
                    } },
                },
                Outputs = new[]
                {
                    "errors",
                },
            },
        },
        Trigger = new Vercel.Inputs.CustomAlertRuleTriggerArgs
        {
            Type = "threshold",
            Output = "errors",
            Operator = "gt",
            Threshold = 20,
        },
        NotificationSettings = new Vercel.Inputs.CustomAlertRuleNotificationSettingsArgs
        {
            EnableTeamOwnerNotifications = true,
        },
    });

    var checkoutErrorsAlertRuleSlackNotification = new Vercel.AlertRuleSlackNotification("checkout_errors", new()
    {
        AlertRuleId = checkoutErrors.Id,
        SlackChannelId = "C0123456789",
    });

    // Page on-call only when the agent investigation classifies the alert as Critical.
    var checkoutErrorsOncall = new Vercel.AlertRuleSlackNotification("checkout_errors_oncall", new()
    {
        AlertRuleId = checkoutErrors.Id,
        SlackChannelId = "C0ONCALL00",
        MinimumSeverityLevel = "critical",
    });

    var alerts = new Vercel.Webhook("alerts", new()
    {
        Endpoint = "https://example.com/vercel-alerts",
        Events = new[]
        {
            "alerts.triggered",
        },
    });

    var checkoutErrorsAlertRuleWebhookNotification = new Vercel.AlertRuleWebhookNotification("checkout_errors", new()
    {
        AlertRuleId = checkoutErrors.Id,
        WebhookId = alerts.Id,
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.vercel.VercelFunctions;
import com.pulumi.vercel.inputs.GetProjectArgs;
import com.pulumiverse.vercel.CustomAlertRule;
import com.pulumiverse.vercel.CustomAlertRuleArgs;
import com.pulumi.vercel.inputs.CustomAlertRuleEvaluationArgs;
import com.pulumi.vercel.inputs.CustomAlertRuleEvaluationQueryArgs;
import com.pulumi.vercel.inputs.CustomAlertRuleTriggerArgs;
import com.pulumi.vercel.inputs.CustomAlertRuleNotificationSettingsArgs;
import com.pulumiverse.vercel.AlertRuleSlackNotification;
import com.pulumiverse.vercel.AlertRuleSlackNotificationArgs;
import com.pulumiverse.vercel.Webhook;
import com.pulumiverse.vercel.WebhookArgs;
import com.pulumiverse.vercel.AlertRuleWebhookNotification;
import com.pulumiverse.vercel.AlertRuleWebhookNotificationArgs;
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) {
        final var checkout = VercelFunctions.getProject(GetProjectArgs.builder()
            .name("checkout")
            .build());

        var checkoutErrors = new CustomAlertRule("checkoutErrors", CustomAlertRuleArgs.builder()
            .name("Checkout server errors")
            .projectId(checkout.id())
            .severity("high")
            .tags(            
                "checkout",
                "payments")
            .evaluation(CustomAlertRuleEvaluationArgs.builder()
                .window("5m")
                .query(CustomAlertRuleEvaluationQueryArgs.builder()
                    .metrics(Map.of("errors", CustomAlertRuleEvaluationQueryMetricsArgs.builder()
                        .metric("vercel.request.count")
                        .aggregation("count")
                        .filter("httpStatus >= 500")
                        .build()))
                    .outputs("errors")
                    .build())
                .build())
            .trigger(CustomAlertRuleTriggerArgs.builder()
                .type("threshold")
                .output("errors")
                .operator("gt")
                .threshold(20.0)
                .build())
            .notificationSettings(CustomAlertRuleNotificationSettingsArgs.builder()
                .enableTeamOwnerNotifications(true)
                .build())
            .build());

        var checkoutErrorsAlertRuleSlackNotification = new AlertRuleSlackNotification("checkoutErrorsAlertRuleSlackNotification", AlertRuleSlackNotificationArgs.builder()
            .alertRuleId(checkoutErrors.id())
            .slackChannelId("C0123456789")
            .build());

        // Page on-call only when the agent investigation classifies the alert as Critical.
        var checkoutErrorsOncall = new AlertRuleSlackNotification("checkoutErrorsOncall", AlertRuleSlackNotificationArgs.builder()
            .alertRuleId(checkoutErrors.id())
            .slackChannelId("C0ONCALL00")
            .minimumSeverityLevel("critical")
            .build());

        var alerts = new Webhook("alerts", WebhookArgs.builder()
            .endpoint("https://example.com/vercel-alerts")
            .events("alerts.triggered")
            .build());

        var checkoutErrorsAlertRuleWebhookNotification = new AlertRuleWebhookNotification("checkoutErrorsAlertRuleWebhookNotification", AlertRuleWebhookNotificationArgs.builder()
            .alertRuleId(checkoutErrors.id())
            .webhookId(alerts.id())
            .build());

    }
}

    resources:
  checkoutErrors:
    type: vercel:CustomAlertRule
    name: checkout_errors
    properties:
      name: Checkout server errors
      projectId: ${checkout.id}
      severity: high
      tags:
        - checkout
        - payments
      evaluation:
        window: 5m
        query:
          metrics:
            errors:
              metric: vercel.request.count
              aggregation: count
              filter: httpStatus >= 500
          outputs:
            - errors
      trigger:
        type: threshold
        output: errors
        operator: gt
        threshold: 20
      notificationSettings:
        enableTeamOwnerNotifications: true
  checkoutErrorsAlertRuleSlackNotification:
    type: vercel:AlertRuleSlackNotification
    name: checkout_errors
    properties:
      alertRuleId: ${checkoutErrors.id}
      slackChannelId: C0123456789
  # Page on-call only when the agent investigation classifies the alert as Critical.
  checkoutErrorsOncall:
    type: vercel:AlertRuleSlackNotification
    name: checkout_errors_oncall
    properties:
      alertRuleId: ${checkoutErrors.id}
      slackChannelId: C0ONCALL00
      minimumSeverityLevel: critical
  checkoutErrorsAlertRuleWebhookNotification:
    type: vercel:AlertRuleWebhookNotification
    name: checkout_errors
    properties:
      alertRuleId: ${checkoutErrors.id}
      webhookId: ${alerts.id}
  alerts:
    type: vercel:Webhook
    properties:
      endpoint: https://example.com/vercel-alerts
      events:
        - alerts.triggered
variables:
  checkout:
    fn::invoke:
      function: vercel:getProject
      arguments:
        name: checkout

    Example coming soon!

    Create CustomAlertRule Resource

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

    Constructor syntax

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

@overload
def CustomAlertRule(resource_name: str,
                    opts: Optional[ResourceOptions] = None,
                    evaluation: Optional[CustomAlertRuleEvaluationArgs] = None,
                    project_id: Optional[str] = None,
                    severity: Optional[str] = None,
                    trigger: Optional[CustomAlertRuleTriggerArgs] = None,
                    investigation_prompt: Optional[str] = None,
                    name: Optional[str] = None,
                    notification_settings: Optional[CustomAlertRuleNotificationSettingsArgs] = None,
                    tags: Optional[Sequence[str]] = None,
                    team_id: Optional[str] = None)
    func NewCustomAlertRule(ctx *Context, name string, args CustomAlertRuleArgs, opts ...ResourceOption) (*CustomAlertRule, error)
    public CustomAlertRule(string name, CustomAlertRuleArgs args, CustomResourceOptions? opts = null)
    public CustomAlertRule(String name, CustomAlertRuleArgs args)
public CustomAlertRule(String name, CustomAlertRuleArgs args, CustomResourceOptions options)

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


    resource "vercel_custom_alert_rule" "name" {
    # resource properties
}

    Parameters

    name string
    The unique name of the resource.
    args CustomAlertRuleArgs
    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 CustomAlertRuleArgs
    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 CustomAlertRuleArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args CustomAlertRuleArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args CustomAlertRuleArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var customAlertRuleResource = new Vercel.CustomAlertRule("customAlertRuleResource", new()
{
    Evaluation = new Vercel.Inputs.CustomAlertRuleEvaluationArgs
    {
        Query = new Vercel.Inputs.CustomAlertRuleEvaluationQueryArgs
        {
            Metrics = 
            {
                { "string", new Vercel.Inputs.CustomAlertRuleEvaluationQueryMetricsArgs
                {
                    Aggregation = "string",
                    Metric = "string",
                    Dimensions = new[]
                    {
                        "string",
                    },
                    Filter = "string",
                    Normalize = "string",
                    Per = "string",
                } },
            },
            Outputs = new[]
            {
                "string",
            },
            Filter = "string",
            Formulas = 
            {
                { "string", "string" },
            },
            GroupBies = new[]
            {
                "string",
            },
        },
        Window = "string",
    },
    ProjectId = "string",
    Severity = "string",
    Trigger = new Vercel.Inputs.CustomAlertRuleTriggerArgs
    {
        Output = "string",
        Type = "string",
        Minimum = new Vercel.Inputs.CustomAlertRuleTriggerMinimumArgs
        {
            Output = "string",
            Threshold = 0.0,
        },
        Operator = "string",
        StandardDeviations = 0.0,
        Threshold = 0.0,
    },
    InvestigationPrompt = "string",
    Name = "string",
    NotificationSettings = new Vercel.Inputs.CustomAlertRuleNotificationSettingsArgs
    {
        EnableTeamOwnerNotifications = false,
        IncidentIoRoutingKey = "string",
        VercelNotificationsMinimumSeverityLevel = "string",
    },
    Tags = new[]
    {
        "string",
    },
    TeamId = "string",
});

    example, err := vercel.NewCustomAlertRule(ctx, "customAlertRuleResource", &vercel.CustomAlertRuleArgs{
	Evaluation: &vercel.CustomAlertRuleEvaluationArgs{
		Query: &vercel.CustomAlertRuleEvaluationQueryArgs{
			Metrics: vercel.CustomAlertRuleEvaluationQueryMetricsMap{
				"string": &vercel.CustomAlertRuleEvaluationQueryMetricsArgs{
					Aggregation: pulumi.String("string"),
					Metric:      pulumi.String("string"),
					Dimensions: pulumi.StringArray{
						pulumi.String("string"),
					},
					Filter:    pulumi.String("string"),
					Normalize: pulumi.String("string"),
					Per:       pulumi.String("string"),
				},
			},
			Outputs: pulumi.StringArray{
				pulumi.String("string"),
			},
			Filter: pulumi.String("string"),
			Formulas: pulumi.StringMap{
				"string": pulumi.String("string"),
			},
			GroupBies: pulumi.StringArray{
				pulumi.String("string"),
			},
		},
		Window: pulumi.String("string"),
	},
	ProjectId: pulumi.String("string"),
	Severity:  pulumi.String("string"),
	Trigger: &vercel.CustomAlertRuleTriggerArgs{
		Output: pulumi.String("string"),
		Type:   pulumi.String("string"),
		Minimum: &vercel.CustomAlertRuleTriggerMinimumArgs{
			Output:    pulumi.String("string"),
			Threshold: pulumi.Float64(0),
		},
		Operator:           pulumi.String("string"),
		StandardDeviations: pulumi.Float64(0),
		Threshold:          pulumi.Float64(0),
	},
	InvestigationPrompt: pulumi.String("string"),
	Name:                pulumi.String("string"),
	NotificationSettings: &vercel.CustomAlertRuleNotificationSettingsArgs{
		EnableTeamOwnerNotifications:            pulumi.Bool(false),
		IncidentIoRoutingKey:                    pulumi.String("string"),
		VercelNotificationsMinimumSeverityLevel: pulumi.String("string"),
	},
	Tags: pulumi.StringArray{
		pulumi.String("string"),
	},
	TeamId: pulumi.String("string"),
})

    resource "vercel_custom_alert_rule" "customAlertRuleResource" {
  lifecycle {
    create_before_destroy = true
  }
  evaluation = {
    query = {
      metrics = {
        "string" = {
          aggregation = "string"
          metric      = "string"
          dimensions  = ["string"]
          filter      = "string"
          normalize   = "string"
          per         = "string"
        }
      }
      outputs = ["string"]
      filter  = "string"
      formulas = {
        "string" = "string"
      }
      group_bies = ["string"]
    }
    window = "string"
  }
  project_id = "string"
  severity   = "string"
  trigger = {
    output = "string"
    type   = "string"
    minimum = {
      output    = "string"
      threshold = 0
    }
    operator            = "string"
    standard_deviations = 0
    threshold           = 0
  }
  investigation_prompt = "string"
  name                 = "string"
  notification_settings = {
    enable_team_owner_notifications             = false
    incident_io_routing_key                     = "string"
    vercel_notifications_minimum_severity_level = "string"
  }
  tags    = ["string"]
  team_id = "string"
}

    var customAlertRuleResource = new CustomAlertRule("customAlertRuleResource", CustomAlertRuleArgs.builder()
    .evaluation(CustomAlertRuleEvaluationArgs.builder()
        .query(CustomAlertRuleEvaluationQueryArgs.builder()
            .metrics(Map.of("string", CustomAlertRuleEvaluationQueryMetricsArgs.builder()
                .aggregation("string")
                .metric("string")
                .dimensions("string")
                .filter("string")
                .normalize("string")
                .per("string")
                .build()))
            .outputs("string")
            .filter("string")
            .formulas(Map.of("string", "string"))
            .groupBies("string")
            .build())
        .window("string")
        .build())
    .projectId("string")
    .severity("string")
    .trigger(CustomAlertRuleTriggerArgs.builder()
        .output("string")
        .type("string")
        .minimum(CustomAlertRuleTriggerMinimumArgs.builder()
            .output("string")
            .threshold(0.0)
            .build())
        .operator("string")
        .standardDeviations(0.0)
        .threshold(0.0)
        .build())
    .investigationPrompt("string")
    .name("string")
    .notificationSettings(CustomAlertRuleNotificationSettingsArgs.builder()
        .enableTeamOwnerNotifications(false)
        .incidentIoRoutingKey("string")
        .vercelNotificationsMinimumSeverityLevel("string")
        .build())
    .tags("string")
    .teamId("string")
    .build());

    custom_alert_rule_resource = vercel.CustomAlertRule("customAlertRuleResource",
    evaluation={
        "query": {
            "metrics": {
                "string": {
                    "aggregation": "string",
                    "metric": "string",
                    "dimensions": ["string"],
                    "filter": "string",
                    "normalize": "string",
                    "per": "string",
                },
            },
            "outputs": ["string"],
            "filter": "string",
            "formulas": {
                "string": "string",
            },
            "group_bies": ["string"],
        },
        "window": "string",
    },
    project_id="string",
    severity="string",
    trigger={
        "output": "string",
        "type": "string",
        "minimum": {
            "output": "string",
            "threshold": float(0),
        },
        "operator": "string",
        "standard_deviations": float(0),
        "threshold": float(0),
    },
    investigation_prompt="string",
    name="string",
    notification_settings={
        "enable_team_owner_notifications": False,
        "incident_io_routing_key": "string",
        "vercel_notifications_minimum_severity_level": "string",
    },
    tags=["string"],
    team_id="string")

    const customAlertRuleResource = new vercel.CustomAlertRule("customAlertRuleResource", {
    evaluation: {
        query: {
            metrics: {
                string: {
                    aggregation: "string",
                    metric: "string",
                    dimensions: ["string"],
                    filter: "string",
                    normalize: "string",
                    per: "string",
                },
            },
            outputs: ["string"],
            filter: "string",
            formulas: {
                string: "string",
            },
            groupBies: ["string"],
        },
        window: "string",
    },
    projectId: "string",
    severity: "string",
    trigger: {
        output: "string",
        type: "string",
        minimum: {
            output: "string",
            threshold: 0,
        },
        operator: "string",
        standardDeviations: 0,
        threshold: 0,
    },
    investigationPrompt: "string",
    name: "string",
    notificationSettings: {
        enableTeamOwnerNotifications: false,
        incidentIoRoutingKey: "string",
        vercelNotificationsMinimumSeverityLevel: "string",
    },
    tags: ["string"],
    teamId: "string",
});

    type: vercel:CustomAlertRule
properties:
    evaluation:
        query:
            filter: string
            formulas:
                string: string
            groupBies:
                - string
            metrics:
                string:
                    aggregation: string
                    dimensions:
                        - string
                    filter: string
                    metric: string
                    normalize: string
                    per: string
            outputs:
                - string
        window: string
    investigationPrompt: string
    name: string
    notificationSettings:
        enableTeamOwnerNotifications: false
        incidentIoRoutingKey: string
        vercelNotificationsMinimumSeverityLevel: string
    projectId: string
    severity: string
    tags:
        - string
    teamId: string
    trigger:
        minimum:
            output: string
            threshold: 0
        operator: string
        output: string
        standardDeviations: 0
        threshold: 0
        type: string

    CustomAlertRule 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 CustomAlertRule resource accepts the following input properties:

    Evaluation Pulumiverse.Vercel.Inputs.CustomAlertRuleEvaluation
    The metric query and evaluation window.
    ProjectId string
    The project evaluated by this custom rule. Creating a rule or changing its query requires Observability Plus on this project.
    Severity string
    Severity assigned when the rule triggers: low, medium, or high. Critical severity is assigned only by a completed agent investigation.
    Trigger Pulumiverse.Vercel.Inputs.CustomAlertRuleTrigger
    A fixed threshold or anomaly condition on the query output.
    InvestigationPrompt string
    Optional guidance stored for agent investigations. The API currently stores this prompt without passing it to the investigation workflow. Removing it clears the stored prompt.
    Name string
    A human-readable name for the alert rule.
    NotificationSettings Pulumiverse.Vercel.Inputs.CustomAlertRuleNotificationSettings
    Notification delivery settings stored on the rule. Notification destination links are managed with the vercel.AlertRuleSlackNotification and vercel.AlertRuleWebhookNotification resources.
    Tags List<string>
    Up to 10 unique tags used to organize the rule. Removing all tags clears them.
    TeamId string
    The ID of the team that owns the alert rule. Required if a default team is not configured in the provider.
    Evaluation CustomAlertRuleEvaluationArgs
    The metric query and evaluation window.
    ProjectId string
    The project evaluated by this custom rule. Creating a rule or changing its query requires Observability Plus on this project.
    Severity string
    Severity assigned when the rule triggers: low, medium, or high. Critical severity is assigned only by a completed agent investigation.
    Trigger CustomAlertRuleTriggerArgs
    A fixed threshold or anomaly condition on the query output.
    InvestigationPrompt string
    Optional guidance stored for agent investigations. The API currently stores this prompt without passing it to the investigation workflow. Removing it clears the stored prompt.
    Name string
    A human-readable name for the alert rule.
    NotificationSettings CustomAlertRuleNotificationSettingsArgs
    Notification delivery settings stored on the rule. Notification destination links are managed with the vercel.AlertRuleSlackNotification and vercel.AlertRuleWebhookNotification resources.
    Tags []string
    Up to 10 unique tags used to organize the rule. Removing all tags clears them.
    TeamId string
    The ID of the team that owns the alert rule. Required if a default team is not configured in the provider.
    evaluation object
    The metric query and evaluation window.
    project_id string
    The project evaluated by this custom rule. Creating a rule or changing its query requires Observability Plus on this project.
    severity string
    Severity assigned when the rule triggers: low, medium, or high. Critical severity is assigned only by a completed agent investigation.
    trigger object
    A fixed threshold or anomaly condition on the query output.
    investigation_prompt string
    Optional guidance stored for agent investigations. The API currently stores this prompt without passing it to the investigation workflow. Removing it clears the stored prompt.
    name string
    A human-readable name for the alert rule.
    notification_settings object
    Notification delivery settings stored on the rule. Notification destination links are managed with the vercel.AlertRuleSlackNotification and vercel.AlertRuleWebhookNotification resources.
    tags list(string)
    Up to 10 unique tags used to organize the rule. Removing all tags clears them.
    team_id string
    The ID of the team that owns the alert rule. Required if a default team is not configured in the provider.
    evaluation CustomAlertRuleEvaluation
    The metric query and evaluation window.
    projectId String
    The project evaluated by this custom rule. Creating a rule or changing its query requires Observability Plus on this project.
    severity String
    Severity assigned when the rule triggers: low, medium, or high. Critical severity is assigned only by a completed agent investigation.
    trigger CustomAlertRuleTrigger
    A fixed threshold or anomaly condition on the query output.
    investigationPrompt String
    Optional guidance stored for agent investigations. The API currently stores this prompt without passing it to the investigation workflow. Removing it clears the stored prompt.
    name String
    A human-readable name for the alert rule.
    notificationSettings CustomAlertRuleNotificationSettings
    Notification delivery settings stored on the rule. Notification destination links are managed with the vercel.AlertRuleSlackNotification and vercel.AlertRuleWebhookNotification resources.
    tags List<String>
    Up to 10 unique tags used to organize the rule. Removing all tags clears them.
    teamId String
    The ID of the team that owns the alert rule. Required if a default team is not configured in the provider.
    evaluation CustomAlertRuleEvaluation
    The metric query and evaluation window.
    projectId string
    The project evaluated by this custom rule. Creating a rule or changing its query requires Observability Plus on this project.
    severity string
    Severity assigned when the rule triggers: low, medium, or high. Critical severity is assigned only by a completed agent investigation.
    trigger CustomAlertRuleTrigger
    A fixed threshold or anomaly condition on the query output.
    investigationPrompt string
    Optional guidance stored for agent investigations. The API currently stores this prompt without passing it to the investigation workflow. Removing it clears the stored prompt.
    name string
    A human-readable name for the alert rule.
    notificationSettings CustomAlertRuleNotificationSettings
    Notification delivery settings stored on the rule. Notification destination links are managed with the vercel.AlertRuleSlackNotification and vercel.AlertRuleWebhookNotification resources.
    tags string[]
    Up to 10 unique tags used to organize the rule. Removing all tags clears them.
    teamId string
    The ID of the team that owns the alert rule. Required if a default team is not configured in the provider.
    evaluation CustomAlertRuleEvaluationArgs
    The metric query and evaluation window.
    project_id str
    The project evaluated by this custom rule. Creating a rule or changing its query requires Observability Plus on this project.
    severity str
    Severity assigned when the rule triggers: low, medium, or high. Critical severity is assigned only by a completed agent investigation.
    trigger CustomAlertRuleTriggerArgs
    A fixed threshold or anomaly condition on the query output.
    investigation_prompt str
    Optional guidance stored for agent investigations. The API currently stores this prompt without passing it to the investigation workflow. Removing it clears the stored prompt.
    name str
    A human-readable name for the alert rule.
    notification_settings CustomAlertRuleNotificationSettingsArgs
    Notification delivery settings stored on the rule. Notification destination links are managed with the vercel.AlertRuleSlackNotification and vercel.AlertRuleWebhookNotification resources.
    tags Sequence[str]
    Up to 10 unique tags used to organize the rule. Removing all tags clears them.
    team_id str
    The ID of the team that owns the alert rule. Required if a default team is not configured in the provider.
    evaluation Property Map
    The metric query and evaluation window.
    projectId String
    The project evaluated by this custom rule. Creating a rule or changing its query requires Observability Plus on this project.
    severity String
    Severity assigned when the rule triggers: low, medium, or high. Critical severity is assigned only by a completed agent investigation.
    trigger Property Map
    A fixed threshold or anomaly condition on the query output.
    investigationPrompt String
    Optional guidance stored for agent investigations. The API currently stores this prompt without passing it to the investigation workflow. Removing it clears the stored prompt.
    name String
    A human-readable name for the alert rule.
    notificationSettings Property Map
    Notification delivery settings stored on the rule. Notification destination links are managed with the vercel.AlertRuleSlackNotification and vercel.AlertRuleWebhookNotification resources.
    tags List<String>
    Up to 10 unique tags used to organize the rule. Removing all tags clears them.
    teamId String
    The ID of the team that owns the alert rule. Required if a default team is not configured in the provider.

    Outputs

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

    CreatedAt int
    Creation time as a Unix epoch timestamp in milliseconds.
    Id string
    The provider-assigned unique ID for this managed resource.
    UpdatedAt int
    Last update time as a Unix epoch timestamp in milliseconds.
    CreatedAt int
    Creation time as a Unix epoch timestamp in milliseconds.
    Id string
    The provider-assigned unique ID for this managed resource.
    UpdatedAt int
    Last update time as a Unix epoch timestamp in milliseconds.
    created_at number
    Creation time as a Unix epoch timestamp in milliseconds.
    id string
    The provider-assigned unique ID for this managed resource.
    updated_at number
    Last update time as a Unix epoch timestamp in milliseconds.
    createdAt Integer
    Creation time as a Unix epoch timestamp in milliseconds.
    id String
    The provider-assigned unique ID for this managed resource.
    updatedAt Integer
    Last update time as a Unix epoch timestamp in milliseconds.
    createdAt number
    Creation time as a Unix epoch timestamp in milliseconds.
    id string
    The provider-assigned unique ID for this managed resource.
    updatedAt number
    Last update time as a Unix epoch timestamp in milliseconds.
    created_at int
    Creation time as a Unix epoch timestamp in milliseconds.
    id str
    The provider-assigned unique ID for this managed resource.
    updated_at int
    Last update time as a Unix epoch timestamp in milliseconds.
    createdAt Number
    Creation time as a Unix epoch timestamp in milliseconds.
    id String
    The provider-assigned unique ID for this managed resource.
    updatedAt Number
    Last update time as a Unix epoch timestamp in milliseconds.

    Look up Existing CustomAlertRule Resource

    Get an existing CustomAlertRule 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?: CustomAlertRuleState, opts?: CustomResourceOptions): CustomAlertRule
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        created_at: Optional[int] = None,
        evaluation: Optional[CustomAlertRuleEvaluationArgs] = None,
        investigation_prompt: Optional[str] = None,
        name: Optional[str] = None,
        notification_settings: Optional[CustomAlertRuleNotificationSettingsArgs] = None,
        project_id: Optional[str] = None,
        severity: Optional[str] = None,
        tags: Optional[Sequence[str]] = None,
        team_id: Optional[str] = None,
        trigger: Optional[CustomAlertRuleTriggerArgs] = None,
        updated_at: Optional[int] = None) -> CustomAlertRule
    func GetCustomAlertRule(ctx *Context, name string, id IDInput, state *CustomAlertRuleState, opts ...ResourceOption) (*CustomAlertRule, error)
    public static CustomAlertRule Get(string name, Input<string> id, CustomAlertRuleState? state, CustomResourceOptions? opts = null)
    public static CustomAlertRule get(String name, Output<String> id, CustomAlertRuleState state, CustomResourceOptions options)
    resources:  _:    type: vercel:CustomAlertRule    get:      id: ${id}
    import {
  to = vercel_custom_alert_rule.example
  id = "${id}"
}
    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:
    CreatedAt int
    Creation time as a Unix epoch timestamp in milliseconds.
    Evaluation Pulumiverse.Vercel.Inputs.CustomAlertRuleEvaluation
    The metric query and evaluation window.
    InvestigationPrompt string
    Optional guidance stored for agent investigations. The API currently stores this prompt without passing it to the investigation workflow. Removing it clears the stored prompt.
    Name string
    A human-readable name for the alert rule.
    NotificationSettings Pulumiverse.Vercel.Inputs.CustomAlertRuleNotificationSettings
    Notification delivery settings stored on the rule. Notification destination links are managed with the vercel.AlertRuleSlackNotification and vercel.AlertRuleWebhookNotification resources.
    ProjectId string
    The project evaluated by this custom rule. Creating a rule or changing its query requires Observability Plus on this project.
    Severity string
    Severity assigned when the rule triggers: low, medium, or high. Critical severity is assigned only by a completed agent investigation.
    Tags List<string>
    Up to 10 unique tags used to organize the rule. Removing all tags clears them.
    TeamId string
    The ID of the team that owns the alert rule. Required if a default team is not configured in the provider.
    Trigger Pulumiverse.Vercel.Inputs.CustomAlertRuleTrigger
    A fixed threshold or anomaly condition on the query output.
    UpdatedAt int
    Last update time as a Unix epoch timestamp in milliseconds.
    CreatedAt int
    Creation time as a Unix epoch timestamp in milliseconds.
    Evaluation CustomAlertRuleEvaluationArgs
    The metric query and evaluation window.
    InvestigationPrompt string
    Optional guidance stored for agent investigations. The API currently stores this prompt without passing it to the investigation workflow. Removing it clears the stored prompt.
    Name string
    A human-readable name for the alert rule.
    NotificationSettings CustomAlertRuleNotificationSettingsArgs
    Notification delivery settings stored on the rule. Notification destination links are managed with the vercel.AlertRuleSlackNotification and vercel.AlertRuleWebhookNotification resources.
    ProjectId string
    The project evaluated by this custom rule. Creating a rule or changing its query requires Observability Plus on this project.
    Severity string
    Severity assigned when the rule triggers: low, medium, or high. Critical severity is assigned only by a completed agent investigation.
    Tags []string
    Up to 10 unique tags used to organize the rule. Removing all tags clears them.
    TeamId string
    The ID of the team that owns the alert rule. Required if a default team is not configured in the provider.
    Trigger CustomAlertRuleTriggerArgs
    A fixed threshold or anomaly condition on the query output.
    UpdatedAt int
    Last update time as a Unix epoch timestamp in milliseconds.
    created_at number
    Creation time as a Unix epoch timestamp in milliseconds.
    evaluation object
    The metric query and evaluation window.
    investigation_prompt string
    Optional guidance stored for agent investigations. The API currently stores this prompt without passing it to the investigation workflow. Removing it clears the stored prompt.
    name string
    A human-readable name for the alert rule.
    notification_settings object
    Notification delivery settings stored on the rule. Notification destination links are managed with the vercel.AlertRuleSlackNotification and vercel.AlertRuleWebhookNotification resources.
    project_id string
    The project evaluated by this custom rule. Creating a rule or changing its query requires Observability Plus on this project.
    severity string
    Severity assigned when the rule triggers: low, medium, or high. Critical severity is assigned only by a completed agent investigation.
    tags list(string)
    Up to 10 unique tags used to organize the rule. Removing all tags clears them.
    team_id string
    The ID of the team that owns the alert rule. Required if a default team is not configured in the provider.
    trigger object
    A fixed threshold or anomaly condition on the query output.
    updated_at number
    Last update time as a Unix epoch timestamp in milliseconds.
    createdAt Integer
    Creation time as a Unix epoch timestamp in milliseconds.
    evaluation CustomAlertRuleEvaluation
    The metric query and evaluation window.
    investigationPrompt String
    Optional guidance stored for agent investigations. The API currently stores this prompt without passing it to the investigation workflow. Removing it clears the stored prompt.
    name String
    A human-readable name for the alert rule.
    notificationSettings CustomAlertRuleNotificationSettings
    Notification delivery settings stored on the rule. Notification destination links are managed with the vercel.AlertRuleSlackNotification and vercel.AlertRuleWebhookNotification resources.
    projectId String
    The project evaluated by this custom rule. Creating a rule or changing its query requires Observability Plus on this project.
    severity String
    Severity assigned when the rule triggers: low, medium, or high. Critical severity is assigned only by a completed agent investigation.
    tags List<String>
    Up to 10 unique tags used to organize the rule. Removing all tags clears them.
    teamId String
    The ID of the team that owns the alert rule. Required if a default team is not configured in the provider.
    trigger CustomAlertRuleTrigger
    A fixed threshold or anomaly condition on the query output.
    updatedAt Integer
    Last update time as a Unix epoch timestamp in milliseconds.
    createdAt number
    Creation time as a Unix epoch timestamp in milliseconds.
    evaluation CustomAlertRuleEvaluation
    The metric query and evaluation window.
    investigationPrompt string
    Optional guidance stored for agent investigations. The API currently stores this prompt without passing it to the investigation workflow. Removing it clears the stored prompt.
    name string
    A human-readable name for the alert rule.
    notificationSettings CustomAlertRuleNotificationSettings
    Notification delivery settings stored on the rule. Notification destination links are managed with the vercel.AlertRuleSlackNotification and vercel.AlertRuleWebhookNotification resources.
    projectId string
    The project evaluated by this custom rule. Creating a rule or changing its query requires Observability Plus on this project.
    severity string
    Severity assigned when the rule triggers: low, medium, or high. Critical severity is assigned only by a completed agent investigation.
    tags string[]
    Up to 10 unique tags used to organize the rule. Removing all tags clears them.
    teamId string
    The ID of the team that owns the alert rule. Required if a default team is not configured in the provider.
    trigger CustomAlertRuleTrigger
    A fixed threshold or anomaly condition on the query output.
    updatedAt number
    Last update time as a Unix epoch timestamp in milliseconds.
    created_at int
    Creation time as a Unix epoch timestamp in milliseconds.
    evaluation CustomAlertRuleEvaluationArgs
    The metric query and evaluation window.
    investigation_prompt str
    Optional guidance stored for agent investigations. The API currently stores this prompt without passing it to the investigation workflow. Removing it clears the stored prompt.
    name str
    A human-readable name for the alert rule.
    notification_settings CustomAlertRuleNotificationSettingsArgs
    Notification delivery settings stored on the rule. Notification destination links are managed with the vercel.AlertRuleSlackNotification and vercel.AlertRuleWebhookNotification resources.
    project_id str
    The project evaluated by this custom rule. Creating a rule or changing its query requires Observability Plus on this project.
    severity str
    Severity assigned when the rule triggers: low, medium, or high. Critical severity is assigned only by a completed agent investigation.
    tags Sequence[str]
    Up to 10 unique tags used to organize the rule. Removing all tags clears them.
    team_id str
    The ID of the team that owns the alert rule. Required if a default team is not configured in the provider.
    trigger CustomAlertRuleTriggerArgs
    A fixed threshold or anomaly condition on the query output.
    updated_at int
    Last update time as a Unix epoch timestamp in milliseconds.
    createdAt Number
    Creation time as a Unix epoch timestamp in milliseconds.
    evaluation Property Map
    The metric query and evaluation window.
    investigationPrompt String
    Optional guidance stored for agent investigations. The API currently stores this prompt without passing it to the investigation workflow. Removing it clears the stored prompt.
    name String
    A human-readable name for the alert rule.
    notificationSettings Property Map
    Notification delivery settings stored on the rule. Notification destination links are managed with the vercel.AlertRuleSlackNotification and vercel.AlertRuleWebhookNotification resources.
    projectId String
    The project evaluated by this custom rule. Creating a rule or changing its query requires Observability Plus on this project.
    severity String
    Severity assigned when the rule triggers: low, medium, or high. Critical severity is assigned only by a completed agent investigation.
    tags List<String>
    Up to 10 unique tags used to organize the rule. Removing all tags clears them.
    teamId String
    The ID of the team that owns the alert rule. Required if a default team is not configured in the provider.
    trigger Property Map
    A fixed threshold or anomaly condition on the query output.
    updatedAt Number
    Last update time as a Unix epoch timestamp in milliseconds.

    Supporting Types

    CustomAlertRuleEvaluation, CustomAlertRuleEvaluationArgs

    Query Pulumiverse.Vercel.Inputs.CustomAlertRuleEvaluationQuery
    The structured Alerts v3 query. Use one metric without formulas, or two metrics with a division formula named formula. Discover supported metrics with vc metrics schema <metric-or-prefix>.
    Window string
    Aggregation granularity and detection cadence: 5m, 15m, 1h, or 1d.
    Query CustomAlertRuleEvaluationQuery
    The structured Alerts v3 query. Use one metric without formulas, or two metrics with a division formula named formula. Discover supported metrics with vc metrics schema <metric-or-prefix>.
    Window string
    Aggregation granularity and detection cadence: 5m, 15m, 1h, or 1d.
    query object
    The structured Alerts v3 query. Use one metric without formulas, or two metrics with a division formula named formula. Discover supported metrics with vc metrics schema <metric-or-prefix>.
    window string
    Aggregation granularity and detection cadence: 5m, 15m, 1h, or 1d.
    query CustomAlertRuleEvaluationQuery
    The structured Alerts v3 query. Use one metric without formulas, or two metrics with a division formula named formula. Discover supported metrics with vc metrics schema <metric-or-prefix>.
    window String
    Aggregation granularity and detection cadence: 5m, 15m, 1h, or 1d.
    query CustomAlertRuleEvaluationQuery
    The structured Alerts v3 query. Use one metric without formulas, or two metrics with a division formula named formula. Discover supported metrics with vc metrics schema <metric-or-prefix>.
    window string
    Aggregation granularity and detection cadence: 5m, 15m, 1h, or 1d.
    query CustomAlertRuleEvaluationQuery
    The structured Alerts v3 query. Use one metric without formulas, or two metrics with a division formula named formula. Discover supported metrics with vc metrics schema <metric-or-prefix>.
    window str
    Aggregation granularity and detection cadence: 5m, 15m, 1h, or 1d.
    query Property Map
    The structured Alerts v3 query. Use one metric without formulas, or two metrics with a division formula named formula. Discover supported metrics with vc metrics schema <metric-or-prefix>.
    window String
    Aggregation granularity and detection cadence: 5m, 15m, 1h, or 1d.

    CustomAlertRuleEvaluationQuery, CustomAlertRuleEvaluationQueryArgs

    Metrics Dictionary<string, Pulumiverse.Vercel.Inputs.CustomAlertRuleEvaluationQueryMetrics>
    One or two metric selections keyed by caller-chosen aliases. The alias formula is reserved.
    Outputs List<string>
    Exactly one output: the sole metric alias, or formula for a ratio.
    Filter string
    KQL filter. Syntax and metric dimensions are validated by the API.
    Formulas Dictionary<string, string>
    Optional division formula, keyed by formula, referencing the two metric aliases, for example errors / requests.
    GroupBies List<string>
    Optional grouping dimension. Exactly one dimension is supported.
    Metrics map[string]CustomAlertRuleEvaluationQueryMetrics
    One or two metric selections keyed by caller-chosen aliases. The alias formula is reserved.
    Outputs []string
    Exactly one output: the sole metric alias, or formula for a ratio.
    Filter string
    KQL filter. Syntax and metric dimensions are validated by the API.
    Formulas map[string]string
    Optional division formula, keyed by formula, referencing the two metric aliases, for example errors / requests.
    GroupBies []string
    Optional grouping dimension. Exactly one dimension is supported.
    metrics map(object)
    One or two metric selections keyed by caller-chosen aliases. The alias formula is reserved.
    outputs list(string)
    Exactly one output: the sole metric alias, or formula for a ratio.
    filter string
    KQL filter. Syntax and metric dimensions are validated by the API.
    formulas map(string)
    Optional division formula, keyed by formula, referencing the two metric aliases, for example errors / requests.
    group_bies list(string)
    Optional grouping dimension. Exactly one dimension is supported.
    metrics Map<String,CustomAlertRuleEvaluationQueryMetrics>
    One or two metric selections keyed by caller-chosen aliases. The alias formula is reserved.
    outputs List<String>
    Exactly one output: the sole metric alias, or formula for a ratio.
    filter String
    KQL filter. Syntax and metric dimensions are validated by the API.
    formulas Map<String,String>
    Optional division formula, keyed by formula, referencing the two metric aliases, for example errors / requests.
    groupBies List<String>
    Optional grouping dimension. Exactly one dimension is supported.
    metrics {[key: string]: CustomAlertRuleEvaluationQueryMetrics}
    One or two metric selections keyed by caller-chosen aliases. The alias formula is reserved.
    outputs string[]
    Exactly one output: the sole metric alias, or formula for a ratio.
    filter string
    KQL filter. Syntax and metric dimensions are validated by the API.
    formulas {[key: string]: string}
    Optional division formula, keyed by formula, referencing the two metric aliases, for example errors / requests.
    groupBies string[]
    Optional grouping dimension. Exactly one dimension is supported.
    metrics Mapping[str, CustomAlertRuleEvaluationQueryMetrics]
    One or two metric selections keyed by caller-chosen aliases. The alias formula is reserved.
    outputs Sequence[str]
    Exactly one output: the sole metric alias, or formula for a ratio.
    filter str
    KQL filter. Syntax and metric dimensions are validated by the API.
    formulas Mapping[str, str]
    Optional division formula, keyed by formula, referencing the two metric aliases, for example errors / requests.
    group_bies Sequence[str]
    Optional grouping dimension. Exactly one dimension is supported.
    metrics Map<Property Map>
    One or two metric selections keyed by caller-chosen aliases. The alias formula is reserved.
    outputs List<String>
    Exactly one output: the sole metric alias, or formula for a ratio.
    filter String
    KQL filter. Syntax and metric dimensions are validated by the API.
    formulas Map<String>
    Optional division formula, keyed by formula, referencing the two metric aliases, for example errors / requests.
    groupBies List<String>
    Optional grouping dimension. Exactly one dimension is supported.

    CustomAlertRuleEvaluationQueryMetrics, CustomAlertRuleEvaluationQueryMetricsArgs

    Aggregation string
    Metric aggregation. Supported combinations depend on the metric.
    Metric string
    Semantic metric ID or custom metric name. Availability is validated by the API.
    Dimensions List<string>
    Dimensions required by the unique aggregation.
    Filter string
    KQL filter. Syntax and metric dimensions are validated by the API.
    Normalize string
    Set to percent for percentage normalization. Only supported for count or sum; cannot be combined with per.
    Per string
    Set to second for a per-second rate. Only supported for count or sum; cannot be combined with normalize.
    Aggregation string
    Metric aggregation. Supported combinations depend on the metric.
    Metric string
    Semantic metric ID or custom metric name. Availability is validated by the API.
    Dimensions []string
    Dimensions required by the unique aggregation.
    Filter string
    KQL filter. Syntax and metric dimensions are validated by the API.
    Normalize string
    Set to percent for percentage normalization. Only supported for count or sum; cannot be combined with per.
    Per string
    Set to second for a per-second rate. Only supported for count or sum; cannot be combined with normalize.
    aggregation string
    Metric aggregation. Supported combinations depend on the metric.
    metric string
    Semantic metric ID or custom metric name. Availability is validated by the API.
    dimensions list(string)
    Dimensions required by the unique aggregation.
    filter string
    KQL filter. Syntax and metric dimensions are validated by the API.
    normalize string
    Set to percent for percentage normalization. Only supported for count or sum; cannot be combined with per.
    per string
    Set to second for a per-second rate. Only supported for count or sum; cannot be combined with normalize.
    aggregation String
    Metric aggregation. Supported combinations depend on the metric.
    metric String
    Semantic metric ID or custom metric name. Availability is validated by the API.
    dimensions List<String>
    Dimensions required by the unique aggregation.
    filter String
    KQL filter. Syntax and metric dimensions are validated by the API.
    normalize String
    Set to percent for percentage normalization. Only supported for count or sum; cannot be combined with per.
    per String
    Set to second for a per-second rate. Only supported for count or sum; cannot be combined with normalize.
    aggregation string
    Metric aggregation. Supported combinations depend on the metric.
    metric string
    Semantic metric ID or custom metric name. Availability is validated by the API.
    dimensions string[]
    Dimensions required by the unique aggregation.
    filter string
    KQL filter. Syntax and metric dimensions are validated by the API.
    normalize string
    Set to percent for percentage normalization. Only supported for count or sum; cannot be combined with per.
    per string
    Set to second for a per-second rate. Only supported for count or sum; cannot be combined with normalize.
    aggregation str
    Metric aggregation. Supported combinations depend on the metric.
    metric str
    Semantic metric ID or custom metric name. Availability is validated by the API.
    dimensions Sequence[str]
    Dimensions required by the unique aggregation.
    filter str
    KQL filter. Syntax and metric dimensions are validated by the API.
    normalize str
    Set to percent for percentage normalization. Only supported for count or sum; cannot be combined with per.
    per str
    Set to second for a per-second rate. Only supported for count or sum; cannot be combined with normalize.
    aggregation String
    Metric aggregation. Supported combinations depend on the metric.
    metric String
    Semantic metric ID or custom metric name. Availability is validated by the API.
    dimensions List<String>
    Dimensions required by the unique aggregation.
    filter String
    KQL filter. Syntax and metric dimensions are validated by the API.
    normalize String
    Set to percent for percentage normalization. Only supported for count or sum; cannot be combined with per.
    per String
    Set to second for a per-second rate. Only supported for count or sum; cannot be combined with normalize.

    CustomAlertRuleNotificationSettings, CustomAlertRuleNotificationSettingsArgs

    EnableTeamOwnerNotifications bool
    IncidentIoRoutingKey string
    VercelNotificationsMinimumSeverityLevel string
    Set to critical to send Vercel notifications only for alerts classified as Critical. Omit to send Vercel notifications for every severity.
    EnableTeamOwnerNotifications bool
    IncidentIoRoutingKey string
    VercelNotificationsMinimumSeverityLevel string
    Set to critical to send Vercel notifications only for alerts classified as Critical. Omit to send Vercel notifications for every severity.
    enable_team_owner_notifications bool
    incident_io_routing_key string
    vercel_notifications_minimum_severity_level string
    Set to critical to send Vercel notifications only for alerts classified as Critical. Omit to send Vercel notifications for every severity.
    enableTeamOwnerNotifications Boolean
    incidentIoRoutingKey String
    vercelNotificationsMinimumSeverityLevel String
    Set to critical to send Vercel notifications only for alerts classified as Critical. Omit to send Vercel notifications for every severity.
    enableTeamOwnerNotifications boolean
    incidentIoRoutingKey string
    vercelNotificationsMinimumSeverityLevel string
    Set to critical to send Vercel notifications only for alerts classified as Critical. Omit to send Vercel notifications for every severity.
    enable_team_owner_notifications bool
    incident_io_routing_key str
    vercel_notifications_minimum_severity_level str
    Set to critical to send Vercel notifications only for alerts classified as Critical. Omit to send Vercel notifications for every severity.
    enableTeamOwnerNotifications Boolean
    incidentIoRoutingKey String
    vercelNotificationsMinimumSeverityLevel String
    Set to critical to send Vercel notifications only for alerts classified as Critical. Omit to send Vercel notifications for every severity.

    CustomAlertRuleTrigger, CustomAlertRuleTriggerArgs

    Output string
    The query's single output alias.
    Type string
    The condition type: threshold or anomaly.
    Minimum Pulumiverse.Vercel.Inputs.CustomAlertRuleTriggerMinimum
    Optional evaluation floor. Allowed for anomalies or ratio thresholds using gt or gte.
    Operator string
    Required for threshold triggers; omitted for anomaly triggers.
    StandardDeviations double
    Required anomaly threshold in standard deviations, at least 0.1.
    Threshold double
    Required numeric threshold for threshold triggers. Zero is supported.
    Output string
    The query's single output alias.
    Type string
    The condition type: threshold or anomaly.
    Minimum CustomAlertRuleTriggerMinimum
    Optional evaluation floor. Allowed for anomalies or ratio thresholds using gt or gte.
    Operator string
    Required for threshold triggers; omitted for anomaly triggers.
    StandardDeviations float64
    Required anomaly threshold in standard deviations, at least 0.1.
    Threshold float64
    Required numeric threshold for threshold triggers. Zero is supported.
    output string
    The query's single output alias.
    type string
    The condition type: threshold or anomaly.
    minimum object
    Optional evaluation floor. Allowed for anomalies or ratio thresholds using gt or gte.
    operator string
    Required for threshold triggers; omitted for anomaly triggers.
    standard_deviations number
    Required anomaly threshold in standard deviations, at least 0.1.
    threshold number
    Required numeric threshold for threshold triggers. Zero is supported.
    output String
    The query's single output alias.
    type String
    The condition type: threshold or anomaly.
    minimum CustomAlertRuleTriggerMinimum
    Optional evaluation floor. Allowed for anomalies or ratio thresholds using gt or gte.
    operator String
    Required for threshold triggers; omitted for anomaly triggers.
    standardDeviations Double
    Required anomaly threshold in standard deviations, at least 0.1.
    threshold Double
    Required numeric threshold for threshold triggers. Zero is supported.
    output string
    The query's single output alias.
    type string
    The condition type: threshold or anomaly.
    minimum CustomAlertRuleTriggerMinimum
    Optional evaluation floor. Allowed for anomalies or ratio thresholds using gt or gte.
    operator string
    Required for threshold triggers; omitted for anomaly triggers.
    standardDeviations number
    Required anomaly threshold in standard deviations, at least 0.1.
    threshold number
    Required numeric threshold for threshold triggers. Zero is supported.
    output str
    The query's single output alias.
    type str
    The condition type: threshold or anomaly.
    minimum CustomAlertRuleTriggerMinimum
    Optional evaluation floor. Allowed for anomalies or ratio thresholds using gt or gte.
    operator str
    Required for threshold triggers; omitted for anomaly triggers.
    standard_deviations float
    Required anomaly threshold in standard deviations, at least 0.1.
    threshold float
    Required numeric threshold for threshold triggers. Zero is supported.
    output String
    The query's single output alias.
    type String
    The condition type: threshold or anomaly.
    minimum Property Map
    Optional evaluation floor. Allowed for anomalies or ratio thresholds using gt or gte.
    operator String
    Required for threshold triggers; omitted for anomaly triggers.
    standardDeviations Number
    Required anomaly threshold in standard deviations, at least 0.1.
    threshold Number
    Required numeric threshold for threshold triggers. Zero is supported.

    CustomAlertRuleTriggerMinimum, CustomAlertRuleTriggerMinimumArgs

    Output string
    The primitive metric alias, or ratio numerator alias.
    Threshold double
    Non-negative floor below which the rule is not evaluated.
    Output string
    The primitive metric alias, or ratio numerator alias.
    Threshold float64
    Non-negative floor below which the rule is not evaluated.
    output string
    The primitive metric alias, or ratio numerator alias.
    threshold number
    Non-negative floor below which the rule is not evaluated.
    output String
    The primitive metric alias, or ratio numerator alias.
    threshold Double
    Non-negative floor below which the rule is not evaluated.
    output string
    The primitive metric alias, or ratio numerator alias.
    threshold number
    Non-negative floor below which the rule is not evaluated.
    output str
    The primitive metric alias, or ratio numerator alias.
    threshold float
    Non-negative floor below which the rule is not evaluated.
    output String
    The primitive metric alias, or ratio numerator alias.
    threshold Number
    Non-negative floor below which the rule is not evaluated.

    Import

    Include the team ID, or omit it when the provider has a default team.

    $ pulumi import vercel:index/customAlertRule:CustomAlertRule checkout_errors team_123/ar_123
$ pulumi import vercel:index/customAlertRule:CustomAlertRule checkout_errors ar_123

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

    Package Details

    Repository
    vercel pulumiverse/pulumi-vercel
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the vercel Terraform Provider.
    vercel logo vercel logo
    Viewing docs for Vercel v5.21.1
    published on Thursday, Oct 15, 2026 by Pulumiverse
    Schema (JSON)
    pulumiverse/pulumi-vercel

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial