pulumi-newrelic 5.48.0a1752732890__py3-none-any.whl → 5.58.0a1766556761__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- pulumi_newrelic/__init__.py +18 -1
- pulumi_newrelic/_inputs.py +4269 -3795
- pulumi_newrelic/account_management.py +35 -36
- pulumi_newrelic/alert_channel.py +61 -62
- pulumi_newrelic/alert_condition.py +217 -218
- pulumi_newrelic/alert_muting_rule.py +92 -93
- pulumi_newrelic/alert_policy.py +69 -70
- pulumi_newrelic/alert_policy_channel.py +52 -53
- pulumi_newrelic/api_access_key.py +190 -159
- pulumi_newrelic/browser_application.py +113 -114
- pulumi_newrelic/cloud/__init__.py +2 -1
- pulumi_newrelic/cloud/_inputs.py +2183 -2130
- pulumi_newrelic/cloud/aws_govcloud_integrations.py +99 -96
- pulumi_newrelic/cloud/aws_govcloud_link_account.py +69 -70
- pulumi_newrelic/cloud/aws_integrations.py +194 -195
- pulumi_newrelic/cloud/aws_link_account.py +69 -70
- pulumi_newrelic/cloud/azure_integrations.py +178 -132
- pulumi_newrelic/cloud/azure_link_account.py +103 -104
- pulumi_newrelic/cloud/gcp_integrations.py +113 -114
- pulumi_newrelic/cloud/gcp_link_account.py +52 -53
- pulumi_newrelic/cloud/oci_link_account.py +926 -0
- pulumi_newrelic/cloud/outputs.py +1468 -1418
- pulumi_newrelic/config/__init__.py +1 -1
- pulumi_newrelic/config/__init__.pyi +1 -2
- pulumi_newrelic/config/vars.py +14 -15
- pulumi_newrelic/data_partition_rule.py +112 -113
- pulumi_newrelic/entity_tags.py +77 -22
- pulumi_newrelic/events_to_metrics_rule.py +95 -96
- pulumi_newrelic/get_account.py +21 -22
- pulumi_newrelic/get_alert_channel.py +52 -21
- pulumi_newrelic/get_alert_policy.py +51 -26
- pulumi_newrelic/get_application.py +13 -14
- pulumi_newrelic/get_authentication_domain.py +9 -10
- pulumi_newrelic/get_cloud_account.py +21 -22
- pulumi_newrelic/get_entity.py +52 -53
- pulumi_newrelic/get_group.py +17 -18
- pulumi_newrelic/get_key_transaction.py +25 -26
- pulumi_newrelic/get_notification_destination.py +29 -30
- pulumi_newrelic/get_obfuscation_expression.py +15 -16
- pulumi_newrelic/get_service_level_alert_helper.py +53 -54
- pulumi_newrelic/get_test_grok_pattern.py +22 -23
- pulumi_newrelic/get_user.py +21 -22
- pulumi_newrelic/group.py +52 -53
- pulumi_newrelic/infra_alert_condition.py +255 -256
- pulumi_newrelic/insights/__init__.py +1 -1
- pulumi_newrelic/insights/_inputs.py +32 -33
- pulumi_newrelic/insights/event.py +4 -5
- pulumi_newrelic/insights/outputs.py +22 -23
- pulumi_newrelic/key_transaction.py +104 -105
- pulumi_newrelic/log_parsing_rule.py +146 -147
- pulumi_newrelic/monitor_downtime.py +146 -154
- pulumi_newrelic/notification_channel.py +159 -160
- pulumi_newrelic/notification_destination.py +114 -129
- pulumi_newrelic/nrql_alert_condition.py +479 -431
- pulumi_newrelic/nrql_drop_rule.py +106 -147
- pulumi_newrelic/obfuscation_expression.py +69 -70
- pulumi_newrelic/obfuscation_rule.py +89 -90
- pulumi_newrelic/one_dashboard.py +93 -94
- pulumi_newrelic/one_dashboard_json.py +62 -63
- pulumi_newrelic/one_dashboard_raw.py +114 -115
- pulumi_newrelic/outputs.py +2991 -2673
- pulumi_newrelic/pipeline_cloud_rule.py +335 -0
- pulumi_newrelic/plugins/__init__.py +1 -1
- pulumi_newrelic/plugins/_inputs.py +158 -159
- pulumi_newrelic/plugins/application_settings.py +167 -168
- pulumi_newrelic/plugins/outputs.py +108 -109
- pulumi_newrelic/plugins/workload.py +131 -132
- pulumi_newrelic/provider.py +106 -107
- pulumi_newrelic/pulumi-plugin.json +1 -1
- pulumi_newrelic/service_level.py +76 -77
- pulumi_newrelic/synthetics/__init__.py +1 -1
- pulumi_newrelic/synthetics/_inputs.py +127 -128
- pulumi_newrelic/synthetics/alert_condition.py +95 -96
- pulumi_newrelic/synthetics/broken_links_monitor.py +197 -198
- pulumi_newrelic/synthetics/cert_check_monitor.py +205 -206
- pulumi_newrelic/synthetics/get_private_location.py +21 -22
- pulumi_newrelic/synthetics/get_secure_credential.py +19 -20
- pulumi_newrelic/synthetics/monitor.py +378 -379
- pulumi_newrelic/synthetics/multi_location_alert_condition.py +118 -119
- pulumi_newrelic/synthetics/outputs.py +85 -86
- pulumi_newrelic/synthetics/private_location.py +105 -106
- pulumi_newrelic/synthetics/script_monitor.py +364 -303
- pulumi_newrelic/synthetics/secure_credential.py +86 -87
- pulumi_newrelic/synthetics/step_monitor.py +220 -221
- pulumi_newrelic/user.py +69 -70
- pulumi_newrelic/workflow.py +139 -140
- {pulumi_newrelic-5.48.0a1752732890.dist-info → pulumi_newrelic-5.58.0a1766556761.dist-info}/METADATA +1 -1
- pulumi_newrelic-5.58.0a1766556761.dist-info/RECORD +92 -0
- pulumi_newrelic-5.48.0a1752732890.dist-info/RECORD +0 -90
- {pulumi_newrelic-5.48.0a1752732890.dist-info → pulumi_newrelic-5.58.0a1766556761.dist-info}/WHEEL +0 -0
- {pulumi_newrelic-5.48.0a1752732890.dist-info → pulumi_newrelic-5.58.0a1766556761.dist-info}/top_level.txt +0 -0
|
@@ -2,8 +2,7 @@
|
|
|
2
2
|
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
-
import builtins
|
|
6
|
-
import copy
|
|
5
|
+
import builtins as _builtins
|
|
7
6
|
import warnings
|
|
8
7
|
import sys
|
|
9
8
|
import pulumi
|
|
@@ -23,63 +22,65 @@ __all__ = ['NrqlAlertConditionArgs', 'NrqlAlertCondition']
|
|
|
23
22
|
class NrqlAlertConditionArgs:
|
|
24
23
|
def __init__(__self__, *,
|
|
25
24
|
nrql: pulumi.Input['NrqlAlertConditionNrqlArgs'],
|
|
26
|
-
policy_id: pulumi.Input[
|
|
27
|
-
account_id: Optional[pulumi.Input[
|
|
28
|
-
aggregation_delay: Optional[pulumi.Input[
|
|
29
|
-
aggregation_method: Optional[pulumi.Input[
|
|
30
|
-
aggregation_timer: Optional[pulumi.Input[
|
|
31
|
-
aggregation_window: Optional[pulumi.Input[
|
|
32
|
-
baseline_direction: Optional[pulumi.Input[
|
|
33
|
-
close_violations_on_expiration: Optional[pulumi.Input[
|
|
25
|
+
policy_id: pulumi.Input[_builtins.str],
|
|
26
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
27
|
+
aggregation_delay: Optional[pulumi.Input[_builtins.str]] = None,
|
|
28
|
+
aggregation_method: Optional[pulumi.Input[_builtins.str]] = None,
|
|
29
|
+
aggregation_timer: Optional[pulumi.Input[_builtins.str]] = None,
|
|
30
|
+
aggregation_window: Optional[pulumi.Input[_builtins.int]] = None,
|
|
31
|
+
baseline_direction: Optional[pulumi.Input[_builtins.str]] = None,
|
|
32
|
+
close_violations_on_expiration: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
34
33
|
critical: Optional[pulumi.Input['NrqlAlertConditionCriticalArgs']] = None,
|
|
35
|
-
description: Optional[pulumi.Input[
|
|
36
|
-
enabled: Optional[pulumi.Input[
|
|
37
|
-
evaluation_delay: Optional[pulumi.Input[
|
|
38
|
-
expiration_duration: Optional[pulumi.Input[
|
|
39
|
-
fill_option: Optional[pulumi.Input[
|
|
40
|
-
fill_value: Optional[pulumi.Input[
|
|
41
|
-
ignore_on_expected_termination: Optional[pulumi.Input[
|
|
42
|
-
name: Optional[pulumi.Input[
|
|
43
|
-
open_violation_on_expiration: Optional[pulumi.Input[
|
|
44
|
-
runbook_url: Optional[pulumi.Input[
|
|
45
|
-
signal_seasonality: Optional[pulumi.Input[
|
|
46
|
-
slide_by: Optional[pulumi.Input[
|
|
34
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
35
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
36
|
+
evaluation_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
37
|
+
expiration_duration: Optional[pulumi.Input[_builtins.int]] = None,
|
|
38
|
+
fill_option: Optional[pulumi.Input[_builtins.str]] = None,
|
|
39
|
+
fill_value: Optional[pulumi.Input[_builtins.float]] = None,
|
|
40
|
+
ignore_on_expected_termination: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
41
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
42
|
+
open_violation_on_expiration: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
43
|
+
runbook_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
44
|
+
signal_seasonality: Optional[pulumi.Input[_builtins.str]] = None,
|
|
45
|
+
slide_by: Optional[pulumi.Input[_builtins.int]] = None,
|
|
46
|
+
target_entity: Optional[pulumi.Input[_builtins.str]] = None,
|
|
47
47
|
terms: Optional[pulumi.Input[Sequence[pulumi.Input['NrqlAlertConditionTermArgs']]]] = None,
|
|
48
|
-
title_template: Optional[pulumi.Input[
|
|
49
|
-
type: Optional[pulumi.Input[
|
|
50
|
-
violation_time_limit: Optional[pulumi.Input[
|
|
51
|
-
violation_time_limit_seconds: Optional[pulumi.Input[
|
|
48
|
+
title_template: Optional[pulumi.Input[_builtins.str]] = None,
|
|
49
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
50
|
+
violation_time_limit: Optional[pulumi.Input[_builtins.str]] = None,
|
|
51
|
+
violation_time_limit_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
52
52
|
warning: Optional[pulumi.Input['NrqlAlertConditionWarningArgs']] = None):
|
|
53
53
|
"""
|
|
54
54
|
The set of arguments for constructing a NrqlAlertCondition resource.
|
|
55
55
|
:param pulumi.Input['NrqlAlertConditionNrqlArgs'] nrql: A NRQL query. See NRQL below for details.
|
|
56
|
-
:param pulumi.Input[
|
|
57
|
-
:param pulumi.Input[
|
|
58
|
-
:param pulumi.Input[
|
|
59
|
-
:param pulumi.Input[
|
|
60
|
-
:param pulumi.Input[
|
|
61
|
-
:param pulumi.Input[
|
|
62
|
-
:param pulumi.Input[
|
|
63
|
-
:param pulumi.Input[
|
|
56
|
+
:param pulumi.Input[_builtins.str] policy_id: The ID of the policy where this condition should be used.
|
|
57
|
+
:param pulumi.Input[_builtins.str] account_id: The New Relic account ID of the account you wish to create the condition. Defaults to the account ID set in your environment variable `NEW_RELIC_ACCOUNT_ID`.
|
|
58
|
+
:param pulumi.Input[_builtins.str] aggregation_delay: How long we wait for data that belongs in each aggregation window. Depending on your data, a longer delay may increase accuracy but delay notifications. Use `aggregation_delay` with the `event_flow` and `cadence` methods. The maximum delay is 1200 seconds (20 minutes) when using `event_flow` and 3600 seconds (60 minutes) when using `cadence`. In both cases, the minimum delay is 0 seconds and the default is 120 seconds. `aggregation_delay` cannot be set with `nrql.evaluation_offset`.
|
|
59
|
+
:param pulumi.Input[_builtins.str] aggregation_method: Determines when we consider an aggregation window to be complete so that we can evaluate the signal for incidents. Possible values are `cadence`, `event_flow` or `event_timer`. Default is `event_flow`. `aggregation_method` cannot be set with `nrql.evaluation_offset`.
|
|
60
|
+
:param pulumi.Input[_builtins.str] aggregation_timer: How long we wait after each data point arrives to make sure we've processed the whole batch. Use `aggregation_timer` with the `event_timer` method. The timer value can range from 0 seconds to 1200 seconds (20 minutes); the default is 60 seconds. `aggregation_timer` cannot be set with `nrql.evaluation_offset`.
|
|
61
|
+
:param pulumi.Input[_builtins.int] aggregation_window: The duration of the time window used to evaluate the NRQL query, in seconds. The value must be at least 30 seconds, and no more than 21600 seconds (6 hours). Default is 60 seconds.
|
|
62
|
+
:param pulumi.Input[_builtins.str] baseline_direction: The baseline direction of a _baseline_ NRQL alert condition. Valid values are: `lower_only`, `upper_and_lower`, `upper_only` (case insensitive).
|
|
63
|
+
:param pulumi.Input[_builtins.bool] close_violations_on_expiration: Whether to close all open incidents when the signal expires.
|
|
64
64
|
:param pulumi.Input['NrqlAlertConditionCriticalArgs'] critical: A list containing the `critical` threshold values. At least one `critical` or `warning` threshold must be defined. See Terms below for details.
|
|
65
|
-
:param pulumi.Input[
|
|
66
|
-
:param pulumi.Input[
|
|
67
|
-
:param pulumi.Input[
|
|
68
|
-
:param pulumi.Input[
|
|
69
|
-
:param pulumi.Input[
|
|
70
|
-
:param pulumi.Input[
|
|
71
|
-
:param pulumi.Input[
|
|
72
|
-
:param pulumi.Input[
|
|
73
|
-
:param pulumi.Input[
|
|
74
|
-
:param pulumi.Input[
|
|
75
|
-
:param pulumi.Input[
|
|
76
|
-
:param pulumi.Input[
|
|
65
|
+
:param pulumi.Input[_builtins.str] description: The description of the NRQL alert condition.
|
|
66
|
+
:param pulumi.Input[_builtins.bool] enabled: Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
|
|
67
|
+
:param pulumi.Input[_builtins.int] evaluation_delay: How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
|
|
68
|
+
:param pulumi.Input[_builtins.int] expiration_duration: The amount of time (in seconds) to wait before considering the signal expired. The value must be at least 30 seconds, and no more than 172800 seconds (48 hours).
|
|
69
|
+
:param pulumi.Input[_builtins.str] fill_option: Which strategy to use when filling gaps in the signal. Possible values are `none`, `last_value` or `static`. If `static`, the `fill_value` field will be used for filling gaps in the signal.
|
|
70
|
+
:param pulumi.Input[_builtins.float] fill_value: This value will be used for filling gaps in the signal.
|
|
71
|
+
:param pulumi.Input[_builtins.bool] ignore_on_expected_termination: Whether an alert condition should ignore expected termination of a signal when considering whether to create a loss of signal incident. Defaults to false.
|
|
72
|
+
:param pulumi.Input[_builtins.str] name: The title of the condition.
|
|
73
|
+
:param pulumi.Input[_builtins.bool] open_violation_on_expiration: Whether to create a new incident to capture that the signal expired.
|
|
74
|
+
:param pulumi.Input[_builtins.str] runbook_url: Runbook URL to display in notifications.
|
|
75
|
+
:param pulumi.Input[_builtins.str] signal_seasonality: Seasonality under which a condition's signal(s) are evaluated. Only available for baseline conditions. Valid values are: `NEW_RELIC_CALCULATION`, `HOURLY`, `DAILY`, `WEEKLY`, or `NONE`. To have New Relic calculate seasonality automatically, set to `NEW_RELIC_CALCULATION`. To turn off seasonality completely, set to `NONE`.
|
|
76
|
+
:param pulumi.Input[_builtins.int] slide_by: Gathers data in overlapping time windows to smooth the chart line, making it easier to spot trends. The `slide_by` value is specified in seconds and must be smaller than and a factor of the `aggregation_window`.
|
|
77
|
+
:param pulumi.Input[_builtins.str] target_entity: BETA PREVIEW: The GUID of the entity explicitly targeted by the condition. Issues triggered by this condition will affect the health status of this entity instead of having the affected entity detected automatically. The entity's account ID must be either `account_id` or `nrql.data_account_id`.
|
|
77
78
|
:param pulumi.Input[Sequence[pulumi.Input['NrqlAlertConditionTermArgs']]] terms: **DEPRECATED** Use `critical`, and `warning` instead. A list of terms for this condition. See Terms below for details.
|
|
78
|
-
:param pulumi.Input[
|
|
79
|
-
:param pulumi.Input[
|
|
80
|
-
:param pulumi.Input[
|
|
79
|
+
:param pulumi.Input[_builtins.str] title_template: The custom title to be used when incidents are opened by the condition. Setting this field will override the default title. Must be [Handlebars](https://handlebarsjs.com/) format.
|
|
80
|
+
:param pulumi.Input[_builtins.str] type: The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
|
|
81
|
+
:param pulumi.Input[_builtins.str] violation_time_limit: **DEPRECATED:** Use `violation_time_limit_seconds` instead. Sets a time limit, in hours, that will automatically force-close a long-lasting incident after the time limit you select. Possible values are `ONE_HOUR`, `TWO_HOURS`, `FOUR_HOURS`, `EIGHT_HOURS`, `TWELVE_HOURS`, `TWENTY_FOUR_HOURS`, `THIRTY_DAYS` (case insensitive).<br>
|
|
81
82
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
82
|
-
:param pulumi.Input[
|
|
83
|
+
:param pulumi.Input[_builtins.int] violation_time_limit_seconds: Sets a time limit, in seconds, that will automatically force-close a long-lasting incident after the time limit you select. The value must be between 300 seconds (5 minutes) to 2592000 seconds (30 days) (inclusive). <br>
|
|
83
84
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
84
85
|
:param pulumi.Input['NrqlAlertConditionWarningArgs'] warning: A list containing the `warning` threshold values. At least one `critical` or `warning` threshold must be defined. See Terms below for details.
|
|
85
86
|
"""
|
|
@@ -125,6 +126,8 @@ class NrqlAlertConditionArgs:
|
|
|
125
126
|
pulumi.set(__self__, "signal_seasonality", signal_seasonality)
|
|
126
127
|
if slide_by is not None:
|
|
127
128
|
pulumi.set(__self__, "slide_by", slide_by)
|
|
129
|
+
if target_entity is not None:
|
|
130
|
+
pulumi.set(__self__, "target_entity", target_entity)
|
|
128
131
|
if terms is not None:
|
|
129
132
|
warnings.warn("""use `critical` and `warning` attributes instead""", DeprecationWarning)
|
|
130
133
|
pulumi.log.warn("""terms is deprecated: use `critical` and `warning` attributes instead""")
|
|
@@ -144,7 +147,7 @@ class NrqlAlertConditionArgs:
|
|
|
144
147
|
if warning is not None:
|
|
145
148
|
pulumi.set(__self__, "warning", warning)
|
|
146
149
|
|
|
147
|
-
@property
|
|
150
|
+
@_builtins.property
|
|
148
151
|
@pulumi.getter
|
|
149
152
|
def nrql(self) -> pulumi.Input['NrqlAlertConditionNrqlArgs']:
|
|
150
153
|
"""
|
|
@@ -156,103 +159,103 @@ class NrqlAlertConditionArgs:
|
|
|
156
159
|
def nrql(self, value: pulumi.Input['NrqlAlertConditionNrqlArgs']):
|
|
157
160
|
pulumi.set(self, "nrql", value)
|
|
158
161
|
|
|
159
|
-
@property
|
|
162
|
+
@_builtins.property
|
|
160
163
|
@pulumi.getter(name="policyId")
|
|
161
|
-
def policy_id(self) -> pulumi.Input[
|
|
164
|
+
def policy_id(self) -> pulumi.Input[_builtins.str]:
|
|
162
165
|
"""
|
|
163
166
|
The ID of the policy where this condition should be used.
|
|
164
167
|
"""
|
|
165
168
|
return pulumi.get(self, "policy_id")
|
|
166
169
|
|
|
167
170
|
@policy_id.setter
|
|
168
|
-
def policy_id(self, value: pulumi.Input[
|
|
171
|
+
def policy_id(self, value: pulumi.Input[_builtins.str]):
|
|
169
172
|
pulumi.set(self, "policy_id", value)
|
|
170
173
|
|
|
171
|
-
@property
|
|
174
|
+
@_builtins.property
|
|
172
175
|
@pulumi.getter(name="accountId")
|
|
173
|
-
def account_id(self) -> Optional[pulumi.Input[
|
|
176
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
174
177
|
"""
|
|
175
178
|
The New Relic account ID of the account you wish to create the condition. Defaults to the account ID set in your environment variable `NEW_RELIC_ACCOUNT_ID`.
|
|
176
179
|
"""
|
|
177
180
|
return pulumi.get(self, "account_id")
|
|
178
181
|
|
|
179
182
|
@account_id.setter
|
|
180
|
-
def account_id(self, value: Optional[pulumi.Input[
|
|
183
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
181
184
|
pulumi.set(self, "account_id", value)
|
|
182
185
|
|
|
183
|
-
@property
|
|
186
|
+
@_builtins.property
|
|
184
187
|
@pulumi.getter(name="aggregationDelay")
|
|
185
|
-
def aggregation_delay(self) -> Optional[pulumi.Input[
|
|
188
|
+
def aggregation_delay(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
186
189
|
"""
|
|
187
190
|
How long we wait for data that belongs in each aggregation window. Depending on your data, a longer delay may increase accuracy but delay notifications. Use `aggregation_delay` with the `event_flow` and `cadence` methods. The maximum delay is 1200 seconds (20 minutes) when using `event_flow` and 3600 seconds (60 minutes) when using `cadence`. In both cases, the minimum delay is 0 seconds and the default is 120 seconds. `aggregation_delay` cannot be set with `nrql.evaluation_offset`.
|
|
188
191
|
"""
|
|
189
192
|
return pulumi.get(self, "aggregation_delay")
|
|
190
193
|
|
|
191
194
|
@aggregation_delay.setter
|
|
192
|
-
def aggregation_delay(self, value: Optional[pulumi.Input[
|
|
195
|
+
def aggregation_delay(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
193
196
|
pulumi.set(self, "aggregation_delay", value)
|
|
194
197
|
|
|
195
|
-
@property
|
|
198
|
+
@_builtins.property
|
|
196
199
|
@pulumi.getter(name="aggregationMethod")
|
|
197
|
-
def aggregation_method(self) -> Optional[pulumi.Input[
|
|
200
|
+
def aggregation_method(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
198
201
|
"""
|
|
199
202
|
Determines when we consider an aggregation window to be complete so that we can evaluate the signal for incidents. Possible values are `cadence`, `event_flow` or `event_timer`. Default is `event_flow`. `aggregation_method` cannot be set with `nrql.evaluation_offset`.
|
|
200
203
|
"""
|
|
201
204
|
return pulumi.get(self, "aggregation_method")
|
|
202
205
|
|
|
203
206
|
@aggregation_method.setter
|
|
204
|
-
def aggregation_method(self, value: Optional[pulumi.Input[
|
|
207
|
+
def aggregation_method(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
205
208
|
pulumi.set(self, "aggregation_method", value)
|
|
206
209
|
|
|
207
|
-
@property
|
|
210
|
+
@_builtins.property
|
|
208
211
|
@pulumi.getter(name="aggregationTimer")
|
|
209
|
-
def aggregation_timer(self) -> Optional[pulumi.Input[
|
|
212
|
+
def aggregation_timer(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
210
213
|
"""
|
|
211
214
|
How long we wait after each data point arrives to make sure we've processed the whole batch. Use `aggregation_timer` with the `event_timer` method. The timer value can range from 0 seconds to 1200 seconds (20 minutes); the default is 60 seconds. `aggregation_timer` cannot be set with `nrql.evaluation_offset`.
|
|
212
215
|
"""
|
|
213
216
|
return pulumi.get(self, "aggregation_timer")
|
|
214
217
|
|
|
215
218
|
@aggregation_timer.setter
|
|
216
|
-
def aggregation_timer(self, value: Optional[pulumi.Input[
|
|
219
|
+
def aggregation_timer(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
217
220
|
pulumi.set(self, "aggregation_timer", value)
|
|
218
221
|
|
|
219
|
-
@property
|
|
222
|
+
@_builtins.property
|
|
220
223
|
@pulumi.getter(name="aggregationWindow")
|
|
221
|
-
def aggregation_window(self) -> Optional[pulumi.Input[
|
|
224
|
+
def aggregation_window(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
222
225
|
"""
|
|
223
226
|
The duration of the time window used to evaluate the NRQL query, in seconds. The value must be at least 30 seconds, and no more than 21600 seconds (6 hours). Default is 60 seconds.
|
|
224
227
|
"""
|
|
225
228
|
return pulumi.get(self, "aggregation_window")
|
|
226
229
|
|
|
227
230
|
@aggregation_window.setter
|
|
228
|
-
def aggregation_window(self, value: Optional[pulumi.Input[
|
|
231
|
+
def aggregation_window(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
229
232
|
pulumi.set(self, "aggregation_window", value)
|
|
230
233
|
|
|
231
|
-
@property
|
|
234
|
+
@_builtins.property
|
|
232
235
|
@pulumi.getter(name="baselineDirection")
|
|
233
|
-
def baseline_direction(self) -> Optional[pulumi.Input[
|
|
236
|
+
def baseline_direction(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
234
237
|
"""
|
|
235
238
|
The baseline direction of a _baseline_ NRQL alert condition. Valid values are: `lower_only`, `upper_and_lower`, `upper_only` (case insensitive).
|
|
236
239
|
"""
|
|
237
240
|
return pulumi.get(self, "baseline_direction")
|
|
238
241
|
|
|
239
242
|
@baseline_direction.setter
|
|
240
|
-
def baseline_direction(self, value: Optional[pulumi.Input[
|
|
243
|
+
def baseline_direction(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
241
244
|
pulumi.set(self, "baseline_direction", value)
|
|
242
245
|
|
|
243
|
-
@property
|
|
246
|
+
@_builtins.property
|
|
244
247
|
@pulumi.getter(name="closeViolationsOnExpiration")
|
|
245
|
-
def close_violations_on_expiration(self) -> Optional[pulumi.Input[
|
|
248
|
+
def close_violations_on_expiration(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
246
249
|
"""
|
|
247
250
|
Whether to close all open incidents when the signal expires.
|
|
248
251
|
"""
|
|
249
252
|
return pulumi.get(self, "close_violations_on_expiration")
|
|
250
253
|
|
|
251
254
|
@close_violations_on_expiration.setter
|
|
252
|
-
def close_violations_on_expiration(self, value: Optional[pulumi.Input[
|
|
255
|
+
def close_violations_on_expiration(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
253
256
|
pulumi.set(self, "close_violations_on_expiration", value)
|
|
254
257
|
|
|
255
|
-
@property
|
|
258
|
+
@_builtins.property
|
|
256
259
|
@pulumi.getter
|
|
257
260
|
def critical(self) -> Optional[pulumi.Input['NrqlAlertConditionCriticalArgs']]:
|
|
258
261
|
"""
|
|
@@ -264,151 +267,163 @@ class NrqlAlertConditionArgs:
|
|
|
264
267
|
def critical(self, value: Optional[pulumi.Input['NrqlAlertConditionCriticalArgs']]):
|
|
265
268
|
pulumi.set(self, "critical", value)
|
|
266
269
|
|
|
267
|
-
@property
|
|
270
|
+
@_builtins.property
|
|
268
271
|
@pulumi.getter
|
|
269
|
-
def description(self) -> Optional[pulumi.Input[
|
|
272
|
+
def description(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
270
273
|
"""
|
|
271
274
|
The description of the NRQL alert condition.
|
|
272
275
|
"""
|
|
273
276
|
return pulumi.get(self, "description")
|
|
274
277
|
|
|
275
278
|
@description.setter
|
|
276
|
-
def description(self, value: Optional[pulumi.Input[
|
|
279
|
+
def description(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
277
280
|
pulumi.set(self, "description", value)
|
|
278
281
|
|
|
279
|
-
@property
|
|
282
|
+
@_builtins.property
|
|
280
283
|
@pulumi.getter
|
|
281
|
-
def enabled(self) -> Optional[pulumi.Input[
|
|
284
|
+
def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
282
285
|
"""
|
|
283
286
|
Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
|
|
284
287
|
"""
|
|
285
288
|
return pulumi.get(self, "enabled")
|
|
286
289
|
|
|
287
290
|
@enabled.setter
|
|
288
|
-
def enabled(self, value: Optional[pulumi.Input[
|
|
291
|
+
def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
289
292
|
pulumi.set(self, "enabled", value)
|
|
290
293
|
|
|
291
|
-
@property
|
|
294
|
+
@_builtins.property
|
|
292
295
|
@pulumi.getter(name="evaluationDelay")
|
|
293
|
-
def evaluation_delay(self) -> Optional[pulumi.Input[
|
|
296
|
+
def evaluation_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
294
297
|
"""
|
|
295
298
|
How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
|
|
296
299
|
"""
|
|
297
300
|
return pulumi.get(self, "evaluation_delay")
|
|
298
301
|
|
|
299
302
|
@evaluation_delay.setter
|
|
300
|
-
def evaluation_delay(self, value: Optional[pulumi.Input[
|
|
303
|
+
def evaluation_delay(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
301
304
|
pulumi.set(self, "evaluation_delay", value)
|
|
302
305
|
|
|
303
|
-
@property
|
|
306
|
+
@_builtins.property
|
|
304
307
|
@pulumi.getter(name="expirationDuration")
|
|
305
|
-
def expiration_duration(self) -> Optional[pulumi.Input[
|
|
308
|
+
def expiration_duration(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
306
309
|
"""
|
|
307
310
|
The amount of time (in seconds) to wait before considering the signal expired. The value must be at least 30 seconds, and no more than 172800 seconds (48 hours).
|
|
308
311
|
"""
|
|
309
312
|
return pulumi.get(self, "expiration_duration")
|
|
310
313
|
|
|
311
314
|
@expiration_duration.setter
|
|
312
|
-
def expiration_duration(self, value: Optional[pulumi.Input[
|
|
315
|
+
def expiration_duration(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
313
316
|
pulumi.set(self, "expiration_duration", value)
|
|
314
317
|
|
|
315
|
-
@property
|
|
318
|
+
@_builtins.property
|
|
316
319
|
@pulumi.getter(name="fillOption")
|
|
317
|
-
def fill_option(self) -> Optional[pulumi.Input[
|
|
320
|
+
def fill_option(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
318
321
|
"""
|
|
319
322
|
Which strategy to use when filling gaps in the signal. Possible values are `none`, `last_value` or `static`. If `static`, the `fill_value` field will be used for filling gaps in the signal.
|
|
320
323
|
"""
|
|
321
324
|
return pulumi.get(self, "fill_option")
|
|
322
325
|
|
|
323
326
|
@fill_option.setter
|
|
324
|
-
def fill_option(self, value: Optional[pulumi.Input[
|
|
327
|
+
def fill_option(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
325
328
|
pulumi.set(self, "fill_option", value)
|
|
326
329
|
|
|
327
|
-
@property
|
|
330
|
+
@_builtins.property
|
|
328
331
|
@pulumi.getter(name="fillValue")
|
|
329
|
-
def fill_value(self) -> Optional[pulumi.Input[
|
|
332
|
+
def fill_value(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
330
333
|
"""
|
|
331
334
|
This value will be used for filling gaps in the signal.
|
|
332
335
|
"""
|
|
333
336
|
return pulumi.get(self, "fill_value")
|
|
334
337
|
|
|
335
338
|
@fill_value.setter
|
|
336
|
-
def fill_value(self, value: Optional[pulumi.Input[
|
|
339
|
+
def fill_value(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
337
340
|
pulumi.set(self, "fill_value", value)
|
|
338
341
|
|
|
339
|
-
@property
|
|
342
|
+
@_builtins.property
|
|
340
343
|
@pulumi.getter(name="ignoreOnExpectedTermination")
|
|
341
|
-
def ignore_on_expected_termination(self) -> Optional[pulumi.Input[
|
|
344
|
+
def ignore_on_expected_termination(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
342
345
|
"""
|
|
343
346
|
Whether an alert condition should ignore expected termination of a signal when considering whether to create a loss of signal incident. Defaults to false.
|
|
344
347
|
"""
|
|
345
348
|
return pulumi.get(self, "ignore_on_expected_termination")
|
|
346
349
|
|
|
347
350
|
@ignore_on_expected_termination.setter
|
|
348
|
-
def ignore_on_expected_termination(self, value: Optional[pulumi.Input[
|
|
351
|
+
def ignore_on_expected_termination(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
349
352
|
pulumi.set(self, "ignore_on_expected_termination", value)
|
|
350
353
|
|
|
351
|
-
@property
|
|
354
|
+
@_builtins.property
|
|
352
355
|
@pulumi.getter
|
|
353
|
-
def name(self) -> Optional[pulumi.Input[
|
|
356
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
354
357
|
"""
|
|
355
358
|
The title of the condition.
|
|
356
359
|
"""
|
|
357
360
|
return pulumi.get(self, "name")
|
|
358
361
|
|
|
359
362
|
@name.setter
|
|
360
|
-
def name(self, value: Optional[pulumi.Input[
|
|
363
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
361
364
|
pulumi.set(self, "name", value)
|
|
362
365
|
|
|
363
|
-
@property
|
|
366
|
+
@_builtins.property
|
|
364
367
|
@pulumi.getter(name="openViolationOnExpiration")
|
|
365
|
-
def open_violation_on_expiration(self) -> Optional[pulumi.Input[
|
|
368
|
+
def open_violation_on_expiration(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
366
369
|
"""
|
|
367
370
|
Whether to create a new incident to capture that the signal expired.
|
|
368
371
|
"""
|
|
369
372
|
return pulumi.get(self, "open_violation_on_expiration")
|
|
370
373
|
|
|
371
374
|
@open_violation_on_expiration.setter
|
|
372
|
-
def open_violation_on_expiration(self, value: Optional[pulumi.Input[
|
|
375
|
+
def open_violation_on_expiration(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
373
376
|
pulumi.set(self, "open_violation_on_expiration", value)
|
|
374
377
|
|
|
375
|
-
@property
|
|
378
|
+
@_builtins.property
|
|
376
379
|
@pulumi.getter(name="runbookUrl")
|
|
377
|
-
def runbook_url(self) -> Optional[pulumi.Input[
|
|
380
|
+
def runbook_url(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
378
381
|
"""
|
|
379
382
|
Runbook URL to display in notifications.
|
|
380
383
|
"""
|
|
381
384
|
return pulumi.get(self, "runbook_url")
|
|
382
385
|
|
|
383
386
|
@runbook_url.setter
|
|
384
|
-
def runbook_url(self, value: Optional[pulumi.Input[
|
|
387
|
+
def runbook_url(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
385
388
|
pulumi.set(self, "runbook_url", value)
|
|
386
389
|
|
|
387
|
-
@property
|
|
390
|
+
@_builtins.property
|
|
388
391
|
@pulumi.getter(name="signalSeasonality")
|
|
389
|
-
def signal_seasonality(self) -> Optional[pulumi.Input[
|
|
392
|
+
def signal_seasonality(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
390
393
|
"""
|
|
391
394
|
Seasonality under which a condition's signal(s) are evaluated. Only available for baseline conditions. Valid values are: `NEW_RELIC_CALCULATION`, `HOURLY`, `DAILY`, `WEEKLY`, or `NONE`. To have New Relic calculate seasonality automatically, set to `NEW_RELIC_CALCULATION`. To turn off seasonality completely, set to `NONE`.
|
|
392
395
|
"""
|
|
393
396
|
return pulumi.get(self, "signal_seasonality")
|
|
394
397
|
|
|
395
398
|
@signal_seasonality.setter
|
|
396
|
-
def signal_seasonality(self, value: Optional[pulumi.Input[
|
|
399
|
+
def signal_seasonality(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
397
400
|
pulumi.set(self, "signal_seasonality", value)
|
|
398
401
|
|
|
399
|
-
@property
|
|
402
|
+
@_builtins.property
|
|
400
403
|
@pulumi.getter(name="slideBy")
|
|
401
|
-
def slide_by(self) -> Optional[pulumi.Input[
|
|
404
|
+
def slide_by(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
402
405
|
"""
|
|
403
406
|
Gathers data in overlapping time windows to smooth the chart line, making it easier to spot trends. The `slide_by` value is specified in seconds and must be smaller than and a factor of the `aggregation_window`.
|
|
404
407
|
"""
|
|
405
408
|
return pulumi.get(self, "slide_by")
|
|
406
409
|
|
|
407
410
|
@slide_by.setter
|
|
408
|
-
def slide_by(self, value: Optional[pulumi.Input[
|
|
411
|
+
def slide_by(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
409
412
|
pulumi.set(self, "slide_by", value)
|
|
410
413
|
|
|
411
|
-
@property
|
|
414
|
+
@_builtins.property
|
|
415
|
+
@pulumi.getter(name="targetEntity")
|
|
416
|
+
def target_entity(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
417
|
+
"""
|
|
418
|
+
BETA PREVIEW: The GUID of the entity explicitly targeted by the condition. Issues triggered by this condition will affect the health status of this entity instead of having the affected entity detected automatically. The entity's account ID must be either `account_id` or `nrql.data_account_id`.
|
|
419
|
+
"""
|
|
420
|
+
return pulumi.get(self, "target_entity")
|
|
421
|
+
|
|
422
|
+
@target_entity.setter
|
|
423
|
+
def target_entity(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
424
|
+
pulumi.set(self, "target_entity", value)
|
|
425
|
+
|
|
426
|
+
@_builtins.property
|
|
412
427
|
@pulumi.getter
|
|
413
428
|
@_utilities.deprecated("""use `critical` and `warning` attributes instead""")
|
|
414
429
|
def terms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NrqlAlertConditionTermArgs']]]]:
|
|
@@ -421,34 +436,34 @@ class NrqlAlertConditionArgs:
|
|
|
421
436
|
def terms(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NrqlAlertConditionTermArgs']]]]):
|
|
422
437
|
pulumi.set(self, "terms", value)
|
|
423
438
|
|
|
424
|
-
@property
|
|
439
|
+
@_builtins.property
|
|
425
440
|
@pulumi.getter(name="titleTemplate")
|
|
426
|
-
def title_template(self) -> Optional[pulumi.Input[
|
|
441
|
+
def title_template(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
427
442
|
"""
|
|
428
443
|
The custom title to be used when incidents are opened by the condition. Setting this field will override the default title. Must be [Handlebars](https://handlebarsjs.com/) format.
|
|
429
444
|
"""
|
|
430
445
|
return pulumi.get(self, "title_template")
|
|
431
446
|
|
|
432
447
|
@title_template.setter
|
|
433
|
-
def title_template(self, value: Optional[pulumi.Input[
|
|
448
|
+
def title_template(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
434
449
|
pulumi.set(self, "title_template", value)
|
|
435
450
|
|
|
436
|
-
@property
|
|
451
|
+
@_builtins.property
|
|
437
452
|
@pulumi.getter
|
|
438
|
-
def type(self) -> Optional[pulumi.Input[
|
|
453
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
439
454
|
"""
|
|
440
455
|
The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
|
|
441
456
|
"""
|
|
442
457
|
return pulumi.get(self, "type")
|
|
443
458
|
|
|
444
459
|
@type.setter
|
|
445
|
-
def type(self, value: Optional[pulumi.Input[
|
|
460
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
446
461
|
pulumi.set(self, "type", value)
|
|
447
462
|
|
|
448
|
-
@property
|
|
463
|
+
@_builtins.property
|
|
449
464
|
@pulumi.getter(name="violationTimeLimit")
|
|
450
465
|
@_utilities.deprecated("""use `violation_time_limit_seconds` attribute instead""")
|
|
451
|
-
def violation_time_limit(self) -> Optional[pulumi.Input[
|
|
466
|
+
def violation_time_limit(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
452
467
|
"""
|
|
453
468
|
**DEPRECATED:** Use `violation_time_limit_seconds` instead. Sets a time limit, in hours, that will automatically force-close a long-lasting incident after the time limit you select. Possible values are `ONE_HOUR`, `TWO_HOURS`, `FOUR_HOURS`, `EIGHT_HOURS`, `TWELVE_HOURS`, `TWENTY_FOUR_HOURS`, `THIRTY_DAYS` (case insensitive).<br>
|
|
454
469
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
@@ -456,12 +471,12 @@ class NrqlAlertConditionArgs:
|
|
|
456
471
|
return pulumi.get(self, "violation_time_limit")
|
|
457
472
|
|
|
458
473
|
@violation_time_limit.setter
|
|
459
|
-
def violation_time_limit(self, value: Optional[pulumi.Input[
|
|
474
|
+
def violation_time_limit(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
460
475
|
pulumi.set(self, "violation_time_limit", value)
|
|
461
476
|
|
|
462
|
-
@property
|
|
477
|
+
@_builtins.property
|
|
463
478
|
@pulumi.getter(name="violationTimeLimitSeconds")
|
|
464
|
-
def violation_time_limit_seconds(self) -> Optional[pulumi.Input[
|
|
479
|
+
def violation_time_limit_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
465
480
|
"""
|
|
466
481
|
Sets a time limit, in seconds, that will automatically force-close a long-lasting incident after the time limit you select. The value must be between 300 seconds (5 minutes) to 2592000 seconds (30 days) (inclusive). <br>
|
|
467
482
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
@@ -469,10 +484,10 @@ class NrqlAlertConditionArgs:
|
|
|
469
484
|
return pulumi.get(self, "violation_time_limit_seconds")
|
|
470
485
|
|
|
471
486
|
@violation_time_limit_seconds.setter
|
|
472
|
-
def violation_time_limit_seconds(self, value: Optional[pulumi.Input[
|
|
487
|
+
def violation_time_limit_seconds(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
473
488
|
pulumi.set(self, "violation_time_limit_seconds", value)
|
|
474
489
|
|
|
475
|
-
@property
|
|
490
|
+
@_builtins.property
|
|
476
491
|
@pulumi.getter
|
|
477
492
|
def warning(self) -> Optional[pulumi.Input['NrqlAlertConditionWarningArgs']]:
|
|
478
493
|
"""
|
|
@@ -488,66 +503,68 @@ class NrqlAlertConditionArgs:
|
|
|
488
503
|
@pulumi.input_type
|
|
489
504
|
class _NrqlAlertConditionState:
|
|
490
505
|
def __init__(__self__, *,
|
|
491
|
-
account_id: Optional[pulumi.Input[
|
|
492
|
-
aggregation_delay: Optional[pulumi.Input[
|
|
493
|
-
aggregation_method: Optional[pulumi.Input[
|
|
494
|
-
aggregation_timer: Optional[pulumi.Input[
|
|
495
|
-
aggregation_window: Optional[pulumi.Input[
|
|
496
|
-
baseline_direction: Optional[pulumi.Input[
|
|
497
|
-
close_violations_on_expiration: Optional[pulumi.Input[
|
|
506
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
507
|
+
aggregation_delay: Optional[pulumi.Input[_builtins.str]] = None,
|
|
508
|
+
aggregation_method: Optional[pulumi.Input[_builtins.str]] = None,
|
|
509
|
+
aggregation_timer: Optional[pulumi.Input[_builtins.str]] = None,
|
|
510
|
+
aggregation_window: Optional[pulumi.Input[_builtins.int]] = None,
|
|
511
|
+
baseline_direction: Optional[pulumi.Input[_builtins.str]] = None,
|
|
512
|
+
close_violations_on_expiration: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
498
513
|
critical: Optional[pulumi.Input['NrqlAlertConditionCriticalArgs']] = None,
|
|
499
|
-
description: Optional[pulumi.Input[
|
|
500
|
-
enabled: Optional[pulumi.Input[
|
|
501
|
-
entity_guid: Optional[pulumi.Input[
|
|
502
|
-
evaluation_delay: Optional[pulumi.Input[
|
|
503
|
-
expiration_duration: Optional[pulumi.Input[
|
|
504
|
-
fill_option: Optional[pulumi.Input[
|
|
505
|
-
fill_value: Optional[pulumi.Input[
|
|
506
|
-
ignore_on_expected_termination: Optional[pulumi.Input[
|
|
507
|
-
name: Optional[pulumi.Input[
|
|
514
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
515
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
516
|
+
entity_guid: Optional[pulumi.Input[_builtins.str]] = None,
|
|
517
|
+
evaluation_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
518
|
+
expiration_duration: Optional[pulumi.Input[_builtins.int]] = None,
|
|
519
|
+
fill_option: Optional[pulumi.Input[_builtins.str]] = None,
|
|
520
|
+
fill_value: Optional[pulumi.Input[_builtins.float]] = None,
|
|
521
|
+
ignore_on_expected_termination: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
522
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
508
523
|
nrql: Optional[pulumi.Input['NrqlAlertConditionNrqlArgs']] = None,
|
|
509
|
-
open_violation_on_expiration: Optional[pulumi.Input[
|
|
510
|
-
policy_id: Optional[pulumi.Input[
|
|
511
|
-
runbook_url: Optional[pulumi.Input[
|
|
512
|
-
signal_seasonality: Optional[pulumi.Input[
|
|
513
|
-
slide_by: Optional[pulumi.Input[
|
|
524
|
+
open_violation_on_expiration: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
525
|
+
policy_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
526
|
+
runbook_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
527
|
+
signal_seasonality: Optional[pulumi.Input[_builtins.str]] = None,
|
|
528
|
+
slide_by: Optional[pulumi.Input[_builtins.int]] = None,
|
|
529
|
+
target_entity: Optional[pulumi.Input[_builtins.str]] = None,
|
|
514
530
|
terms: Optional[pulumi.Input[Sequence[pulumi.Input['NrqlAlertConditionTermArgs']]]] = None,
|
|
515
|
-
title_template: Optional[pulumi.Input[
|
|
516
|
-
type: Optional[pulumi.Input[
|
|
517
|
-
violation_time_limit: Optional[pulumi.Input[
|
|
518
|
-
violation_time_limit_seconds: Optional[pulumi.Input[
|
|
531
|
+
title_template: Optional[pulumi.Input[_builtins.str]] = None,
|
|
532
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
533
|
+
violation_time_limit: Optional[pulumi.Input[_builtins.str]] = None,
|
|
534
|
+
violation_time_limit_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
519
535
|
warning: Optional[pulumi.Input['NrqlAlertConditionWarningArgs']] = None):
|
|
520
536
|
"""
|
|
521
537
|
Input properties used for looking up and filtering NrqlAlertCondition resources.
|
|
522
|
-
:param pulumi.Input[
|
|
523
|
-
:param pulumi.Input[
|
|
524
|
-
:param pulumi.Input[
|
|
525
|
-
:param pulumi.Input[
|
|
526
|
-
:param pulumi.Input[
|
|
527
|
-
:param pulumi.Input[
|
|
528
|
-
:param pulumi.Input[
|
|
538
|
+
:param pulumi.Input[_builtins.str] account_id: The New Relic account ID of the account you wish to create the condition. Defaults to the account ID set in your environment variable `NEW_RELIC_ACCOUNT_ID`.
|
|
539
|
+
:param pulumi.Input[_builtins.str] aggregation_delay: How long we wait for data that belongs in each aggregation window. Depending on your data, a longer delay may increase accuracy but delay notifications. Use `aggregation_delay` with the `event_flow` and `cadence` methods. The maximum delay is 1200 seconds (20 minutes) when using `event_flow` and 3600 seconds (60 minutes) when using `cadence`. In both cases, the minimum delay is 0 seconds and the default is 120 seconds. `aggregation_delay` cannot be set with `nrql.evaluation_offset`.
|
|
540
|
+
:param pulumi.Input[_builtins.str] aggregation_method: Determines when we consider an aggregation window to be complete so that we can evaluate the signal for incidents. Possible values are `cadence`, `event_flow` or `event_timer`. Default is `event_flow`. `aggregation_method` cannot be set with `nrql.evaluation_offset`.
|
|
541
|
+
:param pulumi.Input[_builtins.str] aggregation_timer: How long we wait after each data point arrives to make sure we've processed the whole batch. Use `aggregation_timer` with the `event_timer` method. The timer value can range from 0 seconds to 1200 seconds (20 minutes); the default is 60 seconds. `aggregation_timer` cannot be set with `nrql.evaluation_offset`.
|
|
542
|
+
:param pulumi.Input[_builtins.int] aggregation_window: The duration of the time window used to evaluate the NRQL query, in seconds. The value must be at least 30 seconds, and no more than 21600 seconds (6 hours). Default is 60 seconds.
|
|
543
|
+
:param pulumi.Input[_builtins.str] baseline_direction: The baseline direction of a _baseline_ NRQL alert condition. Valid values are: `lower_only`, `upper_and_lower`, `upper_only` (case insensitive).
|
|
544
|
+
:param pulumi.Input[_builtins.bool] close_violations_on_expiration: Whether to close all open incidents when the signal expires.
|
|
529
545
|
:param pulumi.Input['NrqlAlertConditionCriticalArgs'] critical: A list containing the `critical` threshold values. At least one `critical` or `warning` threshold must be defined. See Terms below for details.
|
|
530
|
-
:param pulumi.Input[
|
|
531
|
-
:param pulumi.Input[
|
|
532
|
-
:param pulumi.Input[
|
|
533
|
-
:param pulumi.Input[
|
|
534
|
-
:param pulumi.Input[
|
|
535
|
-
:param pulumi.Input[
|
|
536
|
-
:param pulumi.Input[
|
|
537
|
-
:param pulumi.Input[
|
|
538
|
-
:param pulumi.Input[
|
|
546
|
+
:param pulumi.Input[_builtins.str] description: The description of the NRQL alert condition.
|
|
547
|
+
:param pulumi.Input[_builtins.bool] enabled: Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
|
|
548
|
+
:param pulumi.Input[_builtins.str] entity_guid: The unique entity identifier of the NRQL Condition in New Relic.
|
|
549
|
+
:param pulumi.Input[_builtins.int] evaluation_delay: How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
|
|
550
|
+
:param pulumi.Input[_builtins.int] expiration_duration: The amount of time (in seconds) to wait before considering the signal expired. The value must be at least 30 seconds, and no more than 172800 seconds (48 hours).
|
|
551
|
+
:param pulumi.Input[_builtins.str] fill_option: Which strategy to use when filling gaps in the signal. Possible values are `none`, `last_value` or `static`. If `static`, the `fill_value` field will be used for filling gaps in the signal.
|
|
552
|
+
:param pulumi.Input[_builtins.float] fill_value: This value will be used for filling gaps in the signal.
|
|
553
|
+
:param pulumi.Input[_builtins.bool] ignore_on_expected_termination: Whether an alert condition should ignore expected termination of a signal when considering whether to create a loss of signal incident. Defaults to false.
|
|
554
|
+
:param pulumi.Input[_builtins.str] name: The title of the condition.
|
|
539
555
|
:param pulumi.Input['NrqlAlertConditionNrqlArgs'] nrql: A NRQL query. See NRQL below for details.
|
|
540
|
-
:param pulumi.Input[
|
|
541
|
-
:param pulumi.Input[
|
|
542
|
-
:param pulumi.Input[
|
|
543
|
-
:param pulumi.Input[
|
|
544
|
-
:param pulumi.Input[
|
|
556
|
+
:param pulumi.Input[_builtins.bool] open_violation_on_expiration: Whether to create a new incident to capture that the signal expired.
|
|
557
|
+
:param pulumi.Input[_builtins.str] policy_id: The ID of the policy where this condition should be used.
|
|
558
|
+
:param pulumi.Input[_builtins.str] runbook_url: Runbook URL to display in notifications.
|
|
559
|
+
:param pulumi.Input[_builtins.str] signal_seasonality: Seasonality under which a condition's signal(s) are evaluated. Only available for baseline conditions. Valid values are: `NEW_RELIC_CALCULATION`, `HOURLY`, `DAILY`, `WEEKLY`, or `NONE`. To have New Relic calculate seasonality automatically, set to `NEW_RELIC_CALCULATION`. To turn off seasonality completely, set to `NONE`.
|
|
560
|
+
:param pulumi.Input[_builtins.int] slide_by: Gathers data in overlapping time windows to smooth the chart line, making it easier to spot trends. The `slide_by` value is specified in seconds and must be smaller than and a factor of the `aggregation_window`.
|
|
561
|
+
:param pulumi.Input[_builtins.str] target_entity: BETA PREVIEW: The GUID of the entity explicitly targeted by the condition. Issues triggered by this condition will affect the health status of this entity instead of having the affected entity detected automatically. The entity's account ID must be either `account_id` or `nrql.data_account_id`.
|
|
545
562
|
:param pulumi.Input[Sequence[pulumi.Input['NrqlAlertConditionTermArgs']]] terms: **DEPRECATED** Use `critical`, and `warning` instead. A list of terms for this condition. See Terms below for details.
|
|
546
|
-
:param pulumi.Input[
|
|
547
|
-
:param pulumi.Input[
|
|
548
|
-
:param pulumi.Input[
|
|
563
|
+
:param pulumi.Input[_builtins.str] title_template: The custom title to be used when incidents are opened by the condition. Setting this field will override the default title. Must be [Handlebars](https://handlebarsjs.com/) format.
|
|
564
|
+
:param pulumi.Input[_builtins.str] type: The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
|
|
565
|
+
:param pulumi.Input[_builtins.str] violation_time_limit: **DEPRECATED:** Use `violation_time_limit_seconds` instead. Sets a time limit, in hours, that will automatically force-close a long-lasting incident after the time limit you select. Possible values are `ONE_HOUR`, `TWO_HOURS`, `FOUR_HOURS`, `EIGHT_HOURS`, `TWELVE_HOURS`, `TWENTY_FOUR_HOURS`, `THIRTY_DAYS` (case insensitive).<br>
|
|
549
566
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
550
|
-
:param pulumi.Input[
|
|
567
|
+
:param pulumi.Input[_builtins.int] violation_time_limit_seconds: Sets a time limit, in seconds, that will automatically force-close a long-lasting incident after the time limit you select. The value must be between 300 seconds (5 minutes) to 2592000 seconds (30 days) (inclusive). <br>
|
|
551
568
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
552
569
|
:param pulumi.Input['NrqlAlertConditionWarningArgs'] warning: A list containing the `warning` threshold values. At least one `critical` or `warning` threshold must be defined. See Terms below for details.
|
|
553
570
|
"""
|
|
@@ -597,6 +614,8 @@ class _NrqlAlertConditionState:
|
|
|
597
614
|
pulumi.set(__self__, "signal_seasonality", signal_seasonality)
|
|
598
615
|
if slide_by is not None:
|
|
599
616
|
pulumi.set(__self__, "slide_by", slide_by)
|
|
617
|
+
if target_entity is not None:
|
|
618
|
+
pulumi.set(__self__, "target_entity", target_entity)
|
|
600
619
|
if terms is not None:
|
|
601
620
|
warnings.warn("""use `critical` and `warning` attributes instead""", DeprecationWarning)
|
|
602
621
|
pulumi.log.warn("""terms is deprecated: use `critical` and `warning` attributes instead""")
|
|
@@ -616,91 +635,91 @@ class _NrqlAlertConditionState:
|
|
|
616
635
|
if warning is not None:
|
|
617
636
|
pulumi.set(__self__, "warning", warning)
|
|
618
637
|
|
|
619
|
-
@property
|
|
638
|
+
@_builtins.property
|
|
620
639
|
@pulumi.getter(name="accountId")
|
|
621
|
-
def account_id(self) -> Optional[pulumi.Input[
|
|
640
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
622
641
|
"""
|
|
623
642
|
The New Relic account ID of the account you wish to create the condition. Defaults to the account ID set in your environment variable `NEW_RELIC_ACCOUNT_ID`.
|
|
624
643
|
"""
|
|
625
644
|
return pulumi.get(self, "account_id")
|
|
626
645
|
|
|
627
646
|
@account_id.setter
|
|
628
|
-
def account_id(self, value: Optional[pulumi.Input[
|
|
647
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
629
648
|
pulumi.set(self, "account_id", value)
|
|
630
649
|
|
|
631
|
-
@property
|
|
650
|
+
@_builtins.property
|
|
632
651
|
@pulumi.getter(name="aggregationDelay")
|
|
633
|
-
def aggregation_delay(self) -> Optional[pulumi.Input[
|
|
652
|
+
def aggregation_delay(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
634
653
|
"""
|
|
635
654
|
How long we wait for data that belongs in each aggregation window. Depending on your data, a longer delay may increase accuracy but delay notifications. Use `aggregation_delay` with the `event_flow` and `cadence` methods. The maximum delay is 1200 seconds (20 minutes) when using `event_flow` and 3600 seconds (60 minutes) when using `cadence`. In both cases, the minimum delay is 0 seconds and the default is 120 seconds. `aggregation_delay` cannot be set with `nrql.evaluation_offset`.
|
|
636
655
|
"""
|
|
637
656
|
return pulumi.get(self, "aggregation_delay")
|
|
638
657
|
|
|
639
658
|
@aggregation_delay.setter
|
|
640
|
-
def aggregation_delay(self, value: Optional[pulumi.Input[
|
|
659
|
+
def aggregation_delay(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
641
660
|
pulumi.set(self, "aggregation_delay", value)
|
|
642
661
|
|
|
643
|
-
@property
|
|
662
|
+
@_builtins.property
|
|
644
663
|
@pulumi.getter(name="aggregationMethod")
|
|
645
|
-
def aggregation_method(self) -> Optional[pulumi.Input[
|
|
664
|
+
def aggregation_method(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
646
665
|
"""
|
|
647
666
|
Determines when we consider an aggregation window to be complete so that we can evaluate the signal for incidents. Possible values are `cadence`, `event_flow` or `event_timer`. Default is `event_flow`. `aggregation_method` cannot be set with `nrql.evaluation_offset`.
|
|
648
667
|
"""
|
|
649
668
|
return pulumi.get(self, "aggregation_method")
|
|
650
669
|
|
|
651
670
|
@aggregation_method.setter
|
|
652
|
-
def aggregation_method(self, value: Optional[pulumi.Input[
|
|
671
|
+
def aggregation_method(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
653
672
|
pulumi.set(self, "aggregation_method", value)
|
|
654
673
|
|
|
655
|
-
@property
|
|
674
|
+
@_builtins.property
|
|
656
675
|
@pulumi.getter(name="aggregationTimer")
|
|
657
|
-
def aggregation_timer(self) -> Optional[pulumi.Input[
|
|
676
|
+
def aggregation_timer(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
658
677
|
"""
|
|
659
678
|
How long we wait after each data point arrives to make sure we've processed the whole batch. Use `aggregation_timer` with the `event_timer` method. The timer value can range from 0 seconds to 1200 seconds (20 minutes); the default is 60 seconds. `aggregation_timer` cannot be set with `nrql.evaluation_offset`.
|
|
660
679
|
"""
|
|
661
680
|
return pulumi.get(self, "aggregation_timer")
|
|
662
681
|
|
|
663
682
|
@aggregation_timer.setter
|
|
664
|
-
def aggregation_timer(self, value: Optional[pulumi.Input[
|
|
683
|
+
def aggregation_timer(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
665
684
|
pulumi.set(self, "aggregation_timer", value)
|
|
666
685
|
|
|
667
|
-
@property
|
|
686
|
+
@_builtins.property
|
|
668
687
|
@pulumi.getter(name="aggregationWindow")
|
|
669
|
-
def aggregation_window(self) -> Optional[pulumi.Input[
|
|
688
|
+
def aggregation_window(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
670
689
|
"""
|
|
671
690
|
The duration of the time window used to evaluate the NRQL query, in seconds. The value must be at least 30 seconds, and no more than 21600 seconds (6 hours). Default is 60 seconds.
|
|
672
691
|
"""
|
|
673
692
|
return pulumi.get(self, "aggregation_window")
|
|
674
693
|
|
|
675
694
|
@aggregation_window.setter
|
|
676
|
-
def aggregation_window(self, value: Optional[pulumi.Input[
|
|
695
|
+
def aggregation_window(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
677
696
|
pulumi.set(self, "aggregation_window", value)
|
|
678
697
|
|
|
679
|
-
@property
|
|
698
|
+
@_builtins.property
|
|
680
699
|
@pulumi.getter(name="baselineDirection")
|
|
681
|
-
def baseline_direction(self) -> Optional[pulumi.Input[
|
|
700
|
+
def baseline_direction(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
682
701
|
"""
|
|
683
702
|
The baseline direction of a _baseline_ NRQL alert condition. Valid values are: `lower_only`, `upper_and_lower`, `upper_only` (case insensitive).
|
|
684
703
|
"""
|
|
685
704
|
return pulumi.get(self, "baseline_direction")
|
|
686
705
|
|
|
687
706
|
@baseline_direction.setter
|
|
688
|
-
def baseline_direction(self, value: Optional[pulumi.Input[
|
|
707
|
+
def baseline_direction(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
689
708
|
pulumi.set(self, "baseline_direction", value)
|
|
690
709
|
|
|
691
|
-
@property
|
|
710
|
+
@_builtins.property
|
|
692
711
|
@pulumi.getter(name="closeViolationsOnExpiration")
|
|
693
|
-
def close_violations_on_expiration(self) -> Optional[pulumi.Input[
|
|
712
|
+
def close_violations_on_expiration(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
694
713
|
"""
|
|
695
714
|
Whether to close all open incidents when the signal expires.
|
|
696
715
|
"""
|
|
697
716
|
return pulumi.get(self, "close_violations_on_expiration")
|
|
698
717
|
|
|
699
718
|
@close_violations_on_expiration.setter
|
|
700
|
-
def close_violations_on_expiration(self, value: Optional[pulumi.Input[
|
|
719
|
+
def close_violations_on_expiration(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
701
720
|
pulumi.set(self, "close_violations_on_expiration", value)
|
|
702
721
|
|
|
703
|
-
@property
|
|
722
|
+
@_builtins.property
|
|
704
723
|
@pulumi.getter
|
|
705
724
|
def critical(self) -> Optional[pulumi.Input['NrqlAlertConditionCriticalArgs']]:
|
|
706
725
|
"""
|
|
@@ -712,115 +731,115 @@ class _NrqlAlertConditionState:
|
|
|
712
731
|
def critical(self, value: Optional[pulumi.Input['NrqlAlertConditionCriticalArgs']]):
|
|
713
732
|
pulumi.set(self, "critical", value)
|
|
714
733
|
|
|
715
|
-
@property
|
|
734
|
+
@_builtins.property
|
|
716
735
|
@pulumi.getter
|
|
717
|
-
def description(self) -> Optional[pulumi.Input[
|
|
736
|
+
def description(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
718
737
|
"""
|
|
719
738
|
The description of the NRQL alert condition.
|
|
720
739
|
"""
|
|
721
740
|
return pulumi.get(self, "description")
|
|
722
741
|
|
|
723
742
|
@description.setter
|
|
724
|
-
def description(self, value: Optional[pulumi.Input[
|
|
743
|
+
def description(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
725
744
|
pulumi.set(self, "description", value)
|
|
726
745
|
|
|
727
|
-
@property
|
|
746
|
+
@_builtins.property
|
|
728
747
|
@pulumi.getter
|
|
729
|
-
def enabled(self) -> Optional[pulumi.Input[
|
|
748
|
+
def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
730
749
|
"""
|
|
731
750
|
Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
|
|
732
751
|
"""
|
|
733
752
|
return pulumi.get(self, "enabled")
|
|
734
753
|
|
|
735
754
|
@enabled.setter
|
|
736
|
-
def enabled(self, value: Optional[pulumi.Input[
|
|
755
|
+
def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
737
756
|
pulumi.set(self, "enabled", value)
|
|
738
757
|
|
|
739
|
-
@property
|
|
758
|
+
@_builtins.property
|
|
740
759
|
@pulumi.getter(name="entityGuid")
|
|
741
|
-
def entity_guid(self) -> Optional[pulumi.Input[
|
|
760
|
+
def entity_guid(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
742
761
|
"""
|
|
743
762
|
The unique entity identifier of the NRQL Condition in New Relic.
|
|
744
763
|
"""
|
|
745
764
|
return pulumi.get(self, "entity_guid")
|
|
746
765
|
|
|
747
766
|
@entity_guid.setter
|
|
748
|
-
def entity_guid(self, value: Optional[pulumi.Input[
|
|
767
|
+
def entity_guid(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
749
768
|
pulumi.set(self, "entity_guid", value)
|
|
750
769
|
|
|
751
|
-
@property
|
|
770
|
+
@_builtins.property
|
|
752
771
|
@pulumi.getter(name="evaluationDelay")
|
|
753
|
-
def evaluation_delay(self) -> Optional[pulumi.Input[
|
|
772
|
+
def evaluation_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
754
773
|
"""
|
|
755
774
|
How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
|
|
756
775
|
"""
|
|
757
776
|
return pulumi.get(self, "evaluation_delay")
|
|
758
777
|
|
|
759
778
|
@evaluation_delay.setter
|
|
760
|
-
def evaluation_delay(self, value: Optional[pulumi.Input[
|
|
779
|
+
def evaluation_delay(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
761
780
|
pulumi.set(self, "evaluation_delay", value)
|
|
762
781
|
|
|
763
|
-
@property
|
|
782
|
+
@_builtins.property
|
|
764
783
|
@pulumi.getter(name="expirationDuration")
|
|
765
|
-
def expiration_duration(self) -> Optional[pulumi.Input[
|
|
784
|
+
def expiration_duration(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
766
785
|
"""
|
|
767
786
|
The amount of time (in seconds) to wait before considering the signal expired. The value must be at least 30 seconds, and no more than 172800 seconds (48 hours).
|
|
768
787
|
"""
|
|
769
788
|
return pulumi.get(self, "expiration_duration")
|
|
770
789
|
|
|
771
790
|
@expiration_duration.setter
|
|
772
|
-
def expiration_duration(self, value: Optional[pulumi.Input[
|
|
791
|
+
def expiration_duration(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
773
792
|
pulumi.set(self, "expiration_duration", value)
|
|
774
793
|
|
|
775
|
-
@property
|
|
794
|
+
@_builtins.property
|
|
776
795
|
@pulumi.getter(name="fillOption")
|
|
777
|
-
def fill_option(self) -> Optional[pulumi.Input[
|
|
796
|
+
def fill_option(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
778
797
|
"""
|
|
779
798
|
Which strategy to use when filling gaps in the signal. Possible values are `none`, `last_value` or `static`. If `static`, the `fill_value` field will be used for filling gaps in the signal.
|
|
780
799
|
"""
|
|
781
800
|
return pulumi.get(self, "fill_option")
|
|
782
801
|
|
|
783
802
|
@fill_option.setter
|
|
784
|
-
def fill_option(self, value: Optional[pulumi.Input[
|
|
803
|
+
def fill_option(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
785
804
|
pulumi.set(self, "fill_option", value)
|
|
786
805
|
|
|
787
|
-
@property
|
|
806
|
+
@_builtins.property
|
|
788
807
|
@pulumi.getter(name="fillValue")
|
|
789
|
-
def fill_value(self) -> Optional[pulumi.Input[
|
|
808
|
+
def fill_value(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
790
809
|
"""
|
|
791
810
|
This value will be used for filling gaps in the signal.
|
|
792
811
|
"""
|
|
793
812
|
return pulumi.get(self, "fill_value")
|
|
794
813
|
|
|
795
814
|
@fill_value.setter
|
|
796
|
-
def fill_value(self, value: Optional[pulumi.Input[
|
|
815
|
+
def fill_value(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
797
816
|
pulumi.set(self, "fill_value", value)
|
|
798
817
|
|
|
799
|
-
@property
|
|
818
|
+
@_builtins.property
|
|
800
819
|
@pulumi.getter(name="ignoreOnExpectedTermination")
|
|
801
|
-
def ignore_on_expected_termination(self) -> Optional[pulumi.Input[
|
|
820
|
+
def ignore_on_expected_termination(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
802
821
|
"""
|
|
803
822
|
Whether an alert condition should ignore expected termination of a signal when considering whether to create a loss of signal incident. Defaults to false.
|
|
804
823
|
"""
|
|
805
824
|
return pulumi.get(self, "ignore_on_expected_termination")
|
|
806
825
|
|
|
807
826
|
@ignore_on_expected_termination.setter
|
|
808
|
-
def ignore_on_expected_termination(self, value: Optional[pulumi.Input[
|
|
827
|
+
def ignore_on_expected_termination(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
809
828
|
pulumi.set(self, "ignore_on_expected_termination", value)
|
|
810
829
|
|
|
811
|
-
@property
|
|
830
|
+
@_builtins.property
|
|
812
831
|
@pulumi.getter
|
|
813
|
-
def name(self) -> Optional[pulumi.Input[
|
|
832
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
814
833
|
"""
|
|
815
834
|
The title of the condition.
|
|
816
835
|
"""
|
|
817
836
|
return pulumi.get(self, "name")
|
|
818
837
|
|
|
819
838
|
@name.setter
|
|
820
|
-
def name(self, value: Optional[pulumi.Input[
|
|
839
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
821
840
|
pulumi.set(self, "name", value)
|
|
822
841
|
|
|
823
|
-
@property
|
|
842
|
+
@_builtins.property
|
|
824
843
|
@pulumi.getter
|
|
825
844
|
def nrql(self) -> Optional[pulumi.Input['NrqlAlertConditionNrqlArgs']]:
|
|
826
845
|
"""
|
|
@@ -832,67 +851,79 @@ class _NrqlAlertConditionState:
|
|
|
832
851
|
def nrql(self, value: Optional[pulumi.Input['NrqlAlertConditionNrqlArgs']]):
|
|
833
852
|
pulumi.set(self, "nrql", value)
|
|
834
853
|
|
|
835
|
-
@property
|
|
854
|
+
@_builtins.property
|
|
836
855
|
@pulumi.getter(name="openViolationOnExpiration")
|
|
837
|
-
def open_violation_on_expiration(self) -> Optional[pulumi.Input[
|
|
856
|
+
def open_violation_on_expiration(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
838
857
|
"""
|
|
839
858
|
Whether to create a new incident to capture that the signal expired.
|
|
840
859
|
"""
|
|
841
860
|
return pulumi.get(self, "open_violation_on_expiration")
|
|
842
861
|
|
|
843
862
|
@open_violation_on_expiration.setter
|
|
844
|
-
def open_violation_on_expiration(self, value: Optional[pulumi.Input[
|
|
863
|
+
def open_violation_on_expiration(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
845
864
|
pulumi.set(self, "open_violation_on_expiration", value)
|
|
846
865
|
|
|
847
|
-
@property
|
|
866
|
+
@_builtins.property
|
|
848
867
|
@pulumi.getter(name="policyId")
|
|
849
|
-
def policy_id(self) -> Optional[pulumi.Input[
|
|
868
|
+
def policy_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
850
869
|
"""
|
|
851
870
|
The ID of the policy where this condition should be used.
|
|
852
871
|
"""
|
|
853
872
|
return pulumi.get(self, "policy_id")
|
|
854
873
|
|
|
855
874
|
@policy_id.setter
|
|
856
|
-
def policy_id(self, value: Optional[pulumi.Input[
|
|
875
|
+
def policy_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
857
876
|
pulumi.set(self, "policy_id", value)
|
|
858
877
|
|
|
859
|
-
@property
|
|
878
|
+
@_builtins.property
|
|
860
879
|
@pulumi.getter(name="runbookUrl")
|
|
861
|
-
def runbook_url(self) -> Optional[pulumi.Input[
|
|
880
|
+
def runbook_url(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
862
881
|
"""
|
|
863
882
|
Runbook URL to display in notifications.
|
|
864
883
|
"""
|
|
865
884
|
return pulumi.get(self, "runbook_url")
|
|
866
885
|
|
|
867
886
|
@runbook_url.setter
|
|
868
|
-
def runbook_url(self, value: Optional[pulumi.Input[
|
|
887
|
+
def runbook_url(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
869
888
|
pulumi.set(self, "runbook_url", value)
|
|
870
889
|
|
|
871
|
-
@property
|
|
890
|
+
@_builtins.property
|
|
872
891
|
@pulumi.getter(name="signalSeasonality")
|
|
873
|
-
def signal_seasonality(self) -> Optional[pulumi.Input[
|
|
892
|
+
def signal_seasonality(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
874
893
|
"""
|
|
875
894
|
Seasonality under which a condition's signal(s) are evaluated. Only available for baseline conditions. Valid values are: `NEW_RELIC_CALCULATION`, `HOURLY`, `DAILY`, `WEEKLY`, or `NONE`. To have New Relic calculate seasonality automatically, set to `NEW_RELIC_CALCULATION`. To turn off seasonality completely, set to `NONE`.
|
|
876
895
|
"""
|
|
877
896
|
return pulumi.get(self, "signal_seasonality")
|
|
878
897
|
|
|
879
898
|
@signal_seasonality.setter
|
|
880
|
-
def signal_seasonality(self, value: Optional[pulumi.Input[
|
|
899
|
+
def signal_seasonality(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
881
900
|
pulumi.set(self, "signal_seasonality", value)
|
|
882
901
|
|
|
883
|
-
@property
|
|
902
|
+
@_builtins.property
|
|
884
903
|
@pulumi.getter(name="slideBy")
|
|
885
|
-
def slide_by(self) -> Optional[pulumi.Input[
|
|
904
|
+
def slide_by(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
886
905
|
"""
|
|
887
906
|
Gathers data in overlapping time windows to smooth the chart line, making it easier to spot trends. The `slide_by` value is specified in seconds and must be smaller than and a factor of the `aggregation_window`.
|
|
888
907
|
"""
|
|
889
908
|
return pulumi.get(self, "slide_by")
|
|
890
909
|
|
|
891
910
|
@slide_by.setter
|
|
892
|
-
def slide_by(self, value: Optional[pulumi.Input[
|
|
911
|
+
def slide_by(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
893
912
|
pulumi.set(self, "slide_by", value)
|
|
894
913
|
|
|
895
|
-
@property
|
|
914
|
+
@_builtins.property
|
|
915
|
+
@pulumi.getter(name="targetEntity")
|
|
916
|
+
def target_entity(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
917
|
+
"""
|
|
918
|
+
BETA PREVIEW: The GUID of the entity explicitly targeted by the condition. Issues triggered by this condition will affect the health status of this entity instead of having the affected entity detected automatically. The entity's account ID must be either `account_id` or `nrql.data_account_id`.
|
|
919
|
+
"""
|
|
920
|
+
return pulumi.get(self, "target_entity")
|
|
921
|
+
|
|
922
|
+
@target_entity.setter
|
|
923
|
+
def target_entity(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
924
|
+
pulumi.set(self, "target_entity", value)
|
|
925
|
+
|
|
926
|
+
@_builtins.property
|
|
896
927
|
@pulumi.getter
|
|
897
928
|
@_utilities.deprecated("""use `critical` and `warning` attributes instead""")
|
|
898
929
|
def terms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NrqlAlertConditionTermArgs']]]]:
|
|
@@ -905,34 +936,34 @@ class _NrqlAlertConditionState:
|
|
|
905
936
|
def terms(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NrqlAlertConditionTermArgs']]]]):
|
|
906
937
|
pulumi.set(self, "terms", value)
|
|
907
938
|
|
|
908
|
-
@property
|
|
939
|
+
@_builtins.property
|
|
909
940
|
@pulumi.getter(name="titleTemplate")
|
|
910
|
-
def title_template(self) -> Optional[pulumi.Input[
|
|
941
|
+
def title_template(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
911
942
|
"""
|
|
912
943
|
The custom title to be used when incidents are opened by the condition. Setting this field will override the default title. Must be [Handlebars](https://handlebarsjs.com/) format.
|
|
913
944
|
"""
|
|
914
945
|
return pulumi.get(self, "title_template")
|
|
915
946
|
|
|
916
947
|
@title_template.setter
|
|
917
|
-
def title_template(self, value: Optional[pulumi.Input[
|
|
948
|
+
def title_template(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
918
949
|
pulumi.set(self, "title_template", value)
|
|
919
950
|
|
|
920
|
-
@property
|
|
951
|
+
@_builtins.property
|
|
921
952
|
@pulumi.getter
|
|
922
|
-
def type(self) -> Optional[pulumi.Input[
|
|
953
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
923
954
|
"""
|
|
924
955
|
The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
|
|
925
956
|
"""
|
|
926
957
|
return pulumi.get(self, "type")
|
|
927
958
|
|
|
928
959
|
@type.setter
|
|
929
|
-
def type(self, value: Optional[pulumi.Input[
|
|
960
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
930
961
|
pulumi.set(self, "type", value)
|
|
931
962
|
|
|
932
|
-
@property
|
|
963
|
+
@_builtins.property
|
|
933
964
|
@pulumi.getter(name="violationTimeLimit")
|
|
934
965
|
@_utilities.deprecated("""use `violation_time_limit_seconds` attribute instead""")
|
|
935
|
-
def violation_time_limit(self) -> Optional[pulumi.Input[
|
|
966
|
+
def violation_time_limit(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
936
967
|
"""
|
|
937
968
|
**DEPRECATED:** Use `violation_time_limit_seconds` instead. Sets a time limit, in hours, that will automatically force-close a long-lasting incident after the time limit you select. Possible values are `ONE_HOUR`, `TWO_HOURS`, `FOUR_HOURS`, `EIGHT_HOURS`, `TWELVE_HOURS`, `TWENTY_FOUR_HOURS`, `THIRTY_DAYS` (case insensitive).<br>
|
|
938
969
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
@@ -940,12 +971,12 @@ class _NrqlAlertConditionState:
|
|
|
940
971
|
return pulumi.get(self, "violation_time_limit")
|
|
941
972
|
|
|
942
973
|
@violation_time_limit.setter
|
|
943
|
-
def violation_time_limit(self, value: Optional[pulumi.Input[
|
|
974
|
+
def violation_time_limit(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
944
975
|
pulumi.set(self, "violation_time_limit", value)
|
|
945
976
|
|
|
946
|
-
@property
|
|
977
|
+
@_builtins.property
|
|
947
978
|
@pulumi.getter(name="violationTimeLimitSeconds")
|
|
948
|
-
def violation_time_limit_seconds(self) -> Optional[pulumi.Input[
|
|
979
|
+
def violation_time_limit_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
949
980
|
"""
|
|
950
981
|
Sets a time limit, in seconds, that will automatically force-close a long-lasting incident after the time limit you select. The value must be between 300 seconds (5 minutes) to 2592000 seconds (30 days) (inclusive). <br>
|
|
951
982
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
@@ -953,10 +984,10 @@ class _NrqlAlertConditionState:
|
|
|
953
984
|
return pulumi.get(self, "violation_time_limit_seconds")
|
|
954
985
|
|
|
955
986
|
@violation_time_limit_seconds.setter
|
|
956
|
-
def violation_time_limit_seconds(self, value: Optional[pulumi.Input[
|
|
987
|
+
def violation_time_limit_seconds(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
957
988
|
pulumi.set(self, "violation_time_limit_seconds", value)
|
|
958
989
|
|
|
959
|
-
@property
|
|
990
|
+
@_builtins.property
|
|
960
991
|
@pulumi.getter
|
|
961
992
|
def warning(self) -> Optional[pulumi.Input['NrqlAlertConditionWarningArgs']]:
|
|
962
993
|
"""
|
|
@@ -975,33 +1006,34 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
975
1006
|
def __init__(__self__,
|
|
976
1007
|
resource_name: str,
|
|
977
1008
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
978
|
-
account_id: Optional[pulumi.Input[
|
|
979
|
-
aggregation_delay: Optional[pulumi.Input[
|
|
980
|
-
aggregation_method: Optional[pulumi.Input[
|
|
981
|
-
aggregation_timer: Optional[pulumi.Input[
|
|
982
|
-
aggregation_window: Optional[pulumi.Input[
|
|
983
|
-
baseline_direction: Optional[pulumi.Input[
|
|
984
|
-
close_violations_on_expiration: Optional[pulumi.Input[
|
|
1009
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1010
|
+
aggregation_delay: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1011
|
+
aggregation_method: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1012
|
+
aggregation_timer: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1013
|
+
aggregation_window: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1014
|
+
baseline_direction: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1015
|
+
close_violations_on_expiration: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
985
1016
|
critical: Optional[pulumi.Input[Union['NrqlAlertConditionCriticalArgs', 'NrqlAlertConditionCriticalArgsDict']]] = None,
|
|
986
|
-
description: Optional[pulumi.Input[
|
|
987
|
-
enabled: Optional[pulumi.Input[
|
|
988
|
-
evaluation_delay: Optional[pulumi.Input[
|
|
989
|
-
expiration_duration: Optional[pulumi.Input[
|
|
990
|
-
fill_option: Optional[pulumi.Input[
|
|
991
|
-
fill_value: Optional[pulumi.Input[
|
|
992
|
-
ignore_on_expected_termination: Optional[pulumi.Input[
|
|
993
|
-
name: Optional[pulumi.Input[
|
|
1017
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1018
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1019
|
+
evaluation_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1020
|
+
expiration_duration: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1021
|
+
fill_option: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1022
|
+
fill_value: Optional[pulumi.Input[_builtins.float]] = None,
|
|
1023
|
+
ignore_on_expected_termination: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1024
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
994
1025
|
nrql: Optional[pulumi.Input[Union['NrqlAlertConditionNrqlArgs', 'NrqlAlertConditionNrqlArgsDict']]] = None,
|
|
995
|
-
open_violation_on_expiration: Optional[pulumi.Input[
|
|
996
|
-
policy_id: Optional[pulumi.Input[
|
|
997
|
-
runbook_url: Optional[pulumi.Input[
|
|
998
|
-
signal_seasonality: Optional[pulumi.Input[
|
|
999
|
-
slide_by: Optional[pulumi.Input[
|
|
1026
|
+
open_violation_on_expiration: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1027
|
+
policy_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1028
|
+
runbook_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1029
|
+
signal_seasonality: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1030
|
+
slide_by: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1031
|
+
target_entity: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1000
1032
|
terms: Optional[pulumi.Input[Sequence[pulumi.Input[Union['NrqlAlertConditionTermArgs', 'NrqlAlertConditionTermArgsDict']]]]] = None,
|
|
1001
|
-
title_template: Optional[pulumi.Input[
|
|
1002
|
-
type: Optional[pulumi.Input[
|
|
1003
|
-
violation_time_limit: Optional[pulumi.Input[
|
|
1004
|
-
violation_time_limit_seconds: Optional[pulumi.Input[
|
|
1033
|
+
title_template: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1034
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1035
|
+
violation_time_limit: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1036
|
+
violation_time_limit_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1005
1037
|
warning: Optional[pulumi.Input[Union['NrqlAlertConditionWarningArgs', 'NrqlAlertConditionWarningArgsDict']]] = None,
|
|
1006
1038
|
__props__=None):
|
|
1007
1039
|
"""
|
|
@@ -1023,6 +1055,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1023
1055
|
name="foo",
|
|
1024
1056
|
description="Alert when transactions are taking too long",
|
|
1025
1057
|
title_template="Issue in environment: {{ tags.environment }}",
|
|
1058
|
+
target_entity="MXxBUE18QVBQTElDQVRJT058MQ",
|
|
1026
1059
|
runbook_url="https://www.example.com",
|
|
1027
1060
|
enabled=True,
|
|
1028
1061
|
violation_time_limit_seconds=3600,
|
|
@@ -1280,34 +1313,35 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1280
1313
|
|
|
1281
1314
|
:param str resource_name: The name of the resource.
|
|
1282
1315
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1283
|
-
:param pulumi.Input[
|
|
1284
|
-
:param pulumi.Input[
|
|
1285
|
-
:param pulumi.Input[
|
|
1286
|
-
:param pulumi.Input[
|
|
1287
|
-
:param pulumi.Input[
|
|
1288
|
-
:param pulumi.Input[
|
|
1289
|
-
:param pulumi.Input[
|
|
1316
|
+
:param pulumi.Input[_builtins.str] account_id: The New Relic account ID of the account you wish to create the condition. Defaults to the account ID set in your environment variable `NEW_RELIC_ACCOUNT_ID`.
|
|
1317
|
+
:param pulumi.Input[_builtins.str] aggregation_delay: How long we wait for data that belongs in each aggregation window. Depending on your data, a longer delay may increase accuracy but delay notifications. Use `aggregation_delay` with the `event_flow` and `cadence` methods. The maximum delay is 1200 seconds (20 minutes) when using `event_flow` and 3600 seconds (60 minutes) when using `cadence`. In both cases, the minimum delay is 0 seconds and the default is 120 seconds. `aggregation_delay` cannot be set with `nrql.evaluation_offset`.
|
|
1318
|
+
:param pulumi.Input[_builtins.str] aggregation_method: Determines when we consider an aggregation window to be complete so that we can evaluate the signal for incidents. Possible values are `cadence`, `event_flow` or `event_timer`. Default is `event_flow`. `aggregation_method` cannot be set with `nrql.evaluation_offset`.
|
|
1319
|
+
:param pulumi.Input[_builtins.str] aggregation_timer: How long we wait after each data point arrives to make sure we've processed the whole batch. Use `aggregation_timer` with the `event_timer` method. The timer value can range from 0 seconds to 1200 seconds (20 minutes); the default is 60 seconds. `aggregation_timer` cannot be set with `nrql.evaluation_offset`.
|
|
1320
|
+
:param pulumi.Input[_builtins.int] aggregation_window: The duration of the time window used to evaluate the NRQL query, in seconds. The value must be at least 30 seconds, and no more than 21600 seconds (6 hours). Default is 60 seconds.
|
|
1321
|
+
:param pulumi.Input[_builtins.str] baseline_direction: The baseline direction of a _baseline_ NRQL alert condition. Valid values are: `lower_only`, `upper_and_lower`, `upper_only` (case insensitive).
|
|
1322
|
+
:param pulumi.Input[_builtins.bool] close_violations_on_expiration: Whether to close all open incidents when the signal expires.
|
|
1290
1323
|
:param pulumi.Input[Union['NrqlAlertConditionCriticalArgs', 'NrqlAlertConditionCriticalArgsDict']] critical: A list containing the `critical` threshold values. At least one `critical` or `warning` threshold must be defined. See Terms below for details.
|
|
1291
|
-
:param pulumi.Input[
|
|
1292
|
-
:param pulumi.Input[
|
|
1293
|
-
:param pulumi.Input[
|
|
1294
|
-
:param pulumi.Input[
|
|
1295
|
-
:param pulumi.Input[
|
|
1296
|
-
:param pulumi.Input[
|
|
1297
|
-
:param pulumi.Input[
|
|
1298
|
-
:param pulumi.Input[
|
|
1324
|
+
:param pulumi.Input[_builtins.str] description: The description of the NRQL alert condition.
|
|
1325
|
+
:param pulumi.Input[_builtins.bool] enabled: Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
|
|
1326
|
+
:param pulumi.Input[_builtins.int] evaluation_delay: How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
|
|
1327
|
+
:param pulumi.Input[_builtins.int] expiration_duration: The amount of time (in seconds) to wait before considering the signal expired. The value must be at least 30 seconds, and no more than 172800 seconds (48 hours).
|
|
1328
|
+
:param pulumi.Input[_builtins.str] fill_option: Which strategy to use when filling gaps in the signal. Possible values are `none`, `last_value` or `static`. If `static`, the `fill_value` field will be used for filling gaps in the signal.
|
|
1329
|
+
:param pulumi.Input[_builtins.float] fill_value: This value will be used for filling gaps in the signal.
|
|
1330
|
+
:param pulumi.Input[_builtins.bool] ignore_on_expected_termination: Whether an alert condition should ignore expected termination of a signal when considering whether to create a loss of signal incident. Defaults to false.
|
|
1331
|
+
:param pulumi.Input[_builtins.str] name: The title of the condition.
|
|
1299
1332
|
:param pulumi.Input[Union['NrqlAlertConditionNrqlArgs', 'NrqlAlertConditionNrqlArgsDict']] nrql: A NRQL query. See NRQL below for details.
|
|
1300
|
-
:param pulumi.Input[
|
|
1301
|
-
:param pulumi.Input[
|
|
1302
|
-
:param pulumi.Input[
|
|
1303
|
-
:param pulumi.Input[
|
|
1304
|
-
:param pulumi.Input[
|
|
1333
|
+
:param pulumi.Input[_builtins.bool] open_violation_on_expiration: Whether to create a new incident to capture that the signal expired.
|
|
1334
|
+
:param pulumi.Input[_builtins.str] policy_id: The ID of the policy where this condition should be used.
|
|
1335
|
+
:param pulumi.Input[_builtins.str] runbook_url: Runbook URL to display in notifications.
|
|
1336
|
+
:param pulumi.Input[_builtins.str] signal_seasonality: Seasonality under which a condition's signal(s) are evaluated. Only available for baseline conditions. Valid values are: `NEW_RELIC_CALCULATION`, `HOURLY`, `DAILY`, `WEEKLY`, or `NONE`. To have New Relic calculate seasonality automatically, set to `NEW_RELIC_CALCULATION`. To turn off seasonality completely, set to `NONE`.
|
|
1337
|
+
:param pulumi.Input[_builtins.int] slide_by: Gathers data in overlapping time windows to smooth the chart line, making it easier to spot trends. The `slide_by` value is specified in seconds and must be smaller than and a factor of the `aggregation_window`.
|
|
1338
|
+
:param pulumi.Input[_builtins.str] target_entity: BETA PREVIEW: The GUID of the entity explicitly targeted by the condition. Issues triggered by this condition will affect the health status of this entity instead of having the affected entity detected automatically. The entity's account ID must be either `account_id` or `nrql.data_account_id`.
|
|
1305
1339
|
:param pulumi.Input[Sequence[pulumi.Input[Union['NrqlAlertConditionTermArgs', 'NrqlAlertConditionTermArgsDict']]]] terms: **DEPRECATED** Use `critical`, and `warning` instead. A list of terms for this condition. See Terms below for details.
|
|
1306
|
-
:param pulumi.Input[
|
|
1307
|
-
:param pulumi.Input[
|
|
1308
|
-
:param pulumi.Input[
|
|
1340
|
+
:param pulumi.Input[_builtins.str] title_template: The custom title to be used when incidents are opened by the condition. Setting this field will override the default title. Must be [Handlebars](https://handlebarsjs.com/) format.
|
|
1341
|
+
:param pulumi.Input[_builtins.str] type: The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
|
|
1342
|
+
:param pulumi.Input[_builtins.str] violation_time_limit: **DEPRECATED:** Use `violation_time_limit_seconds` instead. Sets a time limit, in hours, that will automatically force-close a long-lasting incident after the time limit you select. Possible values are `ONE_HOUR`, `TWO_HOURS`, `FOUR_HOURS`, `EIGHT_HOURS`, `TWELVE_HOURS`, `TWENTY_FOUR_HOURS`, `THIRTY_DAYS` (case insensitive).<br>
|
|
1309
1343
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
1310
|
-
:param pulumi.Input[
|
|
1344
|
+
:param pulumi.Input[_builtins.int] violation_time_limit_seconds: Sets a time limit, in seconds, that will automatically force-close a long-lasting incident after the time limit you select. The value must be between 300 seconds (5 minutes) to 2592000 seconds (30 days) (inclusive). <br>
|
|
1311
1345
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
1312
1346
|
:param pulumi.Input[Union['NrqlAlertConditionWarningArgs', 'NrqlAlertConditionWarningArgsDict']] warning: A list containing the `warning` threshold values. At least one `critical` or `warning` threshold must be defined. See Terms below for details.
|
|
1313
1347
|
"""
|
|
@@ -1336,6 +1370,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1336
1370
|
name="foo",
|
|
1337
1371
|
description="Alert when transactions are taking too long",
|
|
1338
1372
|
title_template="Issue in environment: {{ tags.environment }}",
|
|
1373
|
+
target_entity="MXxBUE18QVBQTElDQVRJT058MQ",
|
|
1339
1374
|
runbook_url="https://www.example.com",
|
|
1340
1375
|
enabled=True,
|
|
1341
1376
|
violation_time_limit_seconds=3600,
|
|
@@ -1606,33 +1641,34 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1606
1641
|
def _internal_init(__self__,
|
|
1607
1642
|
resource_name: str,
|
|
1608
1643
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1609
|
-
account_id: Optional[pulumi.Input[
|
|
1610
|
-
aggregation_delay: Optional[pulumi.Input[
|
|
1611
|
-
aggregation_method: Optional[pulumi.Input[
|
|
1612
|
-
aggregation_timer: Optional[pulumi.Input[
|
|
1613
|
-
aggregation_window: Optional[pulumi.Input[
|
|
1614
|
-
baseline_direction: Optional[pulumi.Input[
|
|
1615
|
-
close_violations_on_expiration: Optional[pulumi.Input[
|
|
1644
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1645
|
+
aggregation_delay: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1646
|
+
aggregation_method: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1647
|
+
aggregation_timer: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1648
|
+
aggregation_window: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1649
|
+
baseline_direction: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1650
|
+
close_violations_on_expiration: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1616
1651
|
critical: Optional[pulumi.Input[Union['NrqlAlertConditionCriticalArgs', 'NrqlAlertConditionCriticalArgsDict']]] = None,
|
|
1617
|
-
description: Optional[pulumi.Input[
|
|
1618
|
-
enabled: Optional[pulumi.Input[
|
|
1619
|
-
evaluation_delay: Optional[pulumi.Input[
|
|
1620
|
-
expiration_duration: Optional[pulumi.Input[
|
|
1621
|
-
fill_option: Optional[pulumi.Input[
|
|
1622
|
-
fill_value: Optional[pulumi.Input[
|
|
1623
|
-
ignore_on_expected_termination: Optional[pulumi.Input[
|
|
1624
|
-
name: Optional[pulumi.Input[
|
|
1652
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1653
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1654
|
+
evaluation_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1655
|
+
expiration_duration: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1656
|
+
fill_option: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1657
|
+
fill_value: Optional[pulumi.Input[_builtins.float]] = None,
|
|
1658
|
+
ignore_on_expected_termination: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1659
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1625
1660
|
nrql: Optional[pulumi.Input[Union['NrqlAlertConditionNrqlArgs', 'NrqlAlertConditionNrqlArgsDict']]] = None,
|
|
1626
|
-
open_violation_on_expiration: Optional[pulumi.Input[
|
|
1627
|
-
policy_id: Optional[pulumi.Input[
|
|
1628
|
-
runbook_url: Optional[pulumi.Input[
|
|
1629
|
-
signal_seasonality: Optional[pulumi.Input[
|
|
1630
|
-
slide_by: Optional[pulumi.Input[
|
|
1661
|
+
open_violation_on_expiration: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1662
|
+
policy_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1663
|
+
runbook_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1664
|
+
signal_seasonality: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1665
|
+
slide_by: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1666
|
+
target_entity: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1631
1667
|
terms: Optional[pulumi.Input[Sequence[pulumi.Input[Union['NrqlAlertConditionTermArgs', 'NrqlAlertConditionTermArgsDict']]]]] = None,
|
|
1632
|
-
title_template: Optional[pulumi.Input[
|
|
1633
|
-
type: Optional[pulumi.Input[
|
|
1634
|
-
violation_time_limit: Optional[pulumi.Input[
|
|
1635
|
-
violation_time_limit_seconds: Optional[pulumi.Input[
|
|
1668
|
+
title_template: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1669
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1670
|
+
violation_time_limit: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1671
|
+
violation_time_limit_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1636
1672
|
warning: Optional[pulumi.Input[Union['NrqlAlertConditionWarningArgs', 'NrqlAlertConditionWarningArgsDict']]] = None,
|
|
1637
1673
|
__props__=None):
|
|
1638
1674
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
@@ -1669,6 +1705,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1669
1705
|
__props__.__dict__["runbook_url"] = runbook_url
|
|
1670
1706
|
__props__.__dict__["signal_seasonality"] = signal_seasonality
|
|
1671
1707
|
__props__.__dict__["slide_by"] = slide_by
|
|
1708
|
+
__props__.__dict__["target_entity"] = target_entity
|
|
1672
1709
|
__props__.__dict__["terms"] = terms
|
|
1673
1710
|
__props__.__dict__["title_template"] = title_template
|
|
1674
1711
|
__props__.__dict__["type"] = type
|
|
@@ -1686,34 +1723,35 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1686
1723
|
def get(resource_name: str,
|
|
1687
1724
|
id: pulumi.Input[str],
|
|
1688
1725
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1689
|
-
account_id: Optional[pulumi.Input[
|
|
1690
|
-
aggregation_delay: Optional[pulumi.Input[
|
|
1691
|
-
aggregation_method: Optional[pulumi.Input[
|
|
1692
|
-
aggregation_timer: Optional[pulumi.Input[
|
|
1693
|
-
aggregation_window: Optional[pulumi.Input[
|
|
1694
|
-
baseline_direction: Optional[pulumi.Input[
|
|
1695
|
-
close_violations_on_expiration: Optional[pulumi.Input[
|
|
1726
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1727
|
+
aggregation_delay: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1728
|
+
aggregation_method: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1729
|
+
aggregation_timer: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1730
|
+
aggregation_window: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1731
|
+
baseline_direction: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1732
|
+
close_violations_on_expiration: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1696
1733
|
critical: Optional[pulumi.Input[Union['NrqlAlertConditionCriticalArgs', 'NrqlAlertConditionCriticalArgsDict']]] = None,
|
|
1697
|
-
description: Optional[pulumi.Input[
|
|
1698
|
-
enabled: Optional[pulumi.Input[
|
|
1699
|
-
entity_guid: Optional[pulumi.Input[
|
|
1700
|
-
evaluation_delay: Optional[pulumi.Input[
|
|
1701
|
-
expiration_duration: Optional[pulumi.Input[
|
|
1702
|
-
fill_option: Optional[pulumi.Input[
|
|
1703
|
-
fill_value: Optional[pulumi.Input[
|
|
1704
|
-
ignore_on_expected_termination: Optional[pulumi.Input[
|
|
1705
|
-
name: Optional[pulumi.Input[
|
|
1734
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1735
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1736
|
+
entity_guid: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1737
|
+
evaluation_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1738
|
+
expiration_duration: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1739
|
+
fill_option: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1740
|
+
fill_value: Optional[pulumi.Input[_builtins.float]] = None,
|
|
1741
|
+
ignore_on_expected_termination: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1742
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1706
1743
|
nrql: Optional[pulumi.Input[Union['NrqlAlertConditionNrqlArgs', 'NrqlAlertConditionNrqlArgsDict']]] = None,
|
|
1707
|
-
open_violation_on_expiration: Optional[pulumi.Input[
|
|
1708
|
-
policy_id: Optional[pulumi.Input[
|
|
1709
|
-
runbook_url: Optional[pulumi.Input[
|
|
1710
|
-
signal_seasonality: Optional[pulumi.Input[
|
|
1711
|
-
slide_by: Optional[pulumi.Input[
|
|
1744
|
+
open_violation_on_expiration: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1745
|
+
policy_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1746
|
+
runbook_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1747
|
+
signal_seasonality: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1748
|
+
slide_by: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1749
|
+
target_entity: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1712
1750
|
terms: Optional[pulumi.Input[Sequence[pulumi.Input[Union['NrqlAlertConditionTermArgs', 'NrqlAlertConditionTermArgsDict']]]]] = None,
|
|
1713
|
-
title_template: Optional[pulumi.Input[
|
|
1714
|
-
type: Optional[pulumi.Input[
|
|
1715
|
-
violation_time_limit: Optional[pulumi.Input[
|
|
1716
|
-
violation_time_limit_seconds: Optional[pulumi.Input[
|
|
1751
|
+
title_template: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1752
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1753
|
+
violation_time_limit: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1754
|
+
violation_time_limit_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1717
1755
|
warning: Optional[pulumi.Input[Union['NrqlAlertConditionWarningArgs', 'NrqlAlertConditionWarningArgsDict']]] = None) -> 'NrqlAlertCondition':
|
|
1718
1756
|
"""
|
|
1719
1757
|
Get an existing NrqlAlertCondition resource's state with the given name, id, and optional extra
|
|
@@ -1722,35 +1760,36 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1722
1760
|
:param str resource_name: The unique name of the resulting resource.
|
|
1723
1761
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1724
1762
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1725
|
-
:param pulumi.Input[
|
|
1726
|
-
:param pulumi.Input[
|
|
1727
|
-
:param pulumi.Input[
|
|
1728
|
-
:param pulumi.Input[
|
|
1729
|
-
:param pulumi.Input[
|
|
1730
|
-
:param pulumi.Input[
|
|
1731
|
-
:param pulumi.Input[
|
|
1763
|
+
:param pulumi.Input[_builtins.str] account_id: The New Relic account ID of the account you wish to create the condition. Defaults to the account ID set in your environment variable `NEW_RELIC_ACCOUNT_ID`.
|
|
1764
|
+
:param pulumi.Input[_builtins.str] aggregation_delay: How long we wait for data that belongs in each aggregation window. Depending on your data, a longer delay may increase accuracy but delay notifications. Use `aggregation_delay` with the `event_flow` and `cadence` methods. The maximum delay is 1200 seconds (20 minutes) when using `event_flow` and 3600 seconds (60 minutes) when using `cadence`. In both cases, the minimum delay is 0 seconds and the default is 120 seconds. `aggregation_delay` cannot be set with `nrql.evaluation_offset`.
|
|
1765
|
+
:param pulumi.Input[_builtins.str] aggregation_method: Determines when we consider an aggregation window to be complete so that we can evaluate the signal for incidents. Possible values are `cadence`, `event_flow` or `event_timer`. Default is `event_flow`. `aggregation_method` cannot be set with `nrql.evaluation_offset`.
|
|
1766
|
+
:param pulumi.Input[_builtins.str] aggregation_timer: How long we wait after each data point arrives to make sure we've processed the whole batch. Use `aggregation_timer` with the `event_timer` method. The timer value can range from 0 seconds to 1200 seconds (20 minutes); the default is 60 seconds. `aggregation_timer` cannot be set with `nrql.evaluation_offset`.
|
|
1767
|
+
:param pulumi.Input[_builtins.int] aggregation_window: The duration of the time window used to evaluate the NRQL query, in seconds. The value must be at least 30 seconds, and no more than 21600 seconds (6 hours). Default is 60 seconds.
|
|
1768
|
+
:param pulumi.Input[_builtins.str] baseline_direction: The baseline direction of a _baseline_ NRQL alert condition. Valid values are: `lower_only`, `upper_and_lower`, `upper_only` (case insensitive).
|
|
1769
|
+
:param pulumi.Input[_builtins.bool] close_violations_on_expiration: Whether to close all open incidents when the signal expires.
|
|
1732
1770
|
:param pulumi.Input[Union['NrqlAlertConditionCriticalArgs', 'NrqlAlertConditionCriticalArgsDict']] critical: A list containing the `critical` threshold values. At least one `critical` or `warning` threshold must be defined. See Terms below for details.
|
|
1733
|
-
:param pulumi.Input[
|
|
1734
|
-
:param pulumi.Input[
|
|
1735
|
-
:param pulumi.Input[
|
|
1736
|
-
:param pulumi.Input[
|
|
1737
|
-
:param pulumi.Input[
|
|
1738
|
-
:param pulumi.Input[
|
|
1739
|
-
:param pulumi.Input[
|
|
1740
|
-
:param pulumi.Input[
|
|
1741
|
-
:param pulumi.Input[
|
|
1771
|
+
:param pulumi.Input[_builtins.str] description: The description of the NRQL alert condition.
|
|
1772
|
+
:param pulumi.Input[_builtins.bool] enabled: Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
|
|
1773
|
+
:param pulumi.Input[_builtins.str] entity_guid: The unique entity identifier of the NRQL Condition in New Relic.
|
|
1774
|
+
:param pulumi.Input[_builtins.int] evaluation_delay: How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
|
|
1775
|
+
:param pulumi.Input[_builtins.int] expiration_duration: The amount of time (in seconds) to wait before considering the signal expired. The value must be at least 30 seconds, and no more than 172800 seconds (48 hours).
|
|
1776
|
+
:param pulumi.Input[_builtins.str] fill_option: Which strategy to use when filling gaps in the signal. Possible values are `none`, `last_value` or `static`. If `static`, the `fill_value` field will be used for filling gaps in the signal.
|
|
1777
|
+
:param pulumi.Input[_builtins.float] fill_value: This value will be used for filling gaps in the signal.
|
|
1778
|
+
:param pulumi.Input[_builtins.bool] ignore_on_expected_termination: Whether an alert condition should ignore expected termination of a signal when considering whether to create a loss of signal incident. Defaults to false.
|
|
1779
|
+
:param pulumi.Input[_builtins.str] name: The title of the condition.
|
|
1742
1780
|
:param pulumi.Input[Union['NrqlAlertConditionNrqlArgs', 'NrqlAlertConditionNrqlArgsDict']] nrql: A NRQL query. See NRQL below for details.
|
|
1743
|
-
:param pulumi.Input[
|
|
1744
|
-
:param pulumi.Input[
|
|
1745
|
-
:param pulumi.Input[
|
|
1746
|
-
:param pulumi.Input[
|
|
1747
|
-
:param pulumi.Input[
|
|
1781
|
+
:param pulumi.Input[_builtins.bool] open_violation_on_expiration: Whether to create a new incident to capture that the signal expired.
|
|
1782
|
+
:param pulumi.Input[_builtins.str] policy_id: The ID of the policy where this condition should be used.
|
|
1783
|
+
:param pulumi.Input[_builtins.str] runbook_url: Runbook URL to display in notifications.
|
|
1784
|
+
:param pulumi.Input[_builtins.str] signal_seasonality: Seasonality under which a condition's signal(s) are evaluated. Only available for baseline conditions. Valid values are: `NEW_RELIC_CALCULATION`, `HOURLY`, `DAILY`, `WEEKLY`, or `NONE`. To have New Relic calculate seasonality automatically, set to `NEW_RELIC_CALCULATION`. To turn off seasonality completely, set to `NONE`.
|
|
1785
|
+
:param pulumi.Input[_builtins.int] slide_by: Gathers data in overlapping time windows to smooth the chart line, making it easier to spot trends. The `slide_by` value is specified in seconds and must be smaller than and a factor of the `aggregation_window`.
|
|
1786
|
+
:param pulumi.Input[_builtins.str] target_entity: BETA PREVIEW: The GUID of the entity explicitly targeted by the condition. Issues triggered by this condition will affect the health status of this entity instead of having the affected entity detected automatically. The entity's account ID must be either `account_id` or `nrql.data_account_id`.
|
|
1748
1787
|
:param pulumi.Input[Sequence[pulumi.Input[Union['NrqlAlertConditionTermArgs', 'NrqlAlertConditionTermArgsDict']]]] terms: **DEPRECATED** Use `critical`, and `warning` instead. A list of terms for this condition. See Terms below for details.
|
|
1749
|
-
:param pulumi.Input[
|
|
1750
|
-
:param pulumi.Input[
|
|
1751
|
-
:param pulumi.Input[
|
|
1788
|
+
:param pulumi.Input[_builtins.str] title_template: The custom title to be used when incidents are opened by the condition. Setting this field will override the default title. Must be [Handlebars](https://handlebarsjs.com/) format.
|
|
1789
|
+
:param pulumi.Input[_builtins.str] type: The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
|
|
1790
|
+
:param pulumi.Input[_builtins.str] violation_time_limit: **DEPRECATED:** Use `violation_time_limit_seconds` instead. Sets a time limit, in hours, that will automatically force-close a long-lasting incident after the time limit you select. Possible values are `ONE_HOUR`, `TWO_HOURS`, `FOUR_HOURS`, `EIGHT_HOURS`, `TWELVE_HOURS`, `TWENTY_FOUR_HOURS`, `THIRTY_DAYS` (case insensitive).<br>
|
|
1752
1791
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
1753
|
-
:param pulumi.Input[
|
|
1792
|
+
:param pulumi.Input[_builtins.int] violation_time_limit_seconds: Sets a time limit, in seconds, that will automatically force-close a long-lasting incident after the time limit you select. The value must be between 300 seconds (5 minutes) to 2592000 seconds (30 days) (inclusive). <br>
|
|
1754
1793
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
1755
1794
|
:param pulumi.Input[Union['NrqlAlertConditionWarningArgs', 'NrqlAlertConditionWarningArgsDict']] warning: A list containing the `warning` threshold values. At least one `critical` or `warning` threshold must be defined. See Terms below for details.
|
|
1756
1795
|
"""
|
|
@@ -1781,6 +1820,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1781
1820
|
__props__.__dict__["runbook_url"] = runbook_url
|
|
1782
1821
|
__props__.__dict__["signal_seasonality"] = signal_seasonality
|
|
1783
1822
|
__props__.__dict__["slide_by"] = slide_by
|
|
1823
|
+
__props__.__dict__["target_entity"] = target_entity
|
|
1784
1824
|
__props__.__dict__["terms"] = terms
|
|
1785
1825
|
__props__.__dict__["title_template"] = title_template
|
|
1786
1826
|
__props__.__dict__["type"] = type
|
|
@@ -1789,63 +1829,63 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1789
1829
|
__props__.__dict__["warning"] = warning
|
|
1790
1830
|
return NrqlAlertCondition(resource_name, opts=opts, __props__=__props__)
|
|
1791
1831
|
|
|
1792
|
-
@property
|
|
1832
|
+
@_builtins.property
|
|
1793
1833
|
@pulumi.getter(name="accountId")
|
|
1794
|
-
def account_id(self) -> pulumi.Output[
|
|
1834
|
+
def account_id(self) -> pulumi.Output[_builtins.str]:
|
|
1795
1835
|
"""
|
|
1796
1836
|
The New Relic account ID of the account you wish to create the condition. Defaults to the account ID set in your environment variable `NEW_RELIC_ACCOUNT_ID`.
|
|
1797
1837
|
"""
|
|
1798
1838
|
return pulumi.get(self, "account_id")
|
|
1799
1839
|
|
|
1800
|
-
@property
|
|
1840
|
+
@_builtins.property
|
|
1801
1841
|
@pulumi.getter(name="aggregationDelay")
|
|
1802
|
-
def aggregation_delay(self) -> pulumi.Output[Optional[
|
|
1842
|
+
def aggregation_delay(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1803
1843
|
"""
|
|
1804
1844
|
How long we wait for data that belongs in each aggregation window. Depending on your data, a longer delay may increase accuracy but delay notifications. Use `aggregation_delay` with the `event_flow` and `cadence` methods. The maximum delay is 1200 seconds (20 minutes) when using `event_flow` and 3600 seconds (60 minutes) when using `cadence`. In both cases, the minimum delay is 0 seconds and the default is 120 seconds. `aggregation_delay` cannot be set with `nrql.evaluation_offset`.
|
|
1805
1845
|
"""
|
|
1806
1846
|
return pulumi.get(self, "aggregation_delay")
|
|
1807
1847
|
|
|
1808
|
-
@property
|
|
1848
|
+
@_builtins.property
|
|
1809
1849
|
@pulumi.getter(name="aggregationMethod")
|
|
1810
|
-
def aggregation_method(self) -> pulumi.Output[Optional[
|
|
1850
|
+
def aggregation_method(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1811
1851
|
"""
|
|
1812
1852
|
Determines when we consider an aggregation window to be complete so that we can evaluate the signal for incidents. Possible values are `cadence`, `event_flow` or `event_timer`. Default is `event_flow`. `aggregation_method` cannot be set with `nrql.evaluation_offset`.
|
|
1813
1853
|
"""
|
|
1814
1854
|
return pulumi.get(self, "aggregation_method")
|
|
1815
1855
|
|
|
1816
|
-
@property
|
|
1856
|
+
@_builtins.property
|
|
1817
1857
|
@pulumi.getter(name="aggregationTimer")
|
|
1818
|
-
def aggregation_timer(self) -> pulumi.Output[Optional[
|
|
1858
|
+
def aggregation_timer(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1819
1859
|
"""
|
|
1820
1860
|
How long we wait after each data point arrives to make sure we've processed the whole batch. Use `aggregation_timer` with the `event_timer` method. The timer value can range from 0 seconds to 1200 seconds (20 minutes); the default is 60 seconds. `aggregation_timer` cannot be set with `nrql.evaluation_offset`.
|
|
1821
1861
|
"""
|
|
1822
1862
|
return pulumi.get(self, "aggregation_timer")
|
|
1823
1863
|
|
|
1824
|
-
@property
|
|
1864
|
+
@_builtins.property
|
|
1825
1865
|
@pulumi.getter(name="aggregationWindow")
|
|
1826
|
-
def aggregation_window(self) -> pulumi.Output[
|
|
1866
|
+
def aggregation_window(self) -> pulumi.Output[_builtins.int]:
|
|
1827
1867
|
"""
|
|
1828
1868
|
The duration of the time window used to evaluate the NRQL query, in seconds. The value must be at least 30 seconds, and no more than 21600 seconds (6 hours). Default is 60 seconds.
|
|
1829
1869
|
"""
|
|
1830
1870
|
return pulumi.get(self, "aggregation_window")
|
|
1831
1871
|
|
|
1832
|
-
@property
|
|
1872
|
+
@_builtins.property
|
|
1833
1873
|
@pulumi.getter(name="baselineDirection")
|
|
1834
|
-
def baseline_direction(self) -> pulumi.Output[Optional[
|
|
1874
|
+
def baseline_direction(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1835
1875
|
"""
|
|
1836
1876
|
The baseline direction of a _baseline_ NRQL alert condition. Valid values are: `lower_only`, `upper_and_lower`, `upper_only` (case insensitive).
|
|
1837
1877
|
"""
|
|
1838
1878
|
return pulumi.get(self, "baseline_direction")
|
|
1839
1879
|
|
|
1840
|
-
@property
|
|
1880
|
+
@_builtins.property
|
|
1841
1881
|
@pulumi.getter(name="closeViolationsOnExpiration")
|
|
1842
|
-
def close_violations_on_expiration(self) -> pulumi.Output[Optional[
|
|
1882
|
+
def close_violations_on_expiration(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1843
1883
|
"""
|
|
1844
1884
|
Whether to close all open incidents when the signal expires.
|
|
1845
1885
|
"""
|
|
1846
1886
|
return pulumi.get(self, "close_violations_on_expiration")
|
|
1847
1887
|
|
|
1848
|
-
@property
|
|
1888
|
+
@_builtins.property
|
|
1849
1889
|
@pulumi.getter
|
|
1850
1890
|
def critical(self) -> pulumi.Output[Optional['outputs.NrqlAlertConditionCritical']]:
|
|
1851
1891
|
"""
|
|
@@ -1853,79 +1893,79 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1853
1893
|
"""
|
|
1854
1894
|
return pulumi.get(self, "critical")
|
|
1855
1895
|
|
|
1856
|
-
@property
|
|
1896
|
+
@_builtins.property
|
|
1857
1897
|
@pulumi.getter
|
|
1858
|
-
def description(self) -> pulumi.Output[Optional[
|
|
1898
|
+
def description(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1859
1899
|
"""
|
|
1860
1900
|
The description of the NRQL alert condition.
|
|
1861
1901
|
"""
|
|
1862
1902
|
return pulumi.get(self, "description")
|
|
1863
1903
|
|
|
1864
|
-
@property
|
|
1904
|
+
@_builtins.property
|
|
1865
1905
|
@pulumi.getter
|
|
1866
|
-
def enabled(self) -> pulumi.Output[Optional[
|
|
1906
|
+
def enabled(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1867
1907
|
"""
|
|
1868
1908
|
Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
|
|
1869
1909
|
"""
|
|
1870
1910
|
return pulumi.get(self, "enabled")
|
|
1871
1911
|
|
|
1872
|
-
@property
|
|
1912
|
+
@_builtins.property
|
|
1873
1913
|
@pulumi.getter(name="entityGuid")
|
|
1874
|
-
def entity_guid(self) -> pulumi.Output[
|
|
1914
|
+
def entity_guid(self) -> pulumi.Output[_builtins.str]:
|
|
1875
1915
|
"""
|
|
1876
1916
|
The unique entity identifier of the NRQL Condition in New Relic.
|
|
1877
1917
|
"""
|
|
1878
1918
|
return pulumi.get(self, "entity_guid")
|
|
1879
1919
|
|
|
1880
|
-
@property
|
|
1920
|
+
@_builtins.property
|
|
1881
1921
|
@pulumi.getter(name="evaluationDelay")
|
|
1882
|
-
def evaluation_delay(self) -> pulumi.Output[Optional[
|
|
1922
|
+
def evaluation_delay(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1883
1923
|
"""
|
|
1884
1924
|
How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
|
|
1885
1925
|
"""
|
|
1886
1926
|
return pulumi.get(self, "evaluation_delay")
|
|
1887
1927
|
|
|
1888
|
-
@property
|
|
1928
|
+
@_builtins.property
|
|
1889
1929
|
@pulumi.getter(name="expirationDuration")
|
|
1890
|
-
def expiration_duration(self) -> pulumi.Output[Optional[
|
|
1930
|
+
def expiration_duration(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1891
1931
|
"""
|
|
1892
1932
|
The amount of time (in seconds) to wait before considering the signal expired. The value must be at least 30 seconds, and no more than 172800 seconds (48 hours).
|
|
1893
1933
|
"""
|
|
1894
1934
|
return pulumi.get(self, "expiration_duration")
|
|
1895
1935
|
|
|
1896
|
-
@property
|
|
1936
|
+
@_builtins.property
|
|
1897
1937
|
@pulumi.getter(name="fillOption")
|
|
1898
|
-
def fill_option(self) -> pulumi.Output[Optional[
|
|
1938
|
+
def fill_option(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1899
1939
|
"""
|
|
1900
1940
|
Which strategy to use when filling gaps in the signal. Possible values are `none`, `last_value` or `static`. If `static`, the `fill_value` field will be used for filling gaps in the signal.
|
|
1901
1941
|
"""
|
|
1902
1942
|
return pulumi.get(self, "fill_option")
|
|
1903
1943
|
|
|
1904
|
-
@property
|
|
1944
|
+
@_builtins.property
|
|
1905
1945
|
@pulumi.getter(name="fillValue")
|
|
1906
|
-
def fill_value(self) -> pulumi.Output[Optional[
|
|
1946
|
+
def fill_value(self) -> pulumi.Output[Optional[_builtins.float]]:
|
|
1907
1947
|
"""
|
|
1908
1948
|
This value will be used for filling gaps in the signal.
|
|
1909
1949
|
"""
|
|
1910
1950
|
return pulumi.get(self, "fill_value")
|
|
1911
1951
|
|
|
1912
|
-
@property
|
|
1952
|
+
@_builtins.property
|
|
1913
1953
|
@pulumi.getter(name="ignoreOnExpectedTermination")
|
|
1914
|
-
def ignore_on_expected_termination(self) -> pulumi.Output[Optional[
|
|
1954
|
+
def ignore_on_expected_termination(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1915
1955
|
"""
|
|
1916
1956
|
Whether an alert condition should ignore expected termination of a signal when considering whether to create a loss of signal incident. Defaults to false.
|
|
1917
1957
|
"""
|
|
1918
1958
|
return pulumi.get(self, "ignore_on_expected_termination")
|
|
1919
1959
|
|
|
1920
|
-
@property
|
|
1960
|
+
@_builtins.property
|
|
1921
1961
|
@pulumi.getter
|
|
1922
|
-
def name(self) -> pulumi.Output[
|
|
1962
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
1923
1963
|
"""
|
|
1924
1964
|
The title of the condition.
|
|
1925
1965
|
"""
|
|
1926
1966
|
return pulumi.get(self, "name")
|
|
1927
1967
|
|
|
1928
|
-
@property
|
|
1968
|
+
@_builtins.property
|
|
1929
1969
|
@pulumi.getter
|
|
1930
1970
|
def nrql(self) -> pulumi.Output['outputs.NrqlAlertConditionNrql']:
|
|
1931
1971
|
"""
|
|
@@ -1933,47 +1973,55 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1933
1973
|
"""
|
|
1934
1974
|
return pulumi.get(self, "nrql")
|
|
1935
1975
|
|
|
1936
|
-
@property
|
|
1976
|
+
@_builtins.property
|
|
1937
1977
|
@pulumi.getter(name="openViolationOnExpiration")
|
|
1938
|
-
def open_violation_on_expiration(self) -> pulumi.Output[Optional[
|
|
1978
|
+
def open_violation_on_expiration(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1939
1979
|
"""
|
|
1940
1980
|
Whether to create a new incident to capture that the signal expired.
|
|
1941
1981
|
"""
|
|
1942
1982
|
return pulumi.get(self, "open_violation_on_expiration")
|
|
1943
1983
|
|
|
1944
|
-
@property
|
|
1984
|
+
@_builtins.property
|
|
1945
1985
|
@pulumi.getter(name="policyId")
|
|
1946
|
-
def policy_id(self) -> pulumi.Output[
|
|
1986
|
+
def policy_id(self) -> pulumi.Output[_builtins.str]:
|
|
1947
1987
|
"""
|
|
1948
1988
|
The ID of the policy where this condition should be used.
|
|
1949
1989
|
"""
|
|
1950
1990
|
return pulumi.get(self, "policy_id")
|
|
1951
1991
|
|
|
1952
|
-
@property
|
|
1992
|
+
@_builtins.property
|
|
1953
1993
|
@pulumi.getter(name="runbookUrl")
|
|
1954
|
-
def runbook_url(self) -> pulumi.Output[Optional[
|
|
1994
|
+
def runbook_url(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1955
1995
|
"""
|
|
1956
1996
|
Runbook URL to display in notifications.
|
|
1957
1997
|
"""
|
|
1958
1998
|
return pulumi.get(self, "runbook_url")
|
|
1959
1999
|
|
|
1960
|
-
@property
|
|
2000
|
+
@_builtins.property
|
|
1961
2001
|
@pulumi.getter(name="signalSeasonality")
|
|
1962
|
-
def signal_seasonality(self) -> pulumi.Output[Optional[
|
|
2002
|
+
def signal_seasonality(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1963
2003
|
"""
|
|
1964
2004
|
Seasonality under which a condition's signal(s) are evaluated. Only available for baseline conditions. Valid values are: `NEW_RELIC_CALCULATION`, `HOURLY`, `DAILY`, `WEEKLY`, or `NONE`. To have New Relic calculate seasonality automatically, set to `NEW_RELIC_CALCULATION`. To turn off seasonality completely, set to `NONE`.
|
|
1965
2005
|
"""
|
|
1966
2006
|
return pulumi.get(self, "signal_seasonality")
|
|
1967
2007
|
|
|
1968
|
-
@property
|
|
2008
|
+
@_builtins.property
|
|
1969
2009
|
@pulumi.getter(name="slideBy")
|
|
1970
|
-
def slide_by(self) -> pulumi.Output[Optional[
|
|
2010
|
+
def slide_by(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1971
2011
|
"""
|
|
1972
2012
|
Gathers data in overlapping time windows to smooth the chart line, making it easier to spot trends. The `slide_by` value is specified in seconds and must be smaller than and a factor of the `aggregation_window`.
|
|
1973
2013
|
"""
|
|
1974
2014
|
return pulumi.get(self, "slide_by")
|
|
1975
2015
|
|
|
1976
|
-
@property
|
|
2016
|
+
@_builtins.property
|
|
2017
|
+
@pulumi.getter(name="targetEntity")
|
|
2018
|
+
def target_entity(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
2019
|
+
"""
|
|
2020
|
+
BETA PREVIEW: The GUID of the entity explicitly targeted by the condition. Issues triggered by this condition will affect the health status of this entity instead of having the affected entity detected automatically. The entity's account ID must be either `account_id` or `nrql.data_account_id`.
|
|
2021
|
+
"""
|
|
2022
|
+
return pulumi.get(self, "target_entity")
|
|
2023
|
+
|
|
2024
|
+
@_builtins.property
|
|
1977
2025
|
@pulumi.getter
|
|
1978
2026
|
@_utilities.deprecated("""use `critical` and `warning` attributes instead""")
|
|
1979
2027
|
def terms(self) -> pulumi.Output[Optional[Sequence['outputs.NrqlAlertConditionTerm']]]:
|
|
@@ -1982,42 +2030,42 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1982
2030
|
"""
|
|
1983
2031
|
return pulumi.get(self, "terms")
|
|
1984
2032
|
|
|
1985
|
-
@property
|
|
2033
|
+
@_builtins.property
|
|
1986
2034
|
@pulumi.getter(name="titleTemplate")
|
|
1987
|
-
def title_template(self) -> pulumi.Output[Optional[
|
|
2035
|
+
def title_template(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1988
2036
|
"""
|
|
1989
2037
|
The custom title to be used when incidents are opened by the condition. Setting this field will override the default title. Must be [Handlebars](https://handlebarsjs.com/) format.
|
|
1990
2038
|
"""
|
|
1991
2039
|
return pulumi.get(self, "title_template")
|
|
1992
2040
|
|
|
1993
|
-
@property
|
|
2041
|
+
@_builtins.property
|
|
1994
2042
|
@pulumi.getter
|
|
1995
|
-
def type(self) -> pulumi.Output[Optional[
|
|
2043
|
+
def type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1996
2044
|
"""
|
|
1997
2045
|
The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
|
|
1998
2046
|
"""
|
|
1999
2047
|
return pulumi.get(self, "type")
|
|
2000
2048
|
|
|
2001
|
-
@property
|
|
2049
|
+
@_builtins.property
|
|
2002
2050
|
@pulumi.getter(name="violationTimeLimit")
|
|
2003
2051
|
@_utilities.deprecated("""use `violation_time_limit_seconds` attribute instead""")
|
|
2004
|
-
def violation_time_limit(self) -> pulumi.Output[
|
|
2052
|
+
def violation_time_limit(self) -> pulumi.Output[_builtins.str]:
|
|
2005
2053
|
"""
|
|
2006
2054
|
**DEPRECATED:** Use `violation_time_limit_seconds` instead. Sets a time limit, in hours, that will automatically force-close a long-lasting incident after the time limit you select. Possible values are `ONE_HOUR`, `TWO_HOURS`, `FOUR_HOURS`, `EIGHT_HOURS`, `TWELVE_HOURS`, `TWENTY_FOUR_HOURS`, `THIRTY_DAYS` (case insensitive).<br>
|
|
2007
2055
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
2008
2056
|
"""
|
|
2009
2057
|
return pulumi.get(self, "violation_time_limit")
|
|
2010
2058
|
|
|
2011
|
-
@property
|
|
2059
|
+
@_builtins.property
|
|
2012
2060
|
@pulumi.getter(name="violationTimeLimitSeconds")
|
|
2013
|
-
def violation_time_limit_seconds(self) -> pulumi.Output[Optional[
|
|
2061
|
+
def violation_time_limit_seconds(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
2014
2062
|
"""
|
|
2015
2063
|
Sets a time limit, in seconds, that will automatically force-close a long-lasting incident after the time limit you select. The value must be between 300 seconds (5 minutes) to 2592000 seconds (30 days) (inclusive). <br>
|
|
2016
2064
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
2017
2065
|
"""
|
|
2018
2066
|
return pulumi.get(self, "violation_time_limit_seconds")
|
|
2019
2067
|
|
|
2020
|
-
@property
|
|
2068
|
+
@_builtins.property
|
|
2021
2069
|
@pulumi.getter
|
|
2022
2070
|
def warning(self) -> pulumi.Output[Optional['outputs.NrqlAlertConditionWarning']]:
|
|
2023
2071
|
"""
|