pulumi-newrelic 5.49.0a1753337775__py3-none-any.whl → 5.49.0a1753510512__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.
Potentially problematic release.
This version of pulumi-newrelic might be problematic. Click here for more details.
- pulumi_newrelic/__init__.py +1 -1
- pulumi_newrelic/_inputs.py +3759 -3760
- pulumi_newrelic/account_management.py +35 -36
- pulumi_newrelic/alert_channel.py +55 -56
- 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 +112 -113
- pulumi_newrelic/browser_application.py +113 -114
- pulumi_newrelic/cloud/__init__.py +1 -1
- pulumi_newrelic/cloud/_inputs.py +2129 -2130
- pulumi_newrelic/cloud/aws_govcloud_integrations.py +95 -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 +131 -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/outputs.py +1417 -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 +21 -22
- pulumi_newrelic/events_to_metrics_rule.py +95 -96
- pulumi_newrelic/get_account.py +21 -22
- pulumi_newrelic/get_alert_channel.py +20 -21
- pulumi_newrelic/get_alert_policy.py +25 -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 +143 -144
- pulumi_newrelic/notification_channel.py +115 -116
- pulumi_newrelic/notification_destination.py +111 -112
- pulumi_newrelic/nrql_alert_condition.py +430 -431
- pulumi_newrelic/nrql_drop_rule.py +78 -79
- 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 +90 -91
- pulumi_newrelic/outputs.py +2646 -2647
- 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 +302 -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.49.0a1753337775.dist-info → pulumi_newrelic-5.49.0a1753510512.dist-info}/METADATA +1 -1
- pulumi_newrelic-5.49.0a1753510512.dist-info/RECORD +90 -0
- pulumi_newrelic-5.49.0a1753337775.dist-info/RECORD +0 -90
- {pulumi_newrelic-5.49.0a1753337775.dist-info → pulumi_newrelic-5.49.0a1753510512.dist-info}/WHEEL +0 -0
- {pulumi_newrelic-5.49.0a1753337775.dist-info → pulumi_newrelic-5.49.0a1753510512.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,63 @@ __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,
|
|
47
46
|
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[
|
|
47
|
+
title_template: Optional[pulumi.Input[_builtins.str]] = None,
|
|
48
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
49
|
+
violation_time_limit: Optional[pulumi.Input[_builtins.str]] = None,
|
|
50
|
+
violation_time_limit_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
52
51
|
warning: Optional[pulumi.Input['NrqlAlertConditionWarningArgs']] = None):
|
|
53
52
|
"""
|
|
54
53
|
The set of arguments for constructing a NrqlAlertCondition resource.
|
|
55
54
|
: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[
|
|
55
|
+
:param pulumi.Input[_builtins.str] policy_id: The ID of the policy where this condition should be used.
|
|
56
|
+
: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`.
|
|
57
|
+
: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`.
|
|
58
|
+
: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`.
|
|
59
|
+
: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`.
|
|
60
|
+
: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.
|
|
61
|
+
: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).
|
|
62
|
+
:param pulumi.Input[_builtins.bool] close_violations_on_expiration: Whether to close all open incidents when the signal expires.
|
|
64
63
|
: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[
|
|
64
|
+
:param pulumi.Input[_builtins.str] description: The description of the NRQL alert condition.
|
|
65
|
+
:param pulumi.Input[_builtins.bool] enabled: Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
|
|
66
|
+
:param pulumi.Input[_builtins.int] evaluation_delay: How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
|
|
67
|
+
: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).
|
|
68
|
+
: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.
|
|
69
|
+
:param pulumi.Input[_builtins.float] fill_value: This value will be used for filling gaps in the signal.
|
|
70
|
+
: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.
|
|
71
|
+
:param pulumi.Input[_builtins.str] name: The title of the condition.
|
|
72
|
+
:param pulumi.Input[_builtins.bool] open_violation_on_expiration: Whether to create a new incident to capture that the signal expired.
|
|
73
|
+
:param pulumi.Input[_builtins.str] runbook_url: Runbook URL to display in notifications.
|
|
74
|
+
: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`.
|
|
75
|
+
: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
76
|
: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[
|
|
77
|
+
: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.
|
|
78
|
+
:param pulumi.Input[_builtins.str] type: The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
|
|
79
|
+
: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
80
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
82
|
-
:param pulumi.Input[
|
|
81
|
+
: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
82
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
84
83
|
: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
84
|
"""
|
|
@@ -144,7 +143,7 @@ class NrqlAlertConditionArgs:
|
|
|
144
143
|
if warning is not None:
|
|
145
144
|
pulumi.set(__self__, "warning", warning)
|
|
146
145
|
|
|
147
|
-
@property
|
|
146
|
+
@_builtins.property
|
|
148
147
|
@pulumi.getter
|
|
149
148
|
def nrql(self) -> pulumi.Input['NrqlAlertConditionNrqlArgs']:
|
|
150
149
|
"""
|
|
@@ -156,103 +155,103 @@ class NrqlAlertConditionArgs:
|
|
|
156
155
|
def nrql(self, value: pulumi.Input['NrqlAlertConditionNrqlArgs']):
|
|
157
156
|
pulumi.set(self, "nrql", value)
|
|
158
157
|
|
|
159
|
-
@property
|
|
158
|
+
@_builtins.property
|
|
160
159
|
@pulumi.getter(name="policyId")
|
|
161
|
-
def policy_id(self) -> pulumi.Input[
|
|
160
|
+
def policy_id(self) -> pulumi.Input[_builtins.str]:
|
|
162
161
|
"""
|
|
163
162
|
The ID of the policy where this condition should be used.
|
|
164
163
|
"""
|
|
165
164
|
return pulumi.get(self, "policy_id")
|
|
166
165
|
|
|
167
166
|
@policy_id.setter
|
|
168
|
-
def policy_id(self, value: pulumi.Input[
|
|
167
|
+
def policy_id(self, value: pulumi.Input[_builtins.str]):
|
|
169
168
|
pulumi.set(self, "policy_id", value)
|
|
170
169
|
|
|
171
|
-
@property
|
|
170
|
+
@_builtins.property
|
|
172
171
|
@pulumi.getter(name="accountId")
|
|
173
|
-
def account_id(self) -> Optional[pulumi.Input[
|
|
172
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
174
173
|
"""
|
|
175
174
|
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
175
|
"""
|
|
177
176
|
return pulumi.get(self, "account_id")
|
|
178
177
|
|
|
179
178
|
@account_id.setter
|
|
180
|
-
def account_id(self, value: Optional[pulumi.Input[
|
|
179
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
181
180
|
pulumi.set(self, "account_id", value)
|
|
182
181
|
|
|
183
|
-
@property
|
|
182
|
+
@_builtins.property
|
|
184
183
|
@pulumi.getter(name="aggregationDelay")
|
|
185
|
-
def aggregation_delay(self) -> Optional[pulumi.Input[
|
|
184
|
+
def aggregation_delay(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
186
185
|
"""
|
|
187
186
|
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
187
|
"""
|
|
189
188
|
return pulumi.get(self, "aggregation_delay")
|
|
190
189
|
|
|
191
190
|
@aggregation_delay.setter
|
|
192
|
-
def aggregation_delay(self, value: Optional[pulumi.Input[
|
|
191
|
+
def aggregation_delay(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
193
192
|
pulumi.set(self, "aggregation_delay", value)
|
|
194
193
|
|
|
195
|
-
@property
|
|
194
|
+
@_builtins.property
|
|
196
195
|
@pulumi.getter(name="aggregationMethod")
|
|
197
|
-
def aggregation_method(self) -> Optional[pulumi.Input[
|
|
196
|
+
def aggregation_method(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
198
197
|
"""
|
|
199
198
|
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
199
|
"""
|
|
201
200
|
return pulumi.get(self, "aggregation_method")
|
|
202
201
|
|
|
203
202
|
@aggregation_method.setter
|
|
204
|
-
def aggregation_method(self, value: Optional[pulumi.Input[
|
|
203
|
+
def aggregation_method(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
205
204
|
pulumi.set(self, "aggregation_method", value)
|
|
206
205
|
|
|
207
|
-
@property
|
|
206
|
+
@_builtins.property
|
|
208
207
|
@pulumi.getter(name="aggregationTimer")
|
|
209
|
-
def aggregation_timer(self) -> Optional[pulumi.Input[
|
|
208
|
+
def aggregation_timer(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
210
209
|
"""
|
|
211
210
|
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
211
|
"""
|
|
213
212
|
return pulumi.get(self, "aggregation_timer")
|
|
214
213
|
|
|
215
214
|
@aggregation_timer.setter
|
|
216
|
-
def aggregation_timer(self, value: Optional[pulumi.Input[
|
|
215
|
+
def aggregation_timer(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
217
216
|
pulumi.set(self, "aggregation_timer", value)
|
|
218
217
|
|
|
219
|
-
@property
|
|
218
|
+
@_builtins.property
|
|
220
219
|
@pulumi.getter(name="aggregationWindow")
|
|
221
|
-
def aggregation_window(self) -> Optional[pulumi.Input[
|
|
220
|
+
def aggregation_window(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
222
221
|
"""
|
|
223
222
|
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
223
|
"""
|
|
225
224
|
return pulumi.get(self, "aggregation_window")
|
|
226
225
|
|
|
227
226
|
@aggregation_window.setter
|
|
228
|
-
def aggregation_window(self, value: Optional[pulumi.Input[
|
|
227
|
+
def aggregation_window(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
229
228
|
pulumi.set(self, "aggregation_window", value)
|
|
230
229
|
|
|
231
|
-
@property
|
|
230
|
+
@_builtins.property
|
|
232
231
|
@pulumi.getter(name="baselineDirection")
|
|
233
|
-
def baseline_direction(self) -> Optional[pulumi.Input[
|
|
232
|
+
def baseline_direction(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
234
233
|
"""
|
|
235
234
|
The baseline direction of a _baseline_ NRQL alert condition. Valid values are: `lower_only`, `upper_and_lower`, `upper_only` (case insensitive).
|
|
236
235
|
"""
|
|
237
236
|
return pulumi.get(self, "baseline_direction")
|
|
238
237
|
|
|
239
238
|
@baseline_direction.setter
|
|
240
|
-
def baseline_direction(self, value: Optional[pulumi.Input[
|
|
239
|
+
def baseline_direction(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
241
240
|
pulumi.set(self, "baseline_direction", value)
|
|
242
241
|
|
|
243
|
-
@property
|
|
242
|
+
@_builtins.property
|
|
244
243
|
@pulumi.getter(name="closeViolationsOnExpiration")
|
|
245
|
-
def close_violations_on_expiration(self) -> Optional[pulumi.Input[
|
|
244
|
+
def close_violations_on_expiration(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
246
245
|
"""
|
|
247
246
|
Whether to close all open incidents when the signal expires.
|
|
248
247
|
"""
|
|
249
248
|
return pulumi.get(self, "close_violations_on_expiration")
|
|
250
249
|
|
|
251
250
|
@close_violations_on_expiration.setter
|
|
252
|
-
def close_violations_on_expiration(self, value: Optional[pulumi.Input[
|
|
251
|
+
def close_violations_on_expiration(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
253
252
|
pulumi.set(self, "close_violations_on_expiration", value)
|
|
254
253
|
|
|
255
|
-
@property
|
|
254
|
+
@_builtins.property
|
|
256
255
|
@pulumi.getter
|
|
257
256
|
def critical(self) -> Optional[pulumi.Input['NrqlAlertConditionCriticalArgs']]:
|
|
258
257
|
"""
|
|
@@ -264,151 +263,151 @@ class NrqlAlertConditionArgs:
|
|
|
264
263
|
def critical(self, value: Optional[pulumi.Input['NrqlAlertConditionCriticalArgs']]):
|
|
265
264
|
pulumi.set(self, "critical", value)
|
|
266
265
|
|
|
267
|
-
@property
|
|
266
|
+
@_builtins.property
|
|
268
267
|
@pulumi.getter
|
|
269
|
-
def description(self) -> Optional[pulumi.Input[
|
|
268
|
+
def description(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
270
269
|
"""
|
|
271
270
|
The description of the NRQL alert condition.
|
|
272
271
|
"""
|
|
273
272
|
return pulumi.get(self, "description")
|
|
274
273
|
|
|
275
274
|
@description.setter
|
|
276
|
-
def description(self, value: Optional[pulumi.Input[
|
|
275
|
+
def description(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
277
276
|
pulumi.set(self, "description", value)
|
|
278
277
|
|
|
279
|
-
@property
|
|
278
|
+
@_builtins.property
|
|
280
279
|
@pulumi.getter
|
|
281
|
-
def enabled(self) -> Optional[pulumi.Input[
|
|
280
|
+
def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
282
281
|
"""
|
|
283
282
|
Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
|
|
284
283
|
"""
|
|
285
284
|
return pulumi.get(self, "enabled")
|
|
286
285
|
|
|
287
286
|
@enabled.setter
|
|
288
|
-
def enabled(self, value: Optional[pulumi.Input[
|
|
287
|
+
def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
289
288
|
pulumi.set(self, "enabled", value)
|
|
290
289
|
|
|
291
|
-
@property
|
|
290
|
+
@_builtins.property
|
|
292
291
|
@pulumi.getter(name="evaluationDelay")
|
|
293
|
-
def evaluation_delay(self) -> Optional[pulumi.Input[
|
|
292
|
+
def evaluation_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
294
293
|
"""
|
|
295
294
|
How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
|
|
296
295
|
"""
|
|
297
296
|
return pulumi.get(self, "evaluation_delay")
|
|
298
297
|
|
|
299
298
|
@evaluation_delay.setter
|
|
300
|
-
def evaluation_delay(self, value: Optional[pulumi.Input[
|
|
299
|
+
def evaluation_delay(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
301
300
|
pulumi.set(self, "evaluation_delay", value)
|
|
302
301
|
|
|
303
|
-
@property
|
|
302
|
+
@_builtins.property
|
|
304
303
|
@pulumi.getter(name="expirationDuration")
|
|
305
|
-
def expiration_duration(self) -> Optional[pulumi.Input[
|
|
304
|
+
def expiration_duration(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
306
305
|
"""
|
|
307
306
|
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
307
|
"""
|
|
309
308
|
return pulumi.get(self, "expiration_duration")
|
|
310
309
|
|
|
311
310
|
@expiration_duration.setter
|
|
312
|
-
def expiration_duration(self, value: Optional[pulumi.Input[
|
|
311
|
+
def expiration_duration(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
313
312
|
pulumi.set(self, "expiration_duration", value)
|
|
314
313
|
|
|
315
|
-
@property
|
|
314
|
+
@_builtins.property
|
|
316
315
|
@pulumi.getter(name="fillOption")
|
|
317
|
-
def fill_option(self) -> Optional[pulumi.Input[
|
|
316
|
+
def fill_option(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
318
317
|
"""
|
|
319
318
|
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
319
|
"""
|
|
321
320
|
return pulumi.get(self, "fill_option")
|
|
322
321
|
|
|
323
322
|
@fill_option.setter
|
|
324
|
-
def fill_option(self, value: Optional[pulumi.Input[
|
|
323
|
+
def fill_option(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
325
324
|
pulumi.set(self, "fill_option", value)
|
|
326
325
|
|
|
327
|
-
@property
|
|
326
|
+
@_builtins.property
|
|
328
327
|
@pulumi.getter(name="fillValue")
|
|
329
|
-
def fill_value(self) -> Optional[pulumi.Input[
|
|
328
|
+
def fill_value(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
330
329
|
"""
|
|
331
330
|
This value will be used for filling gaps in the signal.
|
|
332
331
|
"""
|
|
333
332
|
return pulumi.get(self, "fill_value")
|
|
334
333
|
|
|
335
334
|
@fill_value.setter
|
|
336
|
-
def fill_value(self, value: Optional[pulumi.Input[
|
|
335
|
+
def fill_value(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
337
336
|
pulumi.set(self, "fill_value", value)
|
|
338
337
|
|
|
339
|
-
@property
|
|
338
|
+
@_builtins.property
|
|
340
339
|
@pulumi.getter(name="ignoreOnExpectedTermination")
|
|
341
|
-
def ignore_on_expected_termination(self) -> Optional[pulumi.Input[
|
|
340
|
+
def ignore_on_expected_termination(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
342
341
|
"""
|
|
343
342
|
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
343
|
"""
|
|
345
344
|
return pulumi.get(self, "ignore_on_expected_termination")
|
|
346
345
|
|
|
347
346
|
@ignore_on_expected_termination.setter
|
|
348
|
-
def ignore_on_expected_termination(self, value: Optional[pulumi.Input[
|
|
347
|
+
def ignore_on_expected_termination(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
349
348
|
pulumi.set(self, "ignore_on_expected_termination", value)
|
|
350
349
|
|
|
351
|
-
@property
|
|
350
|
+
@_builtins.property
|
|
352
351
|
@pulumi.getter
|
|
353
|
-
def name(self) -> Optional[pulumi.Input[
|
|
352
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
354
353
|
"""
|
|
355
354
|
The title of the condition.
|
|
356
355
|
"""
|
|
357
356
|
return pulumi.get(self, "name")
|
|
358
357
|
|
|
359
358
|
@name.setter
|
|
360
|
-
def name(self, value: Optional[pulumi.Input[
|
|
359
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
361
360
|
pulumi.set(self, "name", value)
|
|
362
361
|
|
|
363
|
-
@property
|
|
362
|
+
@_builtins.property
|
|
364
363
|
@pulumi.getter(name="openViolationOnExpiration")
|
|
365
|
-
def open_violation_on_expiration(self) -> Optional[pulumi.Input[
|
|
364
|
+
def open_violation_on_expiration(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
366
365
|
"""
|
|
367
366
|
Whether to create a new incident to capture that the signal expired.
|
|
368
367
|
"""
|
|
369
368
|
return pulumi.get(self, "open_violation_on_expiration")
|
|
370
369
|
|
|
371
370
|
@open_violation_on_expiration.setter
|
|
372
|
-
def open_violation_on_expiration(self, value: Optional[pulumi.Input[
|
|
371
|
+
def open_violation_on_expiration(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
373
372
|
pulumi.set(self, "open_violation_on_expiration", value)
|
|
374
373
|
|
|
375
|
-
@property
|
|
374
|
+
@_builtins.property
|
|
376
375
|
@pulumi.getter(name="runbookUrl")
|
|
377
|
-
def runbook_url(self) -> Optional[pulumi.Input[
|
|
376
|
+
def runbook_url(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
378
377
|
"""
|
|
379
378
|
Runbook URL to display in notifications.
|
|
380
379
|
"""
|
|
381
380
|
return pulumi.get(self, "runbook_url")
|
|
382
381
|
|
|
383
382
|
@runbook_url.setter
|
|
384
|
-
def runbook_url(self, value: Optional[pulumi.Input[
|
|
383
|
+
def runbook_url(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
385
384
|
pulumi.set(self, "runbook_url", value)
|
|
386
385
|
|
|
387
|
-
@property
|
|
386
|
+
@_builtins.property
|
|
388
387
|
@pulumi.getter(name="signalSeasonality")
|
|
389
|
-
def signal_seasonality(self) -> Optional[pulumi.Input[
|
|
388
|
+
def signal_seasonality(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
390
389
|
"""
|
|
391
390
|
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
391
|
"""
|
|
393
392
|
return pulumi.get(self, "signal_seasonality")
|
|
394
393
|
|
|
395
394
|
@signal_seasonality.setter
|
|
396
|
-
def signal_seasonality(self, value: Optional[pulumi.Input[
|
|
395
|
+
def signal_seasonality(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
397
396
|
pulumi.set(self, "signal_seasonality", value)
|
|
398
397
|
|
|
399
|
-
@property
|
|
398
|
+
@_builtins.property
|
|
400
399
|
@pulumi.getter(name="slideBy")
|
|
401
|
-
def slide_by(self) -> Optional[pulumi.Input[
|
|
400
|
+
def slide_by(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
402
401
|
"""
|
|
403
402
|
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
403
|
"""
|
|
405
404
|
return pulumi.get(self, "slide_by")
|
|
406
405
|
|
|
407
406
|
@slide_by.setter
|
|
408
|
-
def slide_by(self, value: Optional[pulumi.Input[
|
|
407
|
+
def slide_by(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
409
408
|
pulumi.set(self, "slide_by", value)
|
|
410
409
|
|
|
411
|
-
@property
|
|
410
|
+
@_builtins.property
|
|
412
411
|
@pulumi.getter
|
|
413
412
|
@_utilities.deprecated("""use `critical` and `warning` attributes instead""")
|
|
414
413
|
def terms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NrqlAlertConditionTermArgs']]]]:
|
|
@@ -421,34 +420,34 @@ class NrqlAlertConditionArgs:
|
|
|
421
420
|
def terms(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NrqlAlertConditionTermArgs']]]]):
|
|
422
421
|
pulumi.set(self, "terms", value)
|
|
423
422
|
|
|
424
|
-
@property
|
|
423
|
+
@_builtins.property
|
|
425
424
|
@pulumi.getter(name="titleTemplate")
|
|
426
|
-
def title_template(self) -> Optional[pulumi.Input[
|
|
425
|
+
def title_template(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
427
426
|
"""
|
|
428
427
|
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
428
|
"""
|
|
430
429
|
return pulumi.get(self, "title_template")
|
|
431
430
|
|
|
432
431
|
@title_template.setter
|
|
433
|
-
def title_template(self, value: Optional[pulumi.Input[
|
|
432
|
+
def title_template(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
434
433
|
pulumi.set(self, "title_template", value)
|
|
435
434
|
|
|
436
|
-
@property
|
|
435
|
+
@_builtins.property
|
|
437
436
|
@pulumi.getter
|
|
438
|
-
def type(self) -> Optional[pulumi.Input[
|
|
437
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
439
438
|
"""
|
|
440
439
|
The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
|
|
441
440
|
"""
|
|
442
441
|
return pulumi.get(self, "type")
|
|
443
442
|
|
|
444
443
|
@type.setter
|
|
445
|
-
def type(self, value: Optional[pulumi.Input[
|
|
444
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
446
445
|
pulumi.set(self, "type", value)
|
|
447
446
|
|
|
448
|
-
@property
|
|
447
|
+
@_builtins.property
|
|
449
448
|
@pulumi.getter(name="violationTimeLimit")
|
|
450
449
|
@_utilities.deprecated("""use `violation_time_limit_seconds` attribute instead""")
|
|
451
|
-
def violation_time_limit(self) -> Optional[pulumi.Input[
|
|
450
|
+
def violation_time_limit(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
452
451
|
"""
|
|
453
452
|
**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
453
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
@@ -456,12 +455,12 @@ class NrqlAlertConditionArgs:
|
|
|
456
455
|
return pulumi.get(self, "violation_time_limit")
|
|
457
456
|
|
|
458
457
|
@violation_time_limit.setter
|
|
459
|
-
def violation_time_limit(self, value: Optional[pulumi.Input[
|
|
458
|
+
def violation_time_limit(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
460
459
|
pulumi.set(self, "violation_time_limit", value)
|
|
461
460
|
|
|
462
|
-
@property
|
|
461
|
+
@_builtins.property
|
|
463
462
|
@pulumi.getter(name="violationTimeLimitSeconds")
|
|
464
|
-
def violation_time_limit_seconds(self) -> Optional[pulumi.Input[
|
|
463
|
+
def violation_time_limit_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
465
464
|
"""
|
|
466
465
|
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
466
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
@@ -469,10 +468,10 @@ class NrqlAlertConditionArgs:
|
|
|
469
468
|
return pulumi.get(self, "violation_time_limit_seconds")
|
|
470
469
|
|
|
471
470
|
@violation_time_limit_seconds.setter
|
|
472
|
-
def violation_time_limit_seconds(self, value: Optional[pulumi.Input[
|
|
471
|
+
def violation_time_limit_seconds(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
473
472
|
pulumi.set(self, "violation_time_limit_seconds", value)
|
|
474
473
|
|
|
475
|
-
@property
|
|
474
|
+
@_builtins.property
|
|
476
475
|
@pulumi.getter
|
|
477
476
|
def warning(self) -> Optional[pulumi.Input['NrqlAlertConditionWarningArgs']]:
|
|
478
477
|
"""
|
|
@@ -488,66 +487,66 @@ class NrqlAlertConditionArgs:
|
|
|
488
487
|
@pulumi.input_type
|
|
489
488
|
class _NrqlAlertConditionState:
|
|
490
489
|
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[
|
|
490
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
491
|
+
aggregation_delay: Optional[pulumi.Input[_builtins.str]] = None,
|
|
492
|
+
aggregation_method: Optional[pulumi.Input[_builtins.str]] = None,
|
|
493
|
+
aggregation_timer: Optional[pulumi.Input[_builtins.str]] = None,
|
|
494
|
+
aggregation_window: Optional[pulumi.Input[_builtins.int]] = None,
|
|
495
|
+
baseline_direction: Optional[pulumi.Input[_builtins.str]] = None,
|
|
496
|
+
close_violations_on_expiration: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
498
497
|
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[
|
|
498
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
499
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
500
|
+
entity_guid: Optional[pulumi.Input[_builtins.str]] = None,
|
|
501
|
+
evaluation_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
502
|
+
expiration_duration: Optional[pulumi.Input[_builtins.int]] = None,
|
|
503
|
+
fill_option: Optional[pulumi.Input[_builtins.str]] = None,
|
|
504
|
+
fill_value: Optional[pulumi.Input[_builtins.float]] = None,
|
|
505
|
+
ignore_on_expected_termination: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
506
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
508
507
|
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[
|
|
508
|
+
open_violation_on_expiration: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
509
|
+
policy_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
510
|
+
runbook_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
511
|
+
signal_seasonality: Optional[pulumi.Input[_builtins.str]] = None,
|
|
512
|
+
slide_by: Optional[pulumi.Input[_builtins.int]] = None,
|
|
514
513
|
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[
|
|
514
|
+
title_template: Optional[pulumi.Input[_builtins.str]] = None,
|
|
515
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
516
|
+
violation_time_limit: Optional[pulumi.Input[_builtins.str]] = None,
|
|
517
|
+
violation_time_limit_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
519
518
|
warning: Optional[pulumi.Input['NrqlAlertConditionWarningArgs']] = None):
|
|
520
519
|
"""
|
|
521
520
|
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[
|
|
521
|
+
: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`.
|
|
522
|
+
: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`.
|
|
523
|
+
: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`.
|
|
524
|
+
: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`.
|
|
525
|
+
: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.
|
|
526
|
+
: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).
|
|
527
|
+
:param pulumi.Input[_builtins.bool] close_violations_on_expiration: Whether to close all open incidents when the signal expires.
|
|
529
528
|
: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[
|
|
529
|
+
:param pulumi.Input[_builtins.str] description: The description of the NRQL alert condition.
|
|
530
|
+
:param pulumi.Input[_builtins.bool] enabled: Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
|
|
531
|
+
:param pulumi.Input[_builtins.str] entity_guid: The unique entity identifier of the NRQL Condition in New Relic.
|
|
532
|
+
:param pulumi.Input[_builtins.int] evaluation_delay: How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
|
|
533
|
+
: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).
|
|
534
|
+
: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.
|
|
535
|
+
:param pulumi.Input[_builtins.float] fill_value: This value will be used for filling gaps in the signal.
|
|
536
|
+
: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.
|
|
537
|
+
:param pulumi.Input[_builtins.str] name: The title of the condition.
|
|
539
538
|
: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[
|
|
539
|
+
:param pulumi.Input[_builtins.bool] open_violation_on_expiration: Whether to create a new incident to capture that the signal expired.
|
|
540
|
+
:param pulumi.Input[_builtins.str] policy_id: The ID of the policy where this condition should be used.
|
|
541
|
+
:param pulumi.Input[_builtins.str] runbook_url: Runbook URL to display in notifications.
|
|
542
|
+
: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`.
|
|
543
|
+
: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`.
|
|
545
544
|
: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[
|
|
545
|
+
: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.
|
|
546
|
+
:param pulumi.Input[_builtins.str] type: The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
|
|
547
|
+
: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
548
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
550
|
-
:param pulumi.Input[
|
|
549
|
+
: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
550
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
552
551
|
: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
552
|
"""
|
|
@@ -616,91 +615,91 @@ class _NrqlAlertConditionState:
|
|
|
616
615
|
if warning is not None:
|
|
617
616
|
pulumi.set(__self__, "warning", warning)
|
|
618
617
|
|
|
619
|
-
@property
|
|
618
|
+
@_builtins.property
|
|
620
619
|
@pulumi.getter(name="accountId")
|
|
621
|
-
def account_id(self) -> Optional[pulumi.Input[
|
|
620
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
622
621
|
"""
|
|
623
622
|
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
623
|
"""
|
|
625
624
|
return pulumi.get(self, "account_id")
|
|
626
625
|
|
|
627
626
|
@account_id.setter
|
|
628
|
-
def account_id(self, value: Optional[pulumi.Input[
|
|
627
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
629
628
|
pulumi.set(self, "account_id", value)
|
|
630
629
|
|
|
631
|
-
@property
|
|
630
|
+
@_builtins.property
|
|
632
631
|
@pulumi.getter(name="aggregationDelay")
|
|
633
|
-
def aggregation_delay(self) -> Optional[pulumi.Input[
|
|
632
|
+
def aggregation_delay(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
634
633
|
"""
|
|
635
634
|
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
635
|
"""
|
|
637
636
|
return pulumi.get(self, "aggregation_delay")
|
|
638
637
|
|
|
639
638
|
@aggregation_delay.setter
|
|
640
|
-
def aggregation_delay(self, value: Optional[pulumi.Input[
|
|
639
|
+
def aggregation_delay(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
641
640
|
pulumi.set(self, "aggregation_delay", value)
|
|
642
641
|
|
|
643
|
-
@property
|
|
642
|
+
@_builtins.property
|
|
644
643
|
@pulumi.getter(name="aggregationMethod")
|
|
645
|
-
def aggregation_method(self) -> Optional[pulumi.Input[
|
|
644
|
+
def aggregation_method(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
646
645
|
"""
|
|
647
646
|
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
647
|
"""
|
|
649
648
|
return pulumi.get(self, "aggregation_method")
|
|
650
649
|
|
|
651
650
|
@aggregation_method.setter
|
|
652
|
-
def aggregation_method(self, value: Optional[pulumi.Input[
|
|
651
|
+
def aggregation_method(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
653
652
|
pulumi.set(self, "aggregation_method", value)
|
|
654
653
|
|
|
655
|
-
@property
|
|
654
|
+
@_builtins.property
|
|
656
655
|
@pulumi.getter(name="aggregationTimer")
|
|
657
|
-
def aggregation_timer(self) -> Optional[pulumi.Input[
|
|
656
|
+
def aggregation_timer(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
658
657
|
"""
|
|
659
658
|
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
659
|
"""
|
|
661
660
|
return pulumi.get(self, "aggregation_timer")
|
|
662
661
|
|
|
663
662
|
@aggregation_timer.setter
|
|
664
|
-
def aggregation_timer(self, value: Optional[pulumi.Input[
|
|
663
|
+
def aggregation_timer(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
665
664
|
pulumi.set(self, "aggregation_timer", value)
|
|
666
665
|
|
|
667
|
-
@property
|
|
666
|
+
@_builtins.property
|
|
668
667
|
@pulumi.getter(name="aggregationWindow")
|
|
669
|
-
def aggregation_window(self) -> Optional[pulumi.Input[
|
|
668
|
+
def aggregation_window(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
670
669
|
"""
|
|
671
670
|
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
671
|
"""
|
|
673
672
|
return pulumi.get(self, "aggregation_window")
|
|
674
673
|
|
|
675
674
|
@aggregation_window.setter
|
|
676
|
-
def aggregation_window(self, value: Optional[pulumi.Input[
|
|
675
|
+
def aggregation_window(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
677
676
|
pulumi.set(self, "aggregation_window", value)
|
|
678
677
|
|
|
679
|
-
@property
|
|
678
|
+
@_builtins.property
|
|
680
679
|
@pulumi.getter(name="baselineDirection")
|
|
681
|
-
def baseline_direction(self) -> Optional[pulumi.Input[
|
|
680
|
+
def baseline_direction(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
682
681
|
"""
|
|
683
682
|
The baseline direction of a _baseline_ NRQL alert condition. Valid values are: `lower_only`, `upper_and_lower`, `upper_only` (case insensitive).
|
|
684
683
|
"""
|
|
685
684
|
return pulumi.get(self, "baseline_direction")
|
|
686
685
|
|
|
687
686
|
@baseline_direction.setter
|
|
688
|
-
def baseline_direction(self, value: Optional[pulumi.Input[
|
|
687
|
+
def baseline_direction(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
689
688
|
pulumi.set(self, "baseline_direction", value)
|
|
690
689
|
|
|
691
|
-
@property
|
|
690
|
+
@_builtins.property
|
|
692
691
|
@pulumi.getter(name="closeViolationsOnExpiration")
|
|
693
|
-
def close_violations_on_expiration(self) -> Optional[pulumi.Input[
|
|
692
|
+
def close_violations_on_expiration(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
694
693
|
"""
|
|
695
694
|
Whether to close all open incidents when the signal expires.
|
|
696
695
|
"""
|
|
697
696
|
return pulumi.get(self, "close_violations_on_expiration")
|
|
698
697
|
|
|
699
698
|
@close_violations_on_expiration.setter
|
|
700
|
-
def close_violations_on_expiration(self, value: Optional[pulumi.Input[
|
|
699
|
+
def close_violations_on_expiration(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
701
700
|
pulumi.set(self, "close_violations_on_expiration", value)
|
|
702
701
|
|
|
703
|
-
@property
|
|
702
|
+
@_builtins.property
|
|
704
703
|
@pulumi.getter
|
|
705
704
|
def critical(self) -> Optional[pulumi.Input['NrqlAlertConditionCriticalArgs']]:
|
|
706
705
|
"""
|
|
@@ -712,115 +711,115 @@ class _NrqlAlertConditionState:
|
|
|
712
711
|
def critical(self, value: Optional[pulumi.Input['NrqlAlertConditionCriticalArgs']]):
|
|
713
712
|
pulumi.set(self, "critical", value)
|
|
714
713
|
|
|
715
|
-
@property
|
|
714
|
+
@_builtins.property
|
|
716
715
|
@pulumi.getter
|
|
717
|
-
def description(self) -> Optional[pulumi.Input[
|
|
716
|
+
def description(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
718
717
|
"""
|
|
719
718
|
The description of the NRQL alert condition.
|
|
720
719
|
"""
|
|
721
720
|
return pulumi.get(self, "description")
|
|
722
721
|
|
|
723
722
|
@description.setter
|
|
724
|
-
def description(self, value: Optional[pulumi.Input[
|
|
723
|
+
def description(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
725
724
|
pulumi.set(self, "description", value)
|
|
726
725
|
|
|
727
|
-
@property
|
|
726
|
+
@_builtins.property
|
|
728
727
|
@pulumi.getter
|
|
729
|
-
def enabled(self) -> Optional[pulumi.Input[
|
|
728
|
+
def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
730
729
|
"""
|
|
731
730
|
Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
|
|
732
731
|
"""
|
|
733
732
|
return pulumi.get(self, "enabled")
|
|
734
733
|
|
|
735
734
|
@enabled.setter
|
|
736
|
-
def enabled(self, value: Optional[pulumi.Input[
|
|
735
|
+
def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
737
736
|
pulumi.set(self, "enabled", value)
|
|
738
737
|
|
|
739
|
-
@property
|
|
738
|
+
@_builtins.property
|
|
740
739
|
@pulumi.getter(name="entityGuid")
|
|
741
|
-
def entity_guid(self) -> Optional[pulumi.Input[
|
|
740
|
+
def entity_guid(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
742
741
|
"""
|
|
743
742
|
The unique entity identifier of the NRQL Condition in New Relic.
|
|
744
743
|
"""
|
|
745
744
|
return pulumi.get(self, "entity_guid")
|
|
746
745
|
|
|
747
746
|
@entity_guid.setter
|
|
748
|
-
def entity_guid(self, value: Optional[pulumi.Input[
|
|
747
|
+
def entity_guid(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
749
748
|
pulumi.set(self, "entity_guid", value)
|
|
750
749
|
|
|
751
|
-
@property
|
|
750
|
+
@_builtins.property
|
|
752
751
|
@pulumi.getter(name="evaluationDelay")
|
|
753
|
-
def evaluation_delay(self) -> Optional[pulumi.Input[
|
|
752
|
+
def evaluation_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
754
753
|
"""
|
|
755
754
|
How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
|
|
756
755
|
"""
|
|
757
756
|
return pulumi.get(self, "evaluation_delay")
|
|
758
757
|
|
|
759
758
|
@evaluation_delay.setter
|
|
760
|
-
def evaluation_delay(self, value: Optional[pulumi.Input[
|
|
759
|
+
def evaluation_delay(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
761
760
|
pulumi.set(self, "evaluation_delay", value)
|
|
762
761
|
|
|
763
|
-
@property
|
|
762
|
+
@_builtins.property
|
|
764
763
|
@pulumi.getter(name="expirationDuration")
|
|
765
|
-
def expiration_duration(self) -> Optional[pulumi.Input[
|
|
764
|
+
def expiration_duration(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
766
765
|
"""
|
|
767
766
|
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
767
|
"""
|
|
769
768
|
return pulumi.get(self, "expiration_duration")
|
|
770
769
|
|
|
771
770
|
@expiration_duration.setter
|
|
772
|
-
def expiration_duration(self, value: Optional[pulumi.Input[
|
|
771
|
+
def expiration_duration(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
773
772
|
pulumi.set(self, "expiration_duration", value)
|
|
774
773
|
|
|
775
|
-
@property
|
|
774
|
+
@_builtins.property
|
|
776
775
|
@pulumi.getter(name="fillOption")
|
|
777
|
-
def fill_option(self) -> Optional[pulumi.Input[
|
|
776
|
+
def fill_option(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
778
777
|
"""
|
|
779
778
|
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
779
|
"""
|
|
781
780
|
return pulumi.get(self, "fill_option")
|
|
782
781
|
|
|
783
782
|
@fill_option.setter
|
|
784
|
-
def fill_option(self, value: Optional[pulumi.Input[
|
|
783
|
+
def fill_option(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
785
784
|
pulumi.set(self, "fill_option", value)
|
|
786
785
|
|
|
787
|
-
@property
|
|
786
|
+
@_builtins.property
|
|
788
787
|
@pulumi.getter(name="fillValue")
|
|
789
|
-
def fill_value(self) -> Optional[pulumi.Input[
|
|
788
|
+
def fill_value(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
790
789
|
"""
|
|
791
790
|
This value will be used for filling gaps in the signal.
|
|
792
791
|
"""
|
|
793
792
|
return pulumi.get(self, "fill_value")
|
|
794
793
|
|
|
795
794
|
@fill_value.setter
|
|
796
|
-
def fill_value(self, value: Optional[pulumi.Input[
|
|
795
|
+
def fill_value(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
797
796
|
pulumi.set(self, "fill_value", value)
|
|
798
797
|
|
|
799
|
-
@property
|
|
798
|
+
@_builtins.property
|
|
800
799
|
@pulumi.getter(name="ignoreOnExpectedTermination")
|
|
801
|
-
def ignore_on_expected_termination(self) -> Optional[pulumi.Input[
|
|
800
|
+
def ignore_on_expected_termination(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
802
801
|
"""
|
|
803
802
|
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
803
|
"""
|
|
805
804
|
return pulumi.get(self, "ignore_on_expected_termination")
|
|
806
805
|
|
|
807
806
|
@ignore_on_expected_termination.setter
|
|
808
|
-
def ignore_on_expected_termination(self, value: Optional[pulumi.Input[
|
|
807
|
+
def ignore_on_expected_termination(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
809
808
|
pulumi.set(self, "ignore_on_expected_termination", value)
|
|
810
809
|
|
|
811
|
-
@property
|
|
810
|
+
@_builtins.property
|
|
812
811
|
@pulumi.getter
|
|
813
|
-
def name(self) -> Optional[pulumi.Input[
|
|
812
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
814
813
|
"""
|
|
815
814
|
The title of the condition.
|
|
816
815
|
"""
|
|
817
816
|
return pulumi.get(self, "name")
|
|
818
817
|
|
|
819
818
|
@name.setter
|
|
820
|
-
def name(self, value: Optional[pulumi.Input[
|
|
819
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
821
820
|
pulumi.set(self, "name", value)
|
|
822
821
|
|
|
823
|
-
@property
|
|
822
|
+
@_builtins.property
|
|
824
823
|
@pulumi.getter
|
|
825
824
|
def nrql(self) -> Optional[pulumi.Input['NrqlAlertConditionNrqlArgs']]:
|
|
826
825
|
"""
|
|
@@ -832,67 +831,67 @@ class _NrqlAlertConditionState:
|
|
|
832
831
|
def nrql(self, value: Optional[pulumi.Input['NrqlAlertConditionNrqlArgs']]):
|
|
833
832
|
pulumi.set(self, "nrql", value)
|
|
834
833
|
|
|
835
|
-
@property
|
|
834
|
+
@_builtins.property
|
|
836
835
|
@pulumi.getter(name="openViolationOnExpiration")
|
|
837
|
-
def open_violation_on_expiration(self) -> Optional[pulumi.Input[
|
|
836
|
+
def open_violation_on_expiration(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
838
837
|
"""
|
|
839
838
|
Whether to create a new incident to capture that the signal expired.
|
|
840
839
|
"""
|
|
841
840
|
return pulumi.get(self, "open_violation_on_expiration")
|
|
842
841
|
|
|
843
842
|
@open_violation_on_expiration.setter
|
|
844
|
-
def open_violation_on_expiration(self, value: Optional[pulumi.Input[
|
|
843
|
+
def open_violation_on_expiration(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
845
844
|
pulumi.set(self, "open_violation_on_expiration", value)
|
|
846
845
|
|
|
847
|
-
@property
|
|
846
|
+
@_builtins.property
|
|
848
847
|
@pulumi.getter(name="policyId")
|
|
849
|
-
def policy_id(self) -> Optional[pulumi.Input[
|
|
848
|
+
def policy_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
850
849
|
"""
|
|
851
850
|
The ID of the policy where this condition should be used.
|
|
852
851
|
"""
|
|
853
852
|
return pulumi.get(self, "policy_id")
|
|
854
853
|
|
|
855
854
|
@policy_id.setter
|
|
856
|
-
def policy_id(self, value: Optional[pulumi.Input[
|
|
855
|
+
def policy_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
857
856
|
pulumi.set(self, "policy_id", value)
|
|
858
857
|
|
|
859
|
-
@property
|
|
858
|
+
@_builtins.property
|
|
860
859
|
@pulumi.getter(name="runbookUrl")
|
|
861
|
-
def runbook_url(self) -> Optional[pulumi.Input[
|
|
860
|
+
def runbook_url(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
862
861
|
"""
|
|
863
862
|
Runbook URL to display in notifications.
|
|
864
863
|
"""
|
|
865
864
|
return pulumi.get(self, "runbook_url")
|
|
866
865
|
|
|
867
866
|
@runbook_url.setter
|
|
868
|
-
def runbook_url(self, value: Optional[pulumi.Input[
|
|
867
|
+
def runbook_url(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
869
868
|
pulumi.set(self, "runbook_url", value)
|
|
870
869
|
|
|
871
|
-
@property
|
|
870
|
+
@_builtins.property
|
|
872
871
|
@pulumi.getter(name="signalSeasonality")
|
|
873
|
-
def signal_seasonality(self) -> Optional[pulumi.Input[
|
|
872
|
+
def signal_seasonality(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
874
873
|
"""
|
|
875
874
|
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
875
|
"""
|
|
877
876
|
return pulumi.get(self, "signal_seasonality")
|
|
878
877
|
|
|
879
878
|
@signal_seasonality.setter
|
|
880
|
-
def signal_seasonality(self, value: Optional[pulumi.Input[
|
|
879
|
+
def signal_seasonality(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
881
880
|
pulumi.set(self, "signal_seasonality", value)
|
|
882
881
|
|
|
883
|
-
@property
|
|
882
|
+
@_builtins.property
|
|
884
883
|
@pulumi.getter(name="slideBy")
|
|
885
|
-
def slide_by(self) -> Optional[pulumi.Input[
|
|
884
|
+
def slide_by(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
886
885
|
"""
|
|
887
886
|
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
887
|
"""
|
|
889
888
|
return pulumi.get(self, "slide_by")
|
|
890
889
|
|
|
891
890
|
@slide_by.setter
|
|
892
|
-
def slide_by(self, value: Optional[pulumi.Input[
|
|
891
|
+
def slide_by(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
893
892
|
pulumi.set(self, "slide_by", value)
|
|
894
893
|
|
|
895
|
-
@property
|
|
894
|
+
@_builtins.property
|
|
896
895
|
@pulumi.getter
|
|
897
896
|
@_utilities.deprecated("""use `critical` and `warning` attributes instead""")
|
|
898
897
|
def terms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NrqlAlertConditionTermArgs']]]]:
|
|
@@ -905,34 +904,34 @@ class _NrqlAlertConditionState:
|
|
|
905
904
|
def terms(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NrqlAlertConditionTermArgs']]]]):
|
|
906
905
|
pulumi.set(self, "terms", value)
|
|
907
906
|
|
|
908
|
-
@property
|
|
907
|
+
@_builtins.property
|
|
909
908
|
@pulumi.getter(name="titleTemplate")
|
|
910
|
-
def title_template(self) -> Optional[pulumi.Input[
|
|
909
|
+
def title_template(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
911
910
|
"""
|
|
912
911
|
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
912
|
"""
|
|
914
913
|
return pulumi.get(self, "title_template")
|
|
915
914
|
|
|
916
915
|
@title_template.setter
|
|
917
|
-
def title_template(self, value: Optional[pulumi.Input[
|
|
916
|
+
def title_template(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
918
917
|
pulumi.set(self, "title_template", value)
|
|
919
918
|
|
|
920
|
-
@property
|
|
919
|
+
@_builtins.property
|
|
921
920
|
@pulumi.getter
|
|
922
|
-
def type(self) -> Optional[pulumi.Input[
|
|
921
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
923
922
|
"""
|
|
924
923
|
The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
|
|
925
924
|
"""
|
|
926
925
|
return pulumi.get(self, "type")
|
|
927
926
|
|
|
928
927
|
@type.setter
|
|
929
|
-
def type(self, value: Optional[pulumi.Input[
|
|
928
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
930
929
|
pulumi.set(self, "type", value)
|
|
931
930
|
|
|
932
|
-
@property
|
|
931
|
+
@_builtins.property
|
|
933
932
|
@pulumi.getter(name="violationTimeLimit")
|
|
934
933
|
@_utilities.deprecated("""use `violation_time_limit_seconds` attribute instead""")
|
|
935
|
-
def violation_time_limit(self) -> Optional[pulumi.Input[
|
|
934
|
+
def violation_time_limit(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
936
935
|
"""
|
|
937
936
|
**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
937
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
@@ -940,12 +939,12 @@ class _NrqlAlertConditionState:
|
|
|
940
939
|
return pulumi.get(self, "violation_time_limit")
|
|
941
940
|
|
|
942
941
|
@violation_time_limit.setter
|
|
943
|
-
def violation_time_limit(self, value: Optional[pulumi.Input[
|
|
942
|
+
def violation_time_limit(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
944
943
|
pulumi.set(self, "violation_time_limit", value)
|
|
945
944
|
|
|
946
|
-
@property
|
|
945
|
+
@_builtins.property
|
|
947
946
|
@pulumi.getter(name="violationTimeLimitSeconds")
|
|
948
|
-
def violation_time_limit_seconds(self) -> Optional[pulumi.Input[
|
|
947
|
+
def violation_time_limit_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
949
948
|
"""
|
|
950
949
|
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
950
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
@@ -953,10 +952,10 @@ class _NrqlAlertConditionState:
|
|
|
953
952
|
return pulumi.get(self, "violation_time_limit_seconds")
|
|
954
953
|
|
|
955
954
|
@violation_time_limit_seconds.setter
|
|
956
|
-
def violation_time_limit_seconds(self, value: Optional[pulumi.Input[
|
|
955
|
+
def violation_time_limit_seconds(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
957
956
|
pulumi.set(self, "violation_time_limit_seconds", value)
|
|
958
957
|
|
|
959
|
-
@property
|
|
958
|
+
@_builtins.property
|
|
960
959
|
@pulumi.getter
|
|
961
960
|
def warning(self) -> Optional[pulumi.Input['NrqlAlertConditionWarningArgs']]:
|
|
962
961
|
"""
|
|
@@ -975,33 +974,33 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
975
974
|
def __init__(__self__,
|
|
976
975
|
resource_name: str,
|
|
977
976
|
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[
|
|
977
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
978
|
+
aggregation_delay: Optional[pulumi.Input[_builtins.str]] = None,
|
|
979
|
+
aggregation_method: Optional[pulumi.Input[_builtins.str]] = None,
|
|
980
|
+
aggregation_timer: Optional[pulumi.Input[_builtins.str]] = None,
|
|
981
|
+
aggregation_window: Optional[pulumi.Input[_builtins.int]] = None,
|
|
982
|
+
baseline_direction: Optional[pulumi.Input[_builtins.str]] = None,
|
|
983
|
+
close_violations_on_expiration: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
985
984
|
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[
|
|
985
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
986
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
987
|
+
evaluation_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
988
|
+
expiration_duration: Optional[pulumi.Input[_builtins.int]] = None,
|
|
989
|
+
fill_option: Optional[pulumi.Input[_builtins.str]] = None,
|
|
990
|
+
fill_value: Optional[pulumi.Input[_builtins.float]] = None,
|
|
991
|
+
ignore_on_expected_termination: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
992
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
994
993
|
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[
|
|
994
|
+
open_violation_on_expiration: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
995
|
+
policy_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
996
|
+
runbook_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
997
|
+
signal_seasonality: Optional[pulumi.Input[_builtins.str]] = None,
|
|
998
|
+
slide_by: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1000
999
|
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[
|
|
1000
|
+
title_template: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1001
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1002
|
+
violation_time_limit: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1003
|
+
violation_time_limit_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1005
1004
|
warning: Optional[pulumi.Input[Union['NrqlAlertConditionWarningArgs', 'NrqlAlertConditionWarningArgsDict']]] = None,
|
|
1006
1005
|
__props__=None):
|
|
1007
1006
|
"""
|
|
@@ -1280,34 +1279,34 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1280
1279
|
|
|
1281
1280
|
:param str resource_name: The name of the resource.
|
|
1282
1281
|
: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[
|
|
1282
|
+
: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`.
|
|
1283
|
+
: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`.
|
|
1284
|
+
: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`.
|
|
1285
|
+
: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`.
|
|
1286
|
+
: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.
|
|
1287
|
+
: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).
|
|
1288
|
+
:param pulumi.Input[_builtins.bool] close_violations_on_expiration: Whether to close all open incidents when the signal expires.
|
|
1290
1289
|
: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[
|
|
1290
|
+
:param pulumi.Input[_builtins.str] description: The description of the NRQL alert condition.
|
|
1291
|
+
:param pulumi.Input[_builtins.bool] enabled: Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
|
|
1292
|
+
:param pulumi.Input[_builtins.int] evaluation_delay: How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
|
|
1293
|
+
: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).
|
|
1294
|
+
: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.
|
|
1295
|
+
:param pulumi.Input[_builtins.float] fill_value: This value will be used for filling gaps in the signal.
|
|
1296
|
+
: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.
|
|
1297
|
+
:param pulumi.Input[_builtins.str] name: The title of the condition.
|
|
1299
1298
|
: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[
|
|
1299
|
+
:param pulumi.Input[_builtins.bool] open_violation_on_expiration: Whether to create a new incident to capture that the signal expired.
|
|
1300
|
+
:param pulumi.Input[_builtins.str] policy_id: The ID of the policy where this condition should be used.
|
|
1301
|
+
:param pulumi.Input[_builtins.str] runbook_url: Runbook URL to display in notifications.
|
|
1302
|
+
: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`.
|
|
1303
|
+
: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`.
|
|
1305
1304
|
: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[
|
|
1305
|
+
: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.
|
|
1306
|
+
:param pulumi.Input[_builtins.str] type: The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
|
|
1307
|
+
: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
1308
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
1310
|
-
:param pulumi.Input[
|
|
1309
|
+
: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
1310
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
1312
1311
|
: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
1312
|
"""
|
|
@@ -1606,33 +1605,33 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1606
1605
|
def _internal_init(__self__,
|
|
1607
1606
|
resource_name: str,
|
|
1608
1607
|
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[
|
|
1608
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1609
|
+
aggregation_delay: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1610
|
+
aggregation_method: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1611
|
+
aggregation_timer: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1612
|
+
aggregation_window: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1613
|
+
baseline_direction: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1614
|
+
close_violations_on_expiration: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1616
1615
|
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[
|
|
1616
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1617
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1618
|
+
evaluation_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1619
|
+
expiration_duration: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1620
|
+
fill_option: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1621
|
+
fill_value: Optional[pulumi.Input[_builtins.float]] = None,
|
|
1622
|
+
ignore_on_expected_termination: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1623
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1625
1624
|
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[
|
|
1625
|
+
open_violation_on_expiration: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1626
|
+
policy_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1627
|
+
runbook_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1628
|
+
signal_seasonality: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1629
|
+
slide_by: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1631
1630
|
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[
|
|
1631
|
+
title_template: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1632
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1633
|
+
violation_time_limit: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1634
|
+
violation_time_limit_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1636
1635
|
warning: Optional[pulumi.Input[Union['NrqlAlertConditionWarningArgs', 'NrqlAlertConditionWarningArgsDict']]] = None,
|
|
1637
1636
|
__props__=None):
|
|
1638
1637
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
@@ -1686,34 +1685,34 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1686
1685
|
def get(resource_name: str,
|
|
1687
1686
|
id: pulumi.Input[str],
|
|
1688
1687
|
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[
|
|
1688
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1689
|
+
aggregation_delay: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1690
|
+
aggregation_method: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1691
|
+
aggregation_timer: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1692
|
+
aggregation_window: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1693
|
+
baseline_direction: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1694
|
+
close_violations_on_expiration: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1696
1695
|
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[
|
|
1696
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1697
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1698
|
+
entity_guid: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1699
|
+
evaluation_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1700
|
+
expiration_duration: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1701
|
+
fill_option: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1702
|
+
fill_value: Optional[pulumi.Input[_builtins.float]] = None,
|
|
1703
|
+
ignore_on_expected_termination: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1704
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1706
1705
|
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[
|
|
1706
|
+
open_violation_on_expiration: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1707
|
+
policy_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1708
|
+
runbook_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1709
|
+
signal_seasonality: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1710
|
+
slide_by: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1712
1711
|
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[
|
|
1712
|
+
title_template: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1713
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1714
|
+
violation_time_limit: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1715
|
+
violation_time_limit_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1717
1716
|
warning: Optional[pulumi.Input[Union['NrqlAlertConditionWarningArgs', 'NrqlAlertConditionWarningArgsDict']]] = None) -> 'NrqlAlertCondition':
|
|
1718
1717
|
"""
|
|
1719
1718
|
Get an existing NrqlAlertCondition resource's state with the given name, id, and optional extra
|
|
@@ -1722,35 +1721,35 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1722
1721
|
:param str resource_name: The unique name of the resulting resource.
|
|
1723
1722
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1724
1723
|
: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[
|
|
1724
|
+
: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`.
|
|
1725
|
+
: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`.
|
|
1726
|
+
: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`.
|
|
1727
|
+
: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`.
|
|
1728
|
+
: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.
|
|
1729
|
+
: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).
|
|
1730
|
+
:param pulumi.Input[_builtins.bool] close_violations_on_expiration: Whether to close all open incidents when the signal expires.
|
|
1732
1731
|
: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[
|
|
1732
|
+
:param pulumi.Input[_builtins.str] description: The description of the NRQL alert condition.
|
|
1733
|
+
:param pulumi.Input[_builtins.bool] enabled: Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
|
|
1734
|
+
:param pulumi.Input[_builtins.str] entity_guid: The unique entity identifier of the NRQL Condition in New Relic.
|
|
1735
|
+
:param pulumi.Input[_builtins.int] evaluation_delay: How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
|
|
1736
|
+
: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).
|
|
1737
|
+
: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.
|
|
1738
|
+
:param pulumi.Input[_builtins.float] fill_value: This value will be used for filling gaps in the signal.
|
|
1739
|
+
: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.
|
|
1740
|
+
:param pulumi.Input[_builtins.str] name: The title of the condition.
|
|
1742
1741
|
: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[
|
|
1742
|
+
:param pulumi.Input[_builtins.bool] open_violation_on_expiration: Whether to create a new incident to capture that the signal expired.
|
|
1743
|
+
:param pulumi.Input[_builtins.str] policy_id: The ID of the policy where this condition should be used.
|
|
1744
|
+
:param pulumi.Input[_builtins.str] runbook_url: Runbook URL to display in notifications.
|
|
1745
|
+
: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`.
|
|
1746
|
+
: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`.
|
|
1748
1747
|
: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[
|
|
1748
|
+
: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.
|
|
1749
|
+
:param pulumi.Input[_builtins.str] type: The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
|
|
1750
|
+
: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
1751
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
1753
|
-
:param pulumi.Input[
|
|
1752
|
+
: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
1753
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
1755
1754
|
: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
1755
|
"""
|
|
@@ -1789,63 +1788,63 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1789
1788
|
__props__.__dict__["warning"] = warning
|
|
1790
1789
|
return NrqlAlertCondition(resource_name, opts=opts, __props__=__props__)
|
|
1791
1790
|
|
|
1792
|
-
@property
|
|
1791
|
+
@_builtins.property
|
|
1793
1792
|
@pulumi.getter(name="accountId")
|
|
1794
|
-
def account_id(self) -> pulumi.Output[
|
|
1793
|
+
def account_id(self) -> pulumi.Output[_builtins.str]:
|
|
1795
1794
|
"""
|
|
1796
1795
|
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
1796
|
"""
|
|
1798
1797
|
return pulumi.get(self, "account_id")
|
|
1799
1798
|
|
|
1800
|
-
@property
|
|
1799
|
+
@_builtins.property
|
|
1801
1800
|
@pulumi.getter(name="aggregationDelay")
|
|
1802
|
-
def aggregation_delay(self) -> pulumi.Output[Optional[
|
|
1801
|
+
def aggregation_delay(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1803
1802
|
"""
|
|
1804
1803
|
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
1804
|
"""
|
|
1806
1805
|
return pulumi.get(self, "aggregation_delay")
|
|
1807
1806
|
|
|
1808
|
-
@property
|
|
1807
|
+
@_builtins.property
|
|
1809
1808
|
@pulumi.getter(name="aggregationMethod")
|
|
1810
|
-
def aggregation_method(self) -> pulumi.Output[Optional[
|
|
1809
|
+
def aggregation_method(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1811
1810
|
"""
|
|
1812
1811
|
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
1812
|
"""
|
|
1814
1813
|
return pulumi.get(self, "aggregation_method")
|
|
1815
1814
|
|
|
1816
|
-
@property
|
|
1815
|
+
@_builtins.property
|
|
1817
1816
|
@pulumi.getter(name="aggregationTimer")
|
|
1818
|
-
def aggregation_timer(self) -> pulumi.Output[Optional[
|
|
1817
|
+
def aggregation_timer(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1819
1818
|
"""
|
|
1820
1819
|
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
1820
|
"""
|
|
1822
1821
|
return pulumi.get(self, "aggregation_timer")
|
|
1823
1822
|
|
|
1824
|
-
@property
|
|
1823
|
+
@_builtins.property
|
|
1825
1824
|
@pulumi.getter(name="aggregationWindow")
|
|
1826
|
-
def aggregation_window(self) -> pulumi.Output[
|
|
1825
|
+
def aggregation_window(self) -> pulumi.Output[_builtins.int]:
|
|
1827
1826
|
"""
|
|
1828
1827
|
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
1828
|
"""
|
|
1830
1829
|
return pulumi.get(self, "aggregation_window")
|
|
1831
1830
|
|
|
1832
|
-
@property
|
|
1831
|
+
@_builtins.property
|
|
1833
1832
|
@pulumi.getter(name="baselineDirection")
|
|
1834
|
-
def baseline_direction(self) -> pulumi.Output[Optional[
|
|
1833
|
+
def baseline_direction(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1835
1834
|
"""
|
|
1836
1835
|
The baseline direction of a _baseline_ NRQL alert condition. Valid values are: `lower_only`, `upper_and_lower`, `upper_only` (case insensitive).
|
|
1837
1836
|
"""
|
|
1838
1837
|
return pulumi.get(self, "baseline_direction")
|
|
1839
1838
|
|
|
1840
|
-
@property
|
|
1839
|
+
@_builtins.property
|
|
1841
1840
|
@pulumi.getter(name="closeViolationsOnExpiration")
|
|
1842
|
-
def close_violations_on_expiration(self) -> pulumi.Output[Optional[
|
|
1841
|
+
def close_violations_on_expiration(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1843
1842
|
"""
|
|
1844
1843
|
Whether to close all open incidents when the signal expires.
|
|
1845
1844
|
"""
|
|
1846
1845
|
return pulumi.get(self, "close_violations_on_expiration")
|
|
1847
1846
|
|
|
1848
|
-
@property
|
|
1847
|
+
@_builtins.property
|
|
1849
1848
|
@pulumi.getter
|
|
1850
1849
|
def critical(self) -> pulumi.Output[Optional['outputs.NrqlAlertConditionCritical']]:
|
|
1851
1850
|
"""
|
|
@@ -1853,79 +1852,79 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1853
1852
|
"""
|
|
1854
1853
|
return pulumi.get(self, "critical")
|
|
1855
1854
|
|
|
1856
|
-
@property
|
|
1855
|
+
@_builtins.property
|
|
1857
1856
|
@pulumi.getter
|
|
1858
|
-
def description(self) -> pulumi.Output[Optional[
|
|
1857
|
+
def description(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1859
1858
|
"""
|
|
1860
1859
|
The description of the NRQL alert condition.
|
|
1861
1860
|
"""
|
|
1862
1861
|
return pulumi.get(self, "description")
|
|
1863
1862
|
|
|
1864
|
-
@property
|
|
1863
|
+
@_builtins.property
|
|
1865
1864
|
@pulumi.getter
|
|
1866
|
-
def enabled(self) -> pulumi.Output[Optional[
|
|
1865
|
+
def enabled(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1867
1866
|
"""
|
|
1868
1867
|
Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
|
|
1869
1868
|
"""
|
|
1870
1869
|
return pulumi.get(self, "enabled")
|
|
1871
1870
|
|
|
1872
|
-
@property
|
|
1871
|
+
@_builtins.property
|
|
1873
1872
|
@pulumi.getter(name="entityGuid")
|
|
1874
|
-
def entity_guid(self) -> pulumi.Output[
|
|
1873
|
+
def entity_guid(self) -> pulumi.Output[_builtins.str]:
|
|
1875
1874
|
"""
|
|
1876
1875
|
The unique entity identifier of the NRQL Condition in New Relic.
|
|
1877
1876
|
"""
|
|
1878
1877
|
return pulumi.get(self, "entity_guid")
|
|
1879
1878
|
|
|
1880
|
-
@property
|
|
1879
|
+
@_builtins.property
|
|
1881
1880
|
@pulumi.getter(name="evaluationDelay")
|
|
1882
|
-
def evaluation_delay(self) -> pulumi.Output[Optional[
|
|
1881
|
+
def evaluation_delay(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1883
1882
|
"""
|
|
1884
1883
|
How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
|
|
1885
1884
|
"""
|
|
1886
1885
|
return pulumi.get(self, "evaluation_delay")
|
|
1887
1886
|
|
|
1888
|
-
@property
|
|
1887
|
+
@_builtins.property
|
|
1889
1888
|
@pulumi.getter(name="expirationDuration")
|
|
1890
|
-
def expiration_duration(self) -> pulumi.Output[Optional[
|
|
1889
|
+
def expiration_duration(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1891
1890
|
"""
|
|
1892
1891
|
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
1892
|
"""
|
|
1894
1893
|
return pulumi.get(self, "expiration_duration")
|
|
1895
1894
|
|
|
1896
|
-
@property
|
|
1895
|
+
@_builtins.property
|
|
1897
1896
|
@pulumi.getter(name="fillOption")
|
|
1898
|
-
def fill_option(self) -> pulumi.Output[Optional[
|
|
1897
|
+
def fill_option(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1899
1898
|
"""
|
|
1900
1899
|
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
1900
|
"""
|
|
1902
1901
|
return pulumi.get(self, "fill_option")
|
|
1903
1902
|
|
|
1904
|
-
@property
|
|
1903
|
+
@_builtins.property
|
|
1905
1904
|
@pulumi.getter(name="fillValue")
|
|
1906
|
-
def fill_value(self) -> pulumi.Output[Optional[
|
|
1905
|
+
def fill_value(self) -> pulumi.Output[Optional[_builtins.float]]:
|
|
1907
1906
|
"""
|
|
1908
1907
|
This value will be used for filling gaps in the signal.
|
|
1909
1908
|
"""
|
|
1910
1909
|
return pulumi.get(self, "fill_value")
|
|
1911
1910
|
|
|
1912
|
-
@property
|
|
1911
|
+
@_builtins.property
|
|
1913
1912
|
@pulumi.getter(name="ignoreOnExpectedTermination")
|
|
1914
|
-
def ignore_on_expected_termination(self) -> pulumi.Output[Optional[
|
|
1913
|
+
def ignore_on_expected_termination(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1915
1914
|
"""
|
|
1916
1915
|
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
1916
|
"""
|
|
1918
1917
|
return pulumi.get(self, "ignore_on_expected_termination")
|
|
1919
1918
|
|
|
1920
|
-
@property
|
|
1919
|
+
@_builtins.property
|
|
1921
1920
|
@pulumi.getter
|
|
1922
|
-
def name(self) -> pulumi.Output[
|
|
1921
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
1923
1922
|
"""
|
|
1924
1923
|
The title of the condition.
|
|
1925
1924
|
"""
|
|
1926
1925
|
return pulumi.get(self, "name")
|
|
1927
1926
|
|
|
1928
|
-
@property
|
|
1927
|
+
@_builtins.property
|
|
1929
1928
|
@pulumi.getter
|
|
1930
1929
|
def nrql(self) -> pulumi.Output['outputs.NrqlAlertConditionNrql']:
|
|
1931
1930
|
"""
|
|
@@ -1933,47 +1932,47 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1933
1932
|
"""
|
|
1934
1933
|
return pulumi.get(self, "nrql")
|
|
1935
1934
|
|
|
1936
|
-
@property
|
|
1935
|
+
@_builtins.property
|
|
1937
1936
|
@pulumi.getter(name="openViolationOnExpiration")
|
|
1938
|
-
def open_violation_on_expiration(self) -> pulumi.Output[Optional[
|
|
1937
|
+
def open_violation_on_expiration(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1939
1938
|
"""
|
|
1940
1939
|
Whether to create a new incident to capture that the signal expired.
|
|
1941
1940
|
"""
|
|
1942
1941
|
return pulumi.get(self, "open_violation_on_expiration")
|
|
1943
1942
|
|
|
1944
|
-
@property
|
|
1943
|
+
@_builtins.property
|
|
1945
1944
|
@pulumi.getter(name="policyId")
|
|
1946
|
-
def policy_id(self) -> pulumi.Output[
|
|
1945
|
+
def policy_id(self) -> pulumi.Output[_builtins.str]:
|
|
1947
1946
|
"""
|
|
1948
1947
|
The ID of the policy where this condition should be used.
|
|
1949
1948
|
"""
|
|
1950
1949
|
return pulumi.get(self, "policy_id")
|
|
1951
1950
|
|
|
1952
|
-
@property
|
|
1951
|
+
@_builtins.property
|
|
1953
1952
|
@pulumi.getter(name="runbookUrl")
|
|
1954
|
-
def runbook_url(self) -> pulumi.Output[Optional[
|
|
1953
|
+
def runbook_url(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1955
1954
|
"""
|
|
1956
1955
|
Runbook URL to display in notifications.
|
|
1957
1956
|
"""
|
|
1958
1957
|
return pulumi.get(self, "runbook_url")
|
|
1959
1958
|
|
|
1960
|
-
@property
|
|
1959
|
+
@_builtins.property
|
|
1961
1960
|
@pulumi.getter(name="signalSeasonality")
|
|
1962
|
-
def signal_seasonality(self) -> pulumi.Output[Optional[
|
|
1961
|
+
def signal_seasonality(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1963
1962
|
"""
|
|
1964
1963
|
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
1964
|
"""
|
|
1966
1965
|
return pulumi.get(self, "signal_seasonality")
|
|
1967
1966
|
|
|
1968
|
-
@property
|
|
1967
|
+
@_builtins.property
|
|
1969
1968
|
@pulumi.getter(name="slideBy")
|
|
1970
|
-
def slide_by(self) -> pulumi.Output[Optional[
|
|
1969
|
+
def slide_by(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1971
1970
|
"""
|
|
1972
1971
|
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
1972
|
"""
|
|
1974
1973
|
return pulumi.get(self, "slide_by")
|
|
1975
1974
|
|
|
1976
|
-
@property
|
|
1975
|
+
@_builtins.property
|
|
1977
1976
|
@pulumi.getter
|
|
1978
1977
|
@_utilities.deprecated("""use `critical` and `warning` attributes instead""")
|
|
1979
1978
|
def terms(self) -> pulumi.Output[Optional[Sequence['outputs.NrqlAlertConditionTerm']]]:
|
|
@@ -1982,42 +1981,42 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1982
1981
|
"""
|
|
1983
1982
|
return pulumi.get(self, "terms")
|
|
1984
1983
|
|
|
1985
|
-
@property
|
|
1984
|
+
@_builtins.property
|
|
1986
1985
|
@pulumi.getter(name="titleTemplate")
|
|
1987
|
-
def title_template(self) -> pulumi.Output[Optional[
|
|
1986
|
+
def title_template(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1988
1987
|
"""
|
|
1989
1988
|
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
1989
|
"""
|
|
1991
1990
|
return pulumi.get(self, "title_template")
|
|
1992
1991
|
|
|
1993
|
-
@property
|
|
1992
|
+
@_builtins.property
|
|
1994
1993
|
@pulumi.getter
|
|
1995
|
-
def type(self) -> pulumi.Output[Optional[
|
|
1994
|
+
def type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1996
1995
|
"""
|
|
1997
1996
|
The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
|
|
1998
1997
|
"""
|
|
1999
1998
|
return pulumi.get(self, "type")
|
|
2000
1999
|
|
|
2001
|
-
@property
|
|
2000
|
+
@_builtins.property
|
|
2002
2001
|
@pulumi.getter(name="violationTimeLimit")
|
|
2003
2002
|
@_utilities.deprecated("""use `violation_time_limit_seconds` attribute instead""")
|
|
2004
|
-
def violation_time_limit(self) -> pulumi.Output[
|
|
2003
|
+
def violation_time_limit(self) -> pulumi.Output[_builtins.str]:
|
|
2005
2004
|
"""
|
|
2006
2005
|
**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
2006
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
2008
2007
|
"""
|
|
2009
2008
|
return pulumi.get(self, "violation_time_limit")
|
|
2010
2009
|
|
|
2011
|
-
@property
|
|
2010
|
+
@_builtins.property
|
|
2012
2011
|
@pulumi.getter(name="violationTimeLimitSeconds")
|
|
2013
|
-
def violation_time_limit_seconds(self) -> pulumi.Output[Optional[
|
|
2012
|
+
def violation_time_limit_seconds(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
2014
2013
|
"""
|
|
2015
2014
|
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
2015
|
<small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
|
|
2017
2016
|
"""
|
|
2018
2017
|
return pulumi.get(self, "violation_time_limit_seconds")
|
|
2019
2018
|
|
|
2020
|
-
@property
|
|
2019
|
+
@_builtins.property
|
|
2021
2020
|
@pulumi.getter
|
|
2022
2021
|
def warning(self) -> pulumi.Output[Optional['outputs.NrqlAlertConditionWarning']]:
|
|
2023
2022
|
"""
|