pulumi-newrelic 5.16.0a1698964311__py3-none-any.whl → 5.58.0a1763707205__py3-none-any.whl

pulumi_newrelic/get_service_level_alert_helper.py

@@ -1,12 +1,17 @@
 # coding=utf-8
-# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
+# *** WARNING: this file was generated by pulumi-language-python. ***
 # *** Do not edit by hand unless you're certain you know what you are doing! ***
 
-import copy
+import builtins as _builtins
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from . import _utilities
 
 __all__ = [
@@ -59,76 +64,76 @@ class GetServiceLevelAlertHelperResult:
             raise TypeError("Expected argument 'tolerated_budget_consumption' to be a float")
         pulumi.set(__self__, "tolerated_budget_consumption", tolerated_budget_consumption)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="alertType")
-    def alert_type(self) -> str:
+    def alert_type(self) -> _builtins.str:
         return pulumi.get(self, "alert_type")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="customEvaluationPeriod")
-    def custom_evaluation_period(self) -> Optional[int]:
+    def custom_evaluation_period(self) -> Optional[_builtins.int]:
         return pulumi.get(self, "custom_evaluation_period")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="customToleratedBudgetConsumption")
-    def custom_tolerated_budget_consumption(self) -> Optional[float]:
+    def custom_tolerated_budget_consumption(self) -> Optional[_builtins.float]:
         return pulumi.get(self, "custom_tolerated_budget_consumption")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="evaluationPeriod")
-    def evaluation_period(self) -> int:
+    def evaluation_period(self) -> _builtins.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`.
         """
         return pulumi.get(self, "evaluation_period")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def id(self) -> str:
+    def id(self) -> _builtins.str:
         """
         The provider-assigned unique ID for this managed resource.
         """
         return pulumi.get(self, "id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="isBadEvents")
-    def is_bad_events(self) -> Optional[bool]:
+    def is_bad_events(self) -> Optional[_builtins.bool]:
         return pulumi.get(self, "is_bad_events")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def nrql(self) -> str:
+    def nrql(self) -> _builtins.str:
         """
         (Computed) The nrql query for the selected type of alert.
         """
         return pulumi.get(self, "nrql")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="sliGuid")
-    def sli_guid(self) -> str:
+    def sli_guid(self) -> _builtins.str:
         return pulumi.get(self, "sli_guid")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="sloPeriod")
-    def slo_period(self) -> int:
+    def slo_period(self) -> _builtins.int:
         return pulumi.get(self, "slo_period")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="sloTarget")
-    def slo_target(self) -> float:
+    def slo_target(self) -> _builtins.float:
         return pulumi.get(self, "slo_target")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def threshold(self) -> float:
+    def threshold(self) -> _builtins.float:
         """
         (Computed) The computed threshold given the provided arguments.
         """
         return pulumi.get(self, "threshold")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="toleratedBudgetConsumption")
-    def tolerated_budget_consumption(self) -> float:
+    def tolerated_budget_consumption(self) -> _builtins.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`.
         """
@@ -155,16 +160,16 @@ class AwaitableGetServiceLevelAlertHelperResult(GetServiceLevelAlertHelperResult
             tolerated_budget_consumption=self.tolerated_budget_consumption)
 
 
-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,
+def get_service_level_alert_helper(alert_type: Optional[_builtins.str] = None,
+                                   custom_evaluation_period: Optional[_builtins.int] = None,
+                                   custom_tolerated_budget_consumption: Optional[_builtins.float] = None,
+                                   is_bad_events: Optional[_builtins.bool] = None,
+                                   sli_guid: Optional[_builtins.str] = None,
+                                   slo_period: Optional[_builtins.int] = None,
+                                   slo_target: Optional[_builtins.float] = None,
                                    opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetServiceLevelAlertHelperResult:
     """
-    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`. For more information check [the documentation](https://docs.newrelic.com/docs/service-level-management/alerts-slm/).
+    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](https://docs.newrelic.com/docs/service-level-management/alerts-slm/).
 
     ## Example Usage
 
@@ -178,73 +183,111 @@ def get_service_level_alert_helper(alert_type: Optional[str] = None,
     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",
-                ),
-            ),
-        ))
+        events={
+            "account_id": "12345678",
+            "valid_events": {
+                "from_": "Transaction",
+                "where": "appName = 'Example application' AND (transactionType='Web')",
+            },
+            "bad_events": {
+                "from_": "Transaction",
+                "where": "appName = 'Example application' AND (transactionType= 'Web') AND duration > 0.1",
+            },
+        },
+        objective={
+            "target": foo_target,
+            "time_window": {
+                "rolling": {
+                    "count": foo_period,
+                    "unit": "DAY",
+                },
+            },
+        })
     ```
     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.
