Docs Packages
  1. Packages
  2. New Relic
  3. API Docs
  4. getServiceLevelAlertHelper
New Relic v5.23.1 published on Friday, Apr 26, 2024 by Pulumi
pulumi/pulumi-newrelic

newrelic.getServiceLevelAlertHelper

Explore with Pulumi AI

newrelic logo
New Relic v5.23.1 published on Friday, Apr 26, 2024 by Pulumi
pulumi/pulumi-newrelic

    Use this data source to obtain the necessary fields to set up alerts on your service levels. It can be used for a custom alert_type in order to set up an alert with custom tolerated budget consumption and custom evaluation period or for recommended ones like fast_burn or slow_burn. For more information check the documentation.

    Example Usage

    Firstly set up your service level objective, we recommend using local variables for the target and time_window.rolling.count, as they are also necessary for the helper.

    import * as pulumi from "@pulumi/pulumi";
import * as newrelic from "@pulumi/newrelic";

const fooTarget = 99.9;
const fooPeriod = 28;
const foo = new newrelic.ServiceLevel("foo", {
    guid: "MXxBUE18QVBQTElDQVRJT058MQ",
    name: "Latency",
    description: "Proportion of requests that are served faster than a threshold.",
    events: {
        accountId: 12345678,
        validEvents: {
            from: "Transaction",
            where: "appName = 'Example application' AND (transactionType='Web')",
        },
        badEvents: {
            from: "Transaction",
            where: "appName = 'Example application' AND (transactionType= 'Web') AND duration > 0.1",
        },
    },
    objective: {
        target: fooTarget,
        timeWindow: {
            rolling: {
                count: fooPeriod,
                unit: "DAY",
            },
        },
    },
});

    import pulumi
import pulumi_newrelic as newrelic