+
+    ```python
+    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={
+            "query": foo_slow_burn.nrql,
+        },
+        critical={
+            "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)
+    ```
+
+    Here is an example of a custom alert:
+
     ```python
     import pulumi
     import pulumi_newrelic as newrelic
 
     foo_custom = newrelic.get_service_level_alert_helper(alert_type="custom",
-        sli_guid=newrelic_service_level["foo"]["sli_guid"],
-        slo_target=local["foo_target"],
-        slo_period=local["foo_period"],
-        custom_tolerated_budget_consumption=5,
-        custom_evaluation_period=90,
+        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("yourCondition",
-        account_id=12345678,
-        policy_id=67890,
+    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=foo_custom.evaluation_period,
-            threshold_occurrences="at_least_once",
-        ),
+        nrql={
+            "query": foo_custom.nrql,
+        },
+        critical={
+            "operator": "above_or_equals",
+            "threshold": foo_custom.threshold,
+            "threshold_duration": 900,
+            "threshold_occurrences": "at_least_once",
+        },
         fill_option="none",
-        aggregation_window=3600,
+        aggregation_window=foo_custom.evaluation_period,
         aggregation_method="event_flow",
         aggregation_delay="120",
         slide_by=60)
     ```
 
 
-    :param str alert_type: The type of alert we want to set. Valid values are:
-    :param int custom_evaluation_period: Aggregation window taken into consideration in minutes. Mandatory if `alert_type` is `custom`.
-    :param float custom_tolerated_budget_consumption: How much budget you tolerate to consume during the custom evaluation period, valid values between `0` and `100`. Mandatory if `alert_type` is `custom`.
-    :param bool is_bad_events: If the SLI is defined using bad events. Defaults to `false`
-    :param str sli_guid: The guid of the sli we want to set the alert on.
-    :param int slo_period: The time window of the Service Level Objective in days. Valid values are `1`, `7` and `28`.
-    :param float slo_target: The target of the Service Level Objective, valid values between `0` and `100`.
+    :param _builtins.str alert_type: The type of alert we want to set. Valid values are:
+    :param _builtins.int custom_evaluation_period: Aggregation window taken into consideration in seconds. Mandatory if `alert_type` is `custom`.
+    :param _builtins.float custom_tolerated_budget_consumption: How much budget you tolerate to consume during the custom evaluation period, valid values between `0` and `100`. Mandatory if `alert_type` is `custom`.
+    :param _builtins.bool is_bad_events: If the SLI is defined using bad events. Defaults to `false`
+    :param _builtins.str sli_guid: The guid of the sli we want to set the alert on.
+    :param _builtins.int slo_period: The time window of the Service Level Objective in days. Valid values are `1`, `7` and `28`.
+    :param _builtins.float slo_target: The target of the Service Level Objective, valid values between `0` and `100`.
     """
     __args__ = dict()
     __args__['alertType'] = alert_type
@@ -270,19 +313,16 @@ def get_service_level_alert_helper(alert_type: Optional[str] = None,
         slo_target=pulumi.get(__ret__, 'slo_target'),
         threshold=pulumi.get(__ret__, 'threshold'),
         tolerated_budget_consumption=pulumi.get(__ret__, 'tolerated_budget_consumption'))
-
-
-@_utilities.lift_output_func(get_service_level_alert_helper)
-def get_service_level_alert_helper_output(alert_type: Optional[pulumi.Input[str]] = None,
-                                          custom_evaluation_period: Optional[pulumi.Input[Optional[int]]] = None,
-                                          custom_tolerated_budget_consumption: Optional[pulumi.Input[Optional[float]]] = None,
-                                          is_bad_events: Optional[pulumi.Input[Optional[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[pulumi.InvokeOptions] = None) -> pulumi.Output[GetServiceLevelAlertHelperResult]:
+def get_service_level_alert_helper_output(alert_type: Optional[pulumi.Input[_builtins.str]] = None,
+                                          custom_evaluation_period: Optional[pulumi.Input[Optional[_builtins.int]]] = None,
+                                          custom_tolerated_budget_consumption: Optional[pulumi.Input[Optional[_builtins.float]]] = None,
+                                          is_bad_events: Optional[pulumi.Input[Optional[_builtins.bool]]] = None,
+                                          sli_guid: Optional[pulumi.Input[_builtins.str]] = None,
+                                          slo_period: Optional[pulumi.Input[_builtins.int]] = None,
+                                          slo_target: Optional[pulumi.Input[_builtins.float]] = None,
+                                          opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetServiceLevelAlertHelperResult]:
     """
-    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`. For more information check [the documentation](https://docs.newrelic.com/docs/service-level-management/alerts-slm/).
+    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](https://docs.newrelic.com/docs/service-level-management/alerts-slm/).
 
     ## Example Usage
 
@@ -296,72 +336,132 @@ def get_service_level_alert_helper_output(alert_type: Optional[pulumi.Input[str]
     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",
-                ),
-            ),
-        ))
+        events={
+            "account_id": "12345678",
+            "valid_events": {
+                "from_": "Transaction",
+                "where": "appName = 'Example application' AND (transactionType='Web')",
+            },
+            "bad_events": {
+                "from_": "Transaction",
+                "where": "appName = 'Example application' AND (transactionType= 'Web') AND duration > 0.1",
+            },
+        },
+        objective={
+            "target": foo_target,
+            "time_window": {
+                "rolling": {
+                    "count": foo_period,
+                    "unit": "DAY",
+                },
+            },
+        })
     ```
     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.