foo_target = 99.9
foo_period = 28
foo = newrelic.ServiceLevel("foo",
    guid="MXxBUE18QVBQTElDQVRJT058MQ",
    name="Latency",
    description="Proportion of requests that are served faster than a threshold.",
    events=newrelic.ServiceLevelEventsArgs(
        account_id=12345678,
        valid_events=newrelic.ServiceLevelEventsValidEventsArgs(
            from_="Transaction",
            where="appName = 'Example application' AND (transactionType='Web')",
        ),
        bad_events=newrelic.ServiceLevelEventsBadEventsArgs(
            from_="Transaction",
            where="appName = 'Example application' AND (transactionType= 'Web') AND duration > 0.1",
        ),
    ),
    objective=newrelic.ServiceLevelObjectiveArgs(
        target=foo_target,
        time_window=newrelic.ServiceLevelObjectiveTimeWindowArgs(
            rolling=newrelic.ServiceLevelObjectiveTimeWindowRollingArgs(
                count=foo_period,
                unit="DAY",
            ),
        ),
    ))

    package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		fooTarget := 99.9
		fooPeriod := 28
		_, err := newrelic.NewServiceLevel(ctx, "foo", &newrelic.ServiceLevelArgs{
			Guid:        pulumi.String("MXxBUE18QVBQTElDQVRJT058MQ"),
			Name:        pulumi.String("Latency"),
			Description: pulumi.String("Proportion of requests that are served faster than a threshold."),
			Events: &newrelic.ServiceLevelEventsArgs{
				AccountId: pulumi.Int(12345678),
				ValidEvents: &newrelic.ServiceLevelEventsValidEventsArgs{
					From:  pulumi.String("Transaction"),
					Where: pulumi.String("appName = 'Example application' AND (transactionType='Web')"),
				},
				BadEvents: &newrelic.ServiceLevelEventsBadEventsArgs{
					From:  pulumi.String("Transaction"),
					Where: pulumi.String("appName = 'Example application' AND (transactionType= 'Web') AND duration > 0.1"),
				},
			},
			Objective: &newrelic.ServiceLevelObjectiveArgs{
				Target: pulumi.Float64(fooTarget),
				TimeWindow: &newrelic.ServiceLevelObjectiveTimeWindowArgs{
					Rolling: &newrelic.ServiceLevelObjectiveTimeWindowRollingArgs{
						Count: pulumi.Float64(fooPeriod),
						Unit:  pulumi.String("DAY"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using NewRelic = Pulumi.NewRelic;

return await Deployment.RunAsync(() => 
{
    var fooTarget = 99.9;

    var fooPeriod = 28;

    var foo = new NewRelic.ServiceLevel("foo", new()
    {
        Guid = "MXxBUE18QVBQTElDQVRJT058MQ",
        Name = "Latency",
        Description = "Proportion of requests that are served faster than a threshold.",
        Events = new NewRelic.Inputs.ServiceLevelEventsArgs
        {
            AccountId = 12345678,
            ValidEvents = new NewRelic.Inputs.ServiceLevelEventsValidEventsArgs
            {
                From = "Transaction",
                Where = "appName = 'Example application' AND (transactionType='Web')",
            },
            BadEvents = new NewRelic.Inputs.ServiceLevelEventsBadEventsArgs
            {
                From = "Transaction",
                Where = "appName = 'Example application' AND (transactionType= 'Web') AND duration > 0.1",
            },
        },
        Objective = new NewRelic.Inputs.ServiceLevelObjectiveArgs
        {
            Target = fooTarget,
            TimeWindow = new NewRelic.Inputs.ServiceLevelObjectiveTimeWindowArgs
            {
                Rolling = new NewRelic.Inputs.ServiceLevelObjectiveTimeWindowRollingArgs
                {
                    Count = fooPeriod,
                    Unit = "DAY",
                },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.ServiceLevel;
import com.pulumi.newrelic.ServiceLevelArgs;
import com.pulumi.newrelic.inputs.ServiceLevelEventsArgs;
import com.pulumi.newrelic.inputs.ServiceLevelEventsValidEventsArgs;
import com.pulumi.newrelic.inputs.ServiceLevelEventsBadEventsArgs;
import com.pulumi.newrelic.inputs.ServiceLevelObjectiveArgs;
import com.pulumi.newrelic.inputs.ServiceLevelObjectiveTimeWindowArgs;
import com.pulumi.newrelic.inputs.ServiceLevelObjectiveTimeWindowRollingArgs;
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 fooTarget = 99.9;

        final var fooPeriod = 28;

        var foo = new ServiceLevel("foo", ServiceLevelArgs.builder()        
            .guid("MXxBUE18QVBQTElDQVRJT058MQ")
            .name("Latency")
            .description("Proportion of requests that are served faster than a threshold.")
            .events(ServiceLevelEventsArgs.builder()
                .accountId(12345678)
                .validEvents(ServiceLevelEventsValidEventsArgs.builder()
                    .from("Transaction")
                    .where("appName = 'Example application' AND (transactionType='Web')")
                    .build())
                .badEvents(ServiceLevelEventsBadEventsArgs.builder()
                    .from("Transaction")
                    .where("appName = 'Example application' AND (transactionType= 'Web') AND duration > 0.1")
                    .build())
                .build())
            .objective(ServiceLevelObjectiveArgs.builder()
                .target(fooTarget)
                .timeWindow(ServiceLevelObjectiveTimeWindowArgs.builder()
                    .rolling(ServiceLevelObjectiveTimeWindowRollingArgs.builder()
                        .count(fooPeriod)
                        .unit("DAY")
                        .build())
                    .build())
                .build())
            .build());

    }
}

    resources:
  foo:
    type: newrelic:ServiceLevel
    properties:
      guid: MXxBUE18QVBQTElDQVRJT058MQ
      name: Latency
      description: Proportion of requests that are served faster than a threshold.
      events:
        accountId: 1.2345678e+07
        validEvents:
          from: Transaction
          where: appName = 'Example application' AND (transactionType='Web')
        badEvents:
          from: Transaction
          where: appName = 'Example application' AND (transactionType= 'Web') AND duration > 0.1
      objective:
        target: ${fooTarget}
        timeWindow:
          rolling:
            count: ${fooPeriod}
            unit: DAY
variables:
  fooTarget: 99.9
  fooPeriod: 28

    Then use the helper to obtain the necessary fields to set up an alert on that Service Level. Note that the Service Level was set up using bad events, that’s why is_bad_events is set to true. If the Service Level was configured with good events that would be unnecessary as the field defaults to false.

    Here is an example of a slow_burn alert.

    import * as pulumi from "@pulumi/pulumi";
import * as newrelic from "@pulumi/newrelic";

const fooSlowBurn = newrelic.getServiceLevelAlertHelper({
    alertType: "slow_burn",
    sliGuid: foo.sliGuid,
    sloTarget: fooTarget,
    sloPeriod: fooPeriod,
    isBadEvents: true,
});
const yourCondition = new newrelic.NrqlAlertCondition("your_condition", {
    accountId: 12345678,
    policyId: 67890,
    type: "static",
    name: "Slow burn alert",
    enabled: true,
    violationTimeLimitSeconds: 259200,
    nrql: {
        query: fooSlowBurn.then(fooSlowBurn => fooSlowBurn.nrql),
    },
    critical: {
        operator: "above_or_equals",
        threshold: fooSlowBurn.then(fooSlowBurn => fooSlowBurn.threshold),
        thresholdDuration: 900,
        thresholdOccurrences: "at_least_once",
    },
    fillOption: "none",
    aggregationWindow: fooSlowBurn.then(fooSlowBurn => fooSlowBurn.evaluationPeriod),
    aggregationMethod: "event_flow",
    aggregationDelay: "120",
    slideBy: 900,
});

    import pulumi
import pulumi_newrelic as newrelic

foo_slow_burn = newrelic.get_service_level_alert_helper(alert_type="slow_burn",
    sli_guid=foo["sliGuid"],
    slo_target=foo_target,
    slo_period=foo_period,
    is_bad_events=True)
your_condition = newrelic.NrqlAlertCondition("your_condition",
    account_id=12345678,
    policy_id=67890,
    type="static",
    name="Slow burn alert",
    enabled=True,
    violation_time_limit_seconds=259200,
    nrql=newrelic.NrqlAlertConditionNrqlArgs(
        query=foo_slow_burn.nrql,
    ),
    critical=newrelic.NrqlAlertConditionCriticalArgs(
        operator="above_or_equals",
        threshold=foo_slow_burn.threshold,
        threshold_duration=900,
        threshold_occurrences="at_least_once",
    ),
    fill_option="none",
    aggregation_window=foo_slow_burn.evaluation_period,
    aggregation_method="event_flow",
    aggregation_delay="120",
    slide_by=900)

    package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		fooSlowBurn, err := newrelic.GetServiceLevelAlertHelper(ctx, &newrelic.GetServiceLevelAlertHelperArgs{
			AlertType:   "slow_burn",
			SliGuid:     foo.SliGuid,
			SloTarget:   fooTarget,
			SloPeriod:   fooPeriod,
			IsBadEvents: pulumi.BoolRef(true),
		}, nil)
		if err != nil {
			return err
		}
		_, err = newrelic.NewNrqlAlertCondition(ctx, "your_condition", &newrelic.NrqlAlertConditionArgs{
			AccountId:                 pulumi.Int(12345678),
			PolicyId:                  pulumi.Int(67890),
			Type:                      pulumi.String("static"),
			Name:                      pulumi.String("Slow burn alert"),
			Enabled:                   pulumi.Bool(true),
			ViolationTimeLimitSeconds: pulumi.Int(259200),
			Nrql: &newrelic.NrqlAlertConditionNrqlArgs{
				Query: pulumi.String(fooSlowBurn.Nrql),
			},
			Critical: &newrelic.NrqlAlertConditionCriticalArgs{
				Operator:             pulumi.String("above_or_equals"),
				Threshold:            pulumi.Float64(fooSlowBurn.Threshold),
				ThresholdDuration:    pulumi.Int(900),
				ThresholdOccurrences: pulumi.String("at_least_once"),
			},
			FillOption:        pulumi.String("none"),
			AggregationWindow: pulumi.Int(fooSlowBurn.EvaluationPeriod),
			AggregationMethod: pulumi.String("event_flow"),
			AggregationDelay:  pulumi.String("120"),
			SlideBy:           pulumi.Int(900),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using NewRelic = Pulumi.NewRelic;

return await Deployment.RunAsync(() => 
{
    var fooSlowBurn = NewRelic.GetServiceLevelAlertHelper.Invoke(new()
    {
        AlertType = "slow_burn",
        SliGuid = foo.SliGuid,
        SloTarget = fooTarget,
        SloPeriod = fooPeriod,
        IsBadEvents = true,
    });

    var yourCondition = new NewRelic.NrqlAlertCondition("your_condition", new()
    {
        AccountId = 12345678,
        PolicyId = 67890,
        Type = "static",
        Name = "Slow burn alert",
        Enabled = true,
        ViolationTimeLimitSeconds = 259200,
        Nrql = new NewRelic.Inputs.NrqlAlertConditionNrqlArgs
        {
            Query = fooSlowBurn.Apply(getServiceLevelAlertHelperResult => getServiceLevelAlertHelperResult.Nrql),
        },
        Critical = new NewRelic.Inputs.NrqlAlertConditionCriticalArgs
        {
            Operator = "above_or_equals",
            Threshold = fooSlowBurn.Apply(getServiceLevelAlertHelperResult => getServiceLevelAlertHelperResult.Threshold),
            ThresholdDuration = 900,
            ThresholdOccurrences = "at_least_once",
        },
        FillOption = "none",
        AggregationWindow = fooSlowBurn.Apply(getServiceLevelAlertHelperResult => getServiceLevelAlertHelperResult.EvaluationPeriod),
        AggregationMethod = "event_flow",
        AggregationDelay = "120",
        SlideBy = 900,
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.NewrelicFunctions;
import com.pulumi.newrelic.inputs.GetServiceLevelAlertHelperArgs;
import com.pulumi.newrelic.NrqlAlertCondition;
import com.pulumi.newrelic.NrqlAlertConditionArgs;
import com.pulumi.newrelic.inputs.NrqlAlertConditionNrqlArgs;
import com.pulumi.newrelic.inputs.NrqlAlertConditionCriticalArgs;
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 fooSlowBurn = NewrelicFunctions.getServiceLevelAlertHelper(GetServiceLevelAlertHelperArgs.builder()
            .alertType("slow_burn")
            .sliGuid(foo.sliGuid())
            .sloTarget(fooTarget)
            .sloPeriod(fooPeriod)
            .isBadEvents(true)
            .build());

        var yourCondition = new NrqlAlertCondition("yourCondition", NrqlAlertConditionArgs.builder()        
            .accountId(12345678)
            .policyId(67890)
            .type("static")
            .name("Slow burn alert")
            .enabled(true)
            .violationTimeLimitSeconds(259200)
            .nrql(NrqlAlertConditionNrqlArgs.builder()
                .query(fooSlowBurn.applyValue(getServiceLevelAlertHelperResult -> getServiceLevelAlertHelperResult.nrql()))
                .build())
            .critical(NrqlAlertConditionCriticalArgs.builder()
                .operator("above_or_equals")
                .threshold(fooSlowBurn.applyValue(getServiceLevelAlertHelperResult -> getServiceLevelAlertHelperResult.threshold()))
                .thresholdDuration(900)
                .thresholdOccurrences("at_least_once")
                .build())
            .fillOption("none")
            .aggregationWindow(fooSlowBurn.applyValue(getServiceLevelAlertHelperResult -> getServiceLevelAlertHelperResult.evaluationPeriod()))
            .aggregationMethod("event_flow")
            .aggregationDelay(120)
            .slideBy(900)
            .build());

    }
}

    resources:
  yourCondition:
    type: newrelic:NrqlAlertCondition
    name: your_condition
    properties:
      accountId: 1.2345678e+07
      policyId: 67890
      type: static
      name: Slow burn alert
      enabled: true
      violationTimeLimitSeconds: 259200
      nrql:
        query: ${fooSlowBurn.nrql}
      critical:
        operator: above_or_equals
        threshold: ${fooSlowBurn.threshold}
        thresholdDuration: 900
        thresholdOccurrences: at_least_once
      fillOption: none
      aggregationWindow: ${fooSlowBurn.evaluationPeriod}
      aggregationMethod: event_flow
      aggregationDelay: 120
      slideBy: 900
variables:
  fooSlowBurn:
    fn::invoke:
      Function: newrelic:getServiceLevelAlertHelper
      Arguments:
        alertType: slow_burn
        sliGuid: ${foo.sliGuid}
        sloTarget: ${fooTarget}
        sloPeriod: ${fooPeriod}
        isBadEvents: true

    Here is an example of a custom alert:

    import * as pulumi from "@pulumi/pulumi";
import * as newrelic from "@pulumi/newrelic";

const fooCustom = newrelic.getServiceLevelAlertHelper({
    alertType: "custom",
    sliGuid: foo.sliGuid,
    sloTarget: fooTarget,
    sloPeriod: fooPeriod,
    customToleratedBudgetConsumption: 4,
    customEvaluationPeriod: 5400,
    isBadEvents: true,
});
const yourCondition = new newrelic.NrqlAlertCondition("your_condition", {
    accountId: 12345678,
    policyId: 67890,
    type: "static",
    name: "Custom burn alert",
    enabled: true,
    violationTimeLimitSeconds: 259200,
    nrql: {
        query: fooCustom.then(fooCustom => fooCustom.nrql),
    },
    critical: {
        operator: "above_or_equals",
        threshold: fooCustom.then(fooCustom => fooCustom.threshold),
        thresholdDuration: 900,
        thresholdOccurrences: "at_least_once",
    },
    fillOption: "none",
    aggregationWindow: fooCustom.then(fooCustom => fooCustom.evaluationPeriod),
    aggregationMethod: "event_flow",
    aggregationDelay: "120",
    slideBy: 60,
});

    import pulumi
import pulumi_newrelic as newrelic

foo_custom = newrelic.get_service_level_alert_helper(alert_type="custom",
    sli_guid=foo["sliGuid"],
    slo_target=foo_target,
    slo_period=foo_period,
    custom_tolerated_budget_consumption=4,
    custom_evaluation_period=5400,
    is_bad_events=True)
your_condition = newrelic.NrqlAlertCondition("your_condition",
    account_id=12345678,
    policy_id=67890,
    type="static",
    name="Custom burn alert",
    enabled=True,
    violation_time_limit_seconds=259200,
    nrql=newrelic.NrqlAlertConditionNrqlArgs(
        query=foo_custom.nrql,
    ),
    critical=newrelic.NrqlAlertConditionCriticalArgs(
        operator="above_or_equals",
        threshold=foo_custom.threshold,
        threshold_duration=900,
        threshold_occurrences="at_least_once",
    ),
    fill_option="none",
    aggregation_window=foo_custom.evaluation_period,
    aggregation_method="event_flow",
    aggregation_delay="120",
    slide_by=60)

    package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		fooCustom, err := newrelic.GetServiceLevelAlertHelper(ctx, &newrelic.GetServiceLevelAlertHelperArgs{
			AlertType:                        "custom",
			SliGuid:                          foo.SliGuid,
			SloTarget:                        fooTarget,
			SloPeriod:                        fooPeriod,
			CustomToleratedBudgetConsumption: pulumi.Float64Ref(4),
			CustomEvaluationPeriod:           pulumi.IntRef(5400),
			IsBadEvents:                      pulumi.BoolRef(true),
		}, nil)
		if err != nil {
			return err
		}
		_, err = newrelic.NewNrqlAlertCondition(ctx, "your_condition", &newrelic.NrqlAlertConditionArgs{
			AccountId:                 pulumi.Int(12345678),
			PolicyId:                  pulumi.Int(67890),
			Type:                      pulumi.String("static"),
			Name:                      pulumi.String("Custom burn alert"),
			Enabled:                   pulumi.Bool(true),
			ViolationTimeLimitSeconds: pulumi.Int(259200),
			Nrql: &newrelic.NrqlAlertConditionNrqlArgs{
				Query: pulumi.String(fooCustom.Nrql),
			},
			Critical: &newrelic.NrqlAlertConditionCriticalArgs{
				Operator:             pulumi.String("above_or_equals"),
				Threshold:            pulumi.Float64(fooCustom.Threshold),
				ThresholdDuration:    pulumi.Int(900),
				ThresholdOccurrences: pulumi.String("at_least_once"),
			},
			FillOption:        pulumi.String("none"),
			AggregationWindow: pulumi.Int(fooCustom.EvaluationPeriod),
			AggregationMethod: pulumi.String("event_flow"),
			AggregationDelay:  pulumi.String("120"),
			SlideBy:           pulumi.Int(60),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using NewRelic = Pulumi.NewRelic;

return await Deployment.RunAsync(() => 
{
    var fooCustom = NewRelic.GetServiceLevelAlertHelper.Invoke(new()
    {
        AlertType = "custom",
        SliGuid = foo.SliGuid,
        SloTarget = fooTarget,
        SloPeriod = fooPeriod,
        CustomToleratedBudgetConsumption = 4,
        CustomEvaluationPeriod = 5400,
        IsBadEvents = true,
    });

    var yourCondition = new NewRelic.NrqlAlertCondition("your_condition", new()
    {
        AccountId = 12345678,
        PolicyId = 67890,
        Type = "static",
        Name = "Custom burn alert",
        Enabled = true,
        ViolationTimeLimitSeconds = 259200,
        Nrql = new NewRelic.Inputs.NrqlAlertConditionNrqlArgs
        {
            Query = fooCustom.Apply(getServiceLevelAlertHelperResult => getServiceLevelAlertHelperResult.Nrql),
        },
        Critical = new NewRelic.Inputs.NrqlAlertConditionCriticalArgs
        {
            Operator = "above_or_equals",
            Threshold = fooCustom.Apply(getServiceLevelAlertHelperResult => getServiceLevelAlertHelperResult.Threshold),
            ThresholdDuration = 900,
            ThresholdOccurrences = "at_least_once",
        },
        FillOption = "none",
        AggregationWindow = fooCustom.Apply(getServiceLevelAlertHelperResult => getServiceLevelAlertHelperResult.EvaluationPeriod),
        AggregationMethod = "event_flow",
        AggregationDelay = "120",
        SlideBy = 60,
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.NewrelicFunctions;
import com.pulumi.newrelic.inputs.GetServiceLevelAlertHelperArgs;
import com.pulumi.newrelic.NrqlAlertCondition;
import com.pulumi.newrelic.NrqlAlertConditionArgs;
import com.pulumi.newrelic.inputs.NrqlAlertConditionNrqlArgs;
import com.pulumi.newrelic.inputs.NrqlAlertConditionCriticalArgs;
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 fooCustom = NewrelicFunctions.getServiceLevelAlertHelper(GetServiceLevelAlertHelperArgs.builder()
            .alertType("custom")
            .sliGuid(foo.sliGuid())
            .sloTarget(fooTarget)
            .sloPeriod(fooPeriod)
            .customToleratedBudgetConsumption(4)
            .customEvaluationPeriod(5400)
            .isBadEvents(true)
            .build());

        var yourCondition = new NrqlAlertCondition("yourCondition", NrqlAlertConditionArgs.builder()        
            .accountId(12345678)
            .policyId(67890)
            .type("static")
            .name("Custom burn alert")
            .enabled(true)
            .violationTimeLimitSeconds(259200)
            .nrql(NrqlAlertConditionNrqlArgs.builder()
                .query(fooCustom.applyValue(getServiceLevelAlertHelperResult -> getServiceLevelAlertHelperResult.nrql()))
                .build())
            .critical(NrqlAlertConditionCriticalArgs.builder()
                .operator("above_or_equals")
                .threshold(fooCustom.applyValue(getServiceLevelAlertHelperResult -> getServiceLevelAlertHelperResult.threshold()))
                .thresholdDuration(900)
                .thresholdOccurrences("at_least_once")
                .build())
            .fillOption("none")
            .aggregationWindow(fooCustom.applyValue(getServiceLevelAlertHelperResult -> getServiceLevelAlertHelperResult.evaluationPeriod()))
            .aggregationMethod("event_flow")
            .aggregationDelay(120)
            .slideBy(60)
            .build());

    }
}

    resources:
  yourCondition:
    type: newrelic:NrqlAlertCondition
    name: your_condition
    properties:
      accountId: 1.2345678e+07
      policyId: 67890
      type: static
      name: Custom burn alert
      enabled: true
      violationTimeLimitSeconds: 259200
      nrql:
        query: ${fooCustom.nrql}
      critical:
        operator: above_or_equals
        threshold: ${fooCustom.threshold}
        thresholdDuration: 900
        thresholdOccurrences: at_least_once
      fillOption: none
      aggregationWindow: ${fooCustom.evaluationPeriod}
      aggregationMethod: event_flow
      aggregationDelay: 120
      slideBy: 60
variables:
  fooCustom:
    fn::invoke:
      Function: newrelic:getServiceLevelAlertHelper
      Arguments:
        alertType: custom
        sliGuid: ${foo.sliGuid}
        sloTarget: ${fooTarget}
        sloPeriod: ${fooPeriod}
        customToleratedBudgetConsumption: 4
        customEvaluationPeriod: 5400
        isBadEvents: true

    Using getServiceLevelAlertHelper

    Two invocation forms are available. The direct form accepts plain arguments and either blocks until the result value is available, or returns a Promise-wrapped result. The output form accepts Input-wrapped arguments and returns an Output-wrapped result.

    function getServiceLevelAlertHelper(args: GetServiceLevelAlertHelperArgs, opts?: InvokeOptions): Promise<GetServiceLevelAlertHelperResult>
function getServiceLevelAlertHelperOutput(args: GetServiceLevelAlertHelperOutputArgs, opts?: InvokeOptions): Output<GetServiceLevelAlertHelperResult>
    def get_service_level_alert_helper(alert_type: Optional[str] = None,
                                   custom_evaluation_period: Optional[int] = None,
                                   custom_tolerated_budget_consumption: Optional[float] = None,
                                   is_bad_events: Optional[bool] = None,
                                   sli_guid: Optional[str] = None,
                                   slo_period: Optional[int] = None,
                                   slo_target: Optional[float] = None,
                                   opts: Optional[InvokeOptions] = None) -> GetServiceLevelAlertHelperResult
def get_service_level_alert_helper_output(alert_type: Optional[pulumi.Input[str]] = None,
                                   custom_evaluation_period: Optional[pulumi.Input[int]] = None,
                                   custom_tolerated_budget_consumption: Optional[pulumi.Input[float]] = None,
                                   is_bad_events: Optional[pulumi.Input[bool]] = None,
                                   sli_guid: Optional[pulumi.Input[str]] = None,
                                   slo_period: Optional[pulumi.Input[int]] = None,
                                   slo_target: Optional[pulumi.Input[float]] = None,
                                   opts: Optional[InvokeOptions] = None) -> Output[GetServiceLevelAlertHelperResult]
    func GetServiceLevelAlertHelper(ctx *Context, args *GetServiceLevelAlertHelperArgs, opts ...InvokeOption) (*GetServiceLevelAlertHelperResult, error)
func GetServiceLevelAlertHelperOutput(ctx *Context, args *GetServiceLevelAlertHelperOutputArgs, opts ...InvokeOption) GetServiceLevelAlertHelperResultOutput

    > Note: This function is named GetServiceLevelAlertHelper in the Go SDK.

    public static class GetServiceLevelAlertHelper 
{
    public static Task<GetServiceLevelAlertHelperResult> InvokeAsync(GetServiceLevelAlertHelperArgs args, InvokeOptions? opts = null)
    public static Output<GetServiceLevelAlertHelperResult> Invoke(GetServiceLevelAlertHelperInvokeArgs args, InvokeOptions? opts = null)
}
    public static CompletableFuture<GetServiceLevelAlertHelperResult> getServiceLevelAlertHelper(GetServiceLevelAlertHelperArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

    fn::invoke:
  function: newrelic:index/getServiceLevelAlertHelper:getServiceLevelAlertHelper
  arguments:
    # arguments dictionary

    The following arguments are supported:

    getServiceLevelAlertHelper Result

    The following output properties are available:

    AlertType string
    EvaluationPeriod int
    (Computed) For non custom alert_type, this is the recommended for that type of alert. For custom alert_type it has the same value as custom_evaluation_period.
    Id string
    The provider-assigned unique ID for this managed resource.
    Nrql string
    (Computed) The nrql query for the selected type of alert.
    SliGuid string
    SloPeriod int
    SloTarget double
    Threshold double
    (Computed) The computed threshold given the provided arguments.
    ToleratedBudgetConsumption double
    (Computed) For non custom alert_type, this is the recommended for that type of alert. For custom alert_type it has the same value as custom_tolerated_budget_consumption.
    CustomEvaluationPeriod int
    CustomToleratedBudgetConsumption double
    IsBadEvents bool
    AlertType string
    EvaluationPeriod int
    (Computed) For non custom alert_type, this is the recommended for that type of alert. For custom alert_type it has the same value as custom_evaluation_period.
    Id string
    The provider-assigned unique ID for this managed resource.
    Nrql string
    (Computed) The nrql query for the selected type of alert.
    SliGuid string
    SloPeriod int
    SloTarget float64
    Threshold float64
    (Computed) The computed threshold given the provided arguments.
    ToleratedBudgetConsumption float64
    (Computed) For non custom alert_type, this is the recommended for that type of alert. For custom alert_type it has the same value as custom_tolerated_budget_consumption.
    CustomEvaluationPeriod int
    CustomToleratedBudgetConsumption float64
    IsBadEvents bool
    alertType String
    evaluationPeriod Integer
    (Computed) For non custom alert_type, this is the recommended for that type of alert. For custom alert_type it has the same value as custom_evaluation_period.
    id String
    The provider-assigned unique ID for this managed resource.
    nrql String
    (Computed) The nrql query for the selected type of alert.
    sliGuid String
    sloPeriod Integer
    sloTarget Double
    threshold Double
    (Computed) The computed threshold given the provided arguments.
    toleratedBudgetConsumption Double
    (Computed) For non custom alert_type, this is the recommended for that type of alert. For custom alert_type it has the same value as custom_tolerated_budget_consumption.
    customEvaluationPeriod Integer
    customToleratedBudgetConsumption Double
    isBadEvents Boolean
    alertType string
    evaluationPeriod number
    (Computed) For non custom alert_type, this is the recommended for that type of alert. For custom alert_type it has the same value as custom_evaluation_period.
    id string
    The provider-assigned unique ID for this managed resource.
    nrql string
    (Computed) The nrql query for the selected type of alert.
    sliGuid string
    sloPeriod number
    sloTarget number
    threshold number
    (Computed) The computed threshold given the provided arguments.
    toleratedBudgetConsumption number
    (Computed) For non custom alert_type, this is the recommended for that type of alert. For custom alert_type it has the same value as custom_tolerated_budget_consumption.
    customEvaluationPeriod number
    customToleratedBudgetConsumption number
    isBadEvents boolean
    alert_type str
    evaluation_period int
    (Computed) For non custom alert_type, this is the recommended for that type of alert. For custom alert_type it has the same value as custom_evaluation_period.
    id str
    The provider-assigned unique ID for this managed resource.
    nrql str
    (Computed) The nrql query for the selected type of alert.
    sli_guid str
    slo_period int
    slo_target float
    threshold float
    (Computed) The computed threshold given the provided arguments.
    tolerated_budget_consumption float
    (Computed) For non custom alert_type, this is the recommended for that type of alert. For custom alert_type it has the same value as custom_tolerated_budget_consumption.
    custom_evaluation_period int
    custom_tolerated_budget_consumption float
    is_bad_events bool
    alertType String
    evaluationPeriod Number
    (Computed) For non custom alert_type, this is the recommended for that type of alert. For custom alert_type it has the same value as custom_evaluation_period.
    id String
    The provider-assigned unique ID for this managed resource.
    nrql String
    (Computed) The nrql query for the selected type of alert.
    sliGuid String
    sloPeriod Number
    sloTarget Number
    threshold Number
    (Computed) The computed threshold given the provided arguments.
    toleratedBudgetConsumption Number
    (Computed) For non custom alert_type, this is the recommended for that type of alert. For custom alert_type it has the same value as custom_tolerated_budget_consumption.
    customEvaluationPeriod Number
    customToleratedBudgetConsumption Number
    isBadEvents Boolean

    Package Details

    Repository
    New Relic pulumi/pulumi-newrelic
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the newrelic Terraform Provider.
    newrelic logo
    New Relic v5.23.1 published on Friday, Apr 26, 2024 by Pulumi
    pulumi/pulumi-newrelic