+
+    ```python
+    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={
+            "query": foo_slow_burn.nrql,
+        },
+        critical={
+            "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)
+    ```
+
+    Here is an example of a custom alert:
+
     ```python
     import pulumi
     import pulumi_newrelic as newrelic
 
     foo_custom = newrelic.get_service_level_alert_helper(alert_type="custom",
-        sli_guid=newrelic_service_level["foo"]["sli_guid"],
-        slo_target=local["foo_target"],
-        slo_period=local["foo_period"],
-        custom_tolerated_budget_consumption=5,
-        custom_evaluation_period=90,
+        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("yourCondition",
-        account_id=12345678,
-        policy_id=67890,
+    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=foo_custom.evaluation_period,
-            threshold_occurrences="at_least_once",
-        ),
+        nrql={
+            "query": foo_custom.nrql,
+        },
+        critical={
+            "operator": "above_or_equals",
+            "threshold": foo_custom.threshold,
+            "threshold_duration": 900,
+            "threshold_occurrences": "at_least_once",
+        },
         fill_option="none",
-        aggregation_window=3600,
+        aggregation_window=foo_custom.evaluation_period,
         aggregation_method="event_flow",
         aggregation_delay="120",
         slide_by=60)
     ```
 
 
-    :param str alert_type: The type of alert we want to set. Valid values are:
-    :param int custom_evaluation_period: Aggregation window taken into consideration in minutes. Mandatory if `alert_type` is `custom`.
-    :param float custom_tolerated_budget_consumption: How much budget you tolerate to consume during the custom evaluation period, valid values between `0` and `100`. Mandatory if `alert_type` is `custom`.
-    :param bool is_bad_events: If the SLI is defined using bad events. Defaults to `false`
-    :param str sli_guid: The guid of the sli we want to set the alert on.
-    :param int slo_period: The time window of the Service Level Objective in days. Valid values are `1`, `7` and `28`.
-    :param float slo_target: The target of the Service Level Objective, valid values between `0` and `100`.
+    :param _builtins.str alert_type: The type of alert we want to set. Valid values are:
+    :param _builtins.int custom_evaluation_period: Aggregation window taken into consideration in seconds. Mandatory if `alert_type` is `custom`.
+    :param _builtins.float custom_tolerated_budget_consumption: How much budget you tolerate to consume during the custom evaluation period, valid values between `0` and `100`. Mandatory if `alert_type` is `custom`.
+    :param _builtins.bool is_bad_events: If the SLI is defined using bad events. Defaults to `false`
+    :param _builtins.str sli_guid: The guid of the sli we want to set the alert on.
+    :param _builtins.int slo_period: The time window of the Service Level Objective in days. Valid values are `1`, `7` and `28`.
+    :param _builtins.float slo_target: The target of the Service Level Objective, valid values between `0` and `100`.
     """
-    ...
+    __args__ = dict()
+    __args__['alertType'] = alert_type
+    __args__['customEvaluationPeriod'] = custom_evaluation_period
+    __args__['customToleratedBudgetConsumption'] = custom_tolerated_budget_consumption
+    __args__['isBadEvents'] = is_bad_events
+    __args__['sliGuid'] = sli_guid
+    __args__['sloPeriod'] = slo_period
+    __args__['sloTarget'] = slo_target
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('newrelic:index/getServiceLevelAlertHelper:getServiceLevelAlertHelper', __args__, opts=opts, typ=GetServiceLevelAlertHelperResult)
+    return __ret__.apply(lambda __response__: GetServiceLevelAlertHelperResult(
+        alert_type=pulumi.get(__response__, 'alert_type'),
+        custom_evaluation_period=pulumi.get(__response__, 'custom_evaluation_period'),
+        custom_tolerated_budget_consumption=pulumi.get(__response__, 'custom_tolerated_budget_consumption'),
+        evaluation_period=pulumi.get(__response__, 'evaluation_period'),
+        id=pulumi.get(__response__, 'id'),
+        is_bad_events=pulumi.get(__response__, 'is_bad_events'),
+        nrql=pulumi.get(__response__, 'nrql'),
+        sli_guid=pulumi.get(__response__, 'sli_guid'),
+        slo_period=pulumi.get(__response__, 'slo_period'),
+        slo_target=pulumi.get(__response__, 'slo_target'),
+        threshold=pulumi.get(__response__, 'threshold'),
+        tolerated_budget_consumption=pulumi.get(__response__, 'tolerated_budget_consumption')))