pulumi-newrelic 5.16.0a1698964311__py3-none-any.whl → 5.58.0a1763707205__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 +58 -1
- pulumi_newrelic/_inputs.py +10772 -2775
- pulumi_newrelic/_utilities.py +92 -11
- pulumi_newrelic/account_management.py +56 -42
- pulumi_newrelic/alert_channel.py +177 -151
- pulumi_newrelic/alert_condition.py +313 -301
- pulumi_newrelic/alert_muting_rule.py +195 -138
- pulumi_newrelic/alert_policy.py +157 -109
- pulumi_newrelic/alert_policy_channel.py +95 -81
- pulumi_newrelic/api_access_key.py +191 -209
- pulumi_newrelic/browser_application.py +161 -153
- pulumi_newrelic/cloud/__init__.py +3 -1
- pulumi_newrelic/cloud/_inputs.py +4267 -2710
- pulumi_newrelic/cloud/aws_govcloud_integrations.py +238 -200
- pulumi_newrelic/cloud/aws_govcloud_link_account.py +159 -212
- pulumi_newrelic/cloud/aws_integrations.py +518 -1490
- pulumi_newrelic/cloud/aws_link_account.py +88 -76
- pulumi_newrelic/cloud/azure_integrations.py +681 -587
- pulumi_newrelic/cloud/azure_link_account.py +129 -117
- pulumi_newrelic/cloud/gcp_integrations.py +436 -408
- pulumi_newrelic/cloud/gcp_link_account.py +71 -59
- pulumi_newrelic/cloud/oci_link_account.py +926 -0
- pulumi_newrelic/cloud/outputs.py +1678 -2317
- pulumi_newrelic/config/__init__.py +2 -1
- pulumi_newrelic/config/__init__.pyi +45 -0
- pulumi_newrelic/config/vars.py +22 -17
- pulumi_newrelic/data_partition_rule.py +129 -117
- pulumi_newrelic/entity_tags.py +153 -31
- pulumi_newrelic/events_to_metrics_rule.py +114 -102
- pulumi_newrelic/get_account.py +41 -29
- pulumi_newrelic/get_alert_channel.py +73 -28
- pulumi_newrelic/get_alert_policy.py +83 -34
- pulumi_newrelic/get_application.py +51 -39
- pulumi_newrelic/get_authentication_domain.py +111 -0
- pulumi_newrelic/get_cloud_account.py +43 -31
- pulumi_newrelic/get_entity.py +126 -121
- pulumi_newrelic/get_group.py +190 -0
- pulumi_newrelic/get_key_transaction.py +117 -38
- pulumi_newrelic/get_notification_destination.py +86 -36
- pulumi_newrelic/get_obfuscation_expression.py +47 -35
- pulumi_newrelic/get_service_level_alert_helper.py +237 -137
- pulumi_newrelic/get_test_grok_pattern.py +47 -32
- pulumi_newrelic/get_user.py +165 -0
- pulumi_newrelic/group.py +286 -0
- pulumi_newrelic/infra_alert_condition.py +400 -382
- pulumi_newrelic/insights/__init__.py +2 -1
- pulumi_newrelic/insights/_inputs.py +94 -23
- pulumi_newrelic/insights/event.py +56 -48
- pulumi_newrelic/insights/outputs.py +51 -18
- pulumi_newrelic/key_transaction.py +465 -0
- pulumi_newrelic/log_parsing_rule.py +169 -153
- pulumi_newrelic/monitor_downtime.py +914 -0
- pulumi_newrelic/notification_channel.py +560 -418
- pulumi_newrelic/notification_destination.py +379 -124
- pulumi_newrelic/nrql_alert_condition.py +945 -513
- pulumi_newrelic/nrql_drop_rule.py +121 -129
- pulumi_newrelic/obfuscation_expression.py +88 -76
- pulumi_newrelic/obfuscation_rule.py +123 -109
- pulumi_newrelic/one_dashboard.py +118 -108
- pulumi_newrelic/one_dashboard_json.py +77 -67
- pulumi_newrelic/one_dashboard_raw.py +214 -202
- pulumi_newrelic/outputs.py +5491 -2141
- pulumi_newrelic/pipeline_cloud_rule.py +335 -0
- pulumi_newrelic/plugins/__init__.py +2 -1
- pulumi_newrelic/plugins/_inputs.py +520 -90
- pulumi_newrelic/plugins/application_settings.py +463 -167
- pulumi_newrelic/plugins/outputs.py +337 -75
- pulumi_newrelic/plugins/workload.py +387 -151
- pulumi_newrelic/provider.py +156 -142
- pulumi_newrelic/pulumi-plugin.json +2 -1
- pulumi_newrelic/service_level.py +277 -255
- pulumi_newrelic/synthetics/__init__.py +2 -1
- pulumi_newrelic/synthetics/_inputs.py +275 -106
- pulumi_newrelic/synthetics/alert_condition.py +174 -160
- pulumi_newrelic/synthetics/broken_links_monitor.py +367 -207
- pulumi_newrelic/synthetics/cert_check_monitor.py +380 -218
- pulumi_newrelic/synthetics/get_private_location.py +51 -39
- pulumi_newrelic/synthetics/get_secure_credential.py +39 -27
- pulumi_newrelic/synthetics/monitor.py +668 -462
- pulumi_newrelic/synthetics/multi_location_alert_condition.py +219 -201
- pulumi_newrelic/synthetics/outputs.py +102 -85
- pulumi_newrelic/synthetics/private_location.py +120 -110
- pulumi_newrelic/synthetics/script_monitor.py +623 -375
- pulumi_newrelic/synthetics/secure_credential.py +99 -93
- pulumi_newrelic/synthetics/step_monitor.py +545 -201
- pulumi_newrelic/user.py +366 -0
- pulumi_newrelic/workflow.py +348 -312
- {pulumi_newrelic-5.16.0a1698964311.dist-info → pulumi_newrelic-5.58.0a1763707205.dist-info}/METADATA +8 -7
- pulumi_newrelic-5.58.0a1763707205.dist-info/RECORD +92 -0
- {pulumi_newrelic-5.16.0a1698964311.dist-info → pulumi_newrelic-5.58.0a1763707205.dist-info}/WHEEL +1 -1
- pulumi_newrelic-5.16.0a1698964311.dist-info/RECORD +0 -82
- {pulumi_newrelic-5.16.0a1698964311.dist-info → pulumi_newrelic-5.58.0a1763707205.dist-info}/top_level.txt +0 -0
|
@@ -1,12 +1,17 @@
|
|
|
1
1
|
# coding=utf-8
|
|
2
|
-
# *** WARNING: this file was generated by
|
|
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
|
|
5
|
+
import builtins as _builtins
|
|
6
6
|
import warnings
|
|
7
|
+
import sys
|
|
7
8
|
import pulumi
|
|
8
9
|
import pulumi.runtime
|
|
9
10
|
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
10
15
|
from . import _utilities
|
|
11
16
|
from . import outputs
|
|
12
17
|
from ._inputs import *
|
|
@@ -16,42 +21,42 @@ __all__ = ['InfraAlertConditionArgs', 'InfraAlertCondition']
|
|
|
16
21
|
@pulumi.input_type
|
|
17
22
|
class InfraAlertConditionArgs:
|
|
18
23
|
def __init__(__self__, *,
|
|
19
|
-
policy_id: pulumi.Input[
|
|
20
|
-
type: pulumi.Input[str],
|
|
21
|
-
comparison: Optional[pulumi.Input[str]] = None,
|
|
24
|
+
policy_id: pulumi.Input[_builtins.str],
|
|
25
|
+
type: pulumi.Input[_builtins.str],
|
|
26
|
+
comparison: Optional[pulumi.Input[_builtins.str]] = None,
|
|
22
27
|
critical: Optional[pulumi.Input['InfraAlertConditionCriticalArgs']] = None,
|
|
23
|
-
description: Optional[pulumi.Input[str]] = None,
|
|
24
|
-
enabled: Optional[pulumi.Input[bool]] = None,
|
|
25
|
-
event: Optional[pulumi.Input[str]] = None,
|
|
26
|
-
integration_provider: Optional[pulumi.Input[str]] = None,
|
|
27
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
28
|
-
process_where: Optional[pulumi.Input[str]] = None,
|
|
29
|
-
runbook_url: Optional[pulumi.Input[str]] = None,
|
|
30
|
-
select: Optional[pulumi.Input[str]] = None,
|
|
31
|
-
violation_close_timer: Optional[pulumi.Input[int]] = None,
|
|
28
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
29
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
30
|
+
event: Optional[pulumi.Input[_builtins.str]] = None,
|
|
31
|
+
integration_provider: Optional[pulumi.Input[_builtins.str]] = None,
|
|
32
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
33
|
+
process_where: Optional[pulumi.Input[_builtins.str]] = None,
|
|
34
|
+
runbook_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
35
|
+
select: Optional[pulumi.Input[_builtins.str]] = None,
|
|
36
|
+
violation_close_timer: Optional[pulumi.Input[_builtins.int]] = None,
|
|
32
37
|
warning: Optional[pulumi.Input['InfraAlertConditionWarningArgs']] = None,
|
|
33
|
-
where: Optional[pulumi.Input[str]] = None):
|
|
38
|
+
where: Optional[pulumi.Input[_builtins.str]] = None):
|
|
34
39
|
"""
|
|
35
40
|
The set of arguments for constructing a InfraAlertCondition resource.
|
|
36
|
-
:param pulumi.Input[
|
|
37
|
-
:param pulumi.Input[str] type: The type of Infrastructure alert condition. Valid values are `infra_process_running`, `infra_metric`, and `infra_host_not_reporting`.
|
|
38
|
-
:param pulumi.Input[str] comparison: The operator used to evaluate the threshold value. Valid values are `above`, `below`, and `equal`. Supported by the `infra_metric` and `infra_process_running` condition types.
|
|
41
|
+
:param pulumi.Input[_builtins.str] policy_id: The ID of the alert policy where this condition should be used.
|
|
42
|
+
:param pulumi.Input[_builtins.str] type: The type of Infrastructure alert condition. Valid values are `infra_process_running`, `infra_metric`, and `infra_host_not_reporting`.
|
|
43
|
+
:param pulumi.Input[_builtins.str] comparison: The operator used to evaluate the threshold value. Valid values are `above`, `below`, and `equal`. Supported by the `infra_metric` and `infra_process_running` condition types.
|
|
39
44
|
:param pulumi.Input['InfraAlertConditionCriticalArgs'] critical: Identifies the threshold parameters for opening a critical alert incident. See Thresholds below for details.
|
|
40
|
-
:param pulumi.Input[str] description: The description of the Infrastructure alert condition.
|
|
41
|
-
:param pulumi.Input[bool] enabled: Whether the condition is turned on or off. Valid values are `true` and `false`. Defaults to `true`.
|
|
42
|
-
:param pulumi.Input[str] event: The metric event; for example, `SystemSample` or `StorageSample`. Supported by the `infra_metric` condition type.
|
|
43
|
-
:param pulumi.Input[str] integration_provider: For alerts on integrations, use this instead of `event`. Supported by the `infra_metric` condition type.
|
|
44
|
-
:param pulumi.Input[str] name: The Infrastructure alert condition's name.
|
|
45
|
-
:param pulumi.Input[str] process_where: Any filters applied to processes; for example: `commandName = 'java'`. Required by the `infra_process_running` condition type.
|
|
46
|
-
:param pulumi.Input[str] runbook_url: Runbook URL to display in notifications.
|
|
47
|
-
:param pulumi.Input[str] select: The attribute name to identify the metric being targeted; for example, `cpuPercent`, `diskFreePercent`, or `memoryResidentSizeBytes`. The underlying API will automatically populate this value for Infrastructure integrations (for example `diskFreePercent`), so make sure to explicitly include this value to avoid diff issues. Supported by the `infra_metric` condition type.
|
|
48
|
-
:param pulumi.Input[int] violation_close_timer: Determines how much time will pass (in hours) before an incident is automatically closed. Valid values are `1 2 4 8 12 24 48 72`. Defaults to 24. If `0` is provided, default of `24` is used and will have configuration drift during the apply phase until a valid value is provided.
|
|
45
|
+
:param pulumi.Input[_builtins.str] description: The description of the Infrastructure alert condition.
|
|
46
|
+
:param pulumi.Input[_builtins.bool] enabled: Whether the condition is turned on or off. Valid values are `true` and `false`. Defaults to `true`.
|
|
47
|
+
:param pulumi.Input[_builtins.str] event: The metric event; for example, `SystemSample` or `StorageSample`. Supported by the `infra_metric` condition type.
|
|
48
|
+
:param pulumi.Input[_builtins.str] integration_provider: For alerts on integrations, use this instead of `event`. Supported by the `infra_metric` condition type.
|
|
49
|
+
:param pulumi.Input[_builtins.str] name: The Infrastructure alert condition's name.
|
|
50
|
+
:param pulumi.Input[_builtins.str] process_where: Any filters applied to processes; for example: `commandName = 'java'`. Required by the `infra_process_running` condition type.
|
|
51
|
+
:param pulumi.Input[_builtins.str] runbook_url: Runbook URL to display in notifications.
|
|
52
|
+
:param pulumi.Input[_builtins.str] select: The attribute name to identify the metric being targeted; for example, `cpuPercent`, `diskFreePercent`, or `memoryResidentSizeBytes`. The underlying API will automatically populate this value for Infrastructure integrations (for example `diskFreePercent`), so make sure to explicitly include this value to avoid diff issues. Supported by the `infra_metric` condition type.
|
|
53
|
+
:param pulumi.Input[_builtins.int] violation_close_timer: Determines how much time will pass (in hours) before an incident is automatically closed. Valid values are `1 2 4 8 12 24 48 72`. Defaults to 24. If `0` is provided, default of `24` is used and will have configuration drift during the apply phase until a valid value is provided.
|
|
49
54
|
|
|
50
|
-
```
|
|
51
|
-
|
|
55
|
+
```
|
|
56
|
+
Warning: This resource will use the account ID linked to your API key. At the moment it is not possible to dynamically set the account ID.
|
|
52
57
|
```
|
|
53
58
|
:param pulumi.Input['InfraAlertConditionWarningArgs'] warning: Identifies the threshold parameters for opening a warning alert incident. See Thresholds below for details.
|
|
54
|
-
:param pulumi.Input[str] where: If applicable, this identifies any Infrastructure host filters used; for example: `hostname LIKE '%cassandra%'`.
|
|
59
|
+
:param pulumi.Input[_builtins.str] where: If applicable, this identifies any Infrastructure host filters used; for example: `hostname LIKE '%cassandra%'`.
|
|
55
60
|
"""
|
|
56
61
|
pulumi.set(__self__, "policy_id", policy_id)
|
|
57
62
|
pulumi.set(__self__, "type", type)
|
|
@@ -82,43 +87,43 @@ class InfraAlertConditionArgs:
|
|
|
82
87
|
if where is not None:
|
|
83
88
|
pulumi.set(__self__, "where", where)
|
|
84
89
|
|
|
85
|
-
@property
|
|
90
|
+
@_builtins.property
|
|
86
91
|
@pulumi.getter(name="policyId")
|
|
87
|
-
def policy_id(self) -> pulumi.Input[
|
|
92
|
+
def policy_id(self) -> pulumi.Input[_builtins.str]:
|
|
88
93
|
"""
|
|
89
94
|
The ID of the alert policy where this condition should be used.
|
|
90
95
|
"""
|
|
91
96
|
return pulumi.get(self, "policy_id")
|
|
92
97
|
|
|
93
98
|
@policy_id.setter
|
|
94
|
-
def policy_id(self, value: pulumi.Input[
|
|
99
|
+
def policy_id(self, value: pulumi.Input[_builtins.str]):
|
|
95
100
|
pulumi.set(self, "policy_id", value)
|
|
96
101
|
|
|
97
|
-
@property
|
|
102
|
+
@_builtins.property
|
|
98
103
|
@pulumi.getter
|
|
99
|
-
def type(self) -> pulumi.Input[str]:
|
|
104
|
+
def type(self) -> pulumi.Input[_builtins.str]:
|
|
100
105
|
"""
|
|
101
106
|
The type of Infrastructure alert condition. Valid values are `infra_process_running`, `infra_metric`, and `infra_host_not_reporting`.
|
|
102
107
|
"""
|
|
103
108
|
return pulumi.get(self, "type")
|
|
104
109
|
|
|
105
110
|
@type.setter
|
|
106
|
-
def type(self, value: pulumi.Input[str]):
|
|
111
|
+
def type(self, value: pulumi.Input[_builtins.str]):
|
|
107
112
|
pulumi.set(self, "type", value)
|
|
108
113
|
|
|
109
|
-
@property
|
|
114
|
+
@_builtins.property
|
|
110
115
|
@pulumi.getter
|
|
111
|
-
def comparison(self) -> Optional[pulumi.Input[str]]:
|
|
116
|
+
def comparison(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
112
117
|
"""
|
|
113
118
|
The operator used to evaluate the threshold value. Valid values are `above`, `below`, and `equal`. Supported by the `infra_metric` and `infra_process_running` condition types.
|
|
114
119
|
"""
|
|
115
120
|
return pulumi.get(self, "comparison")
|
|
116
121
|
|
|
117
122
|
@comparison.setter
|
|
118
|
-
def comparison(self, value: Optional[pulumi.Input[str]]):
|
|
123
|
+
def comparison(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
119
124
|
pulumi.set(self, "comparison", value)
|
|
120
125
|
|
|
121
|
-
@property
|
|
126
|
+
@_builtins.property
|
|
122
127
|
@pulumi.getter
|
|
123
128
|
def critical(self) -> Optional[pulumi.Input['InfraAlertConditionCriticalArgs']]:
|
|
124
129
|
"""
|
|
@@ -130,119 +135,119 @@ class InfraAlertConditionArgs:
|
|
|
130
135
|
def critical(self, value: Optional[pulumi.Input['InfraAlertConditionCriticalArgs']]):
|
|
131
136
|
pulumi.set(self, "critical", value)
|
|
132
137
|
|
|
133
|
-
@property
|
|
138
|
+
@_builtins.property
|
|
134
139
|
@pulumi.getter
|
|
135
|
-
def description(self) -> Optional[pulumi.Input[str]]:
|
|
140
|
+
def description(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
136
141
|
"""
|
|
137
142
|
The description of the Infrastructure alert condition.
|
|
138
143
|
"""
|
|
139
144
|
return pulumi.get(self, "description")
|
|
140
145
|
|
|
141
146
|
@description.setter
|
|
142
|
-
def description(self, value: Optional[pulumi.Input[str]]):
|
|
147
|
+
def description(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
143
148
|
pulumi.set(self, "description", value)
|
|
144
149
|
|
|
145
|
-
@property
|
|
150
|
+
@_builtins.property
|
|
146
151
|
@pulumi.getter
|
|
147
|
-
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
152
|
+
def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
148
153
|
"""
|
|
149
154
|
Whether the condition is turned on or off. Valid values are `true` and `false`. Defaults to `true`.
|
|
150
155
|
"""
|
|
151
156
|
return pulumi.get(self, "enabled")
|
|
152
157
|
|
|
153
158
|
@enabled.setter
|
|
154
|
-
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
159
|
+
def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
155
160
|
pulumi.set(self, "enabled", value)
|
|
156
161
|
|
|
157
|
-
@property
|
|
162
|
+
@_builtins.property
|
|
158
163
|
@pulumi.getter
|
|
159
|
-
def event(self) -> Optional[pulumi.Input[str]]:
|
|
164
|
+
def event(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
160
165
|
"""
|
|
161
166
|
The metric event; for example, `SystemSample` or `StorageSample`. Supported by the `infra_metric` condition type.
|
|
162
167
|
"""
|
|
163
168
|
return pulumi.get(self, "event")
|
|
164
169
|
|
|
165
170
|
@event.setter
|
|
166
|
-
def event(self, value: Optional[pulumi.Input[str]]):
|
|
171
|
+
def event(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
167
172
|
pulumi.set(self, "event", value)
|
|
168
173
|
|
|
169
|
-
@property
|
|
174
|
+
@_builtins.property
|
|
170
175
|
@pulumi.getter(name="integrationProvider")
|
|
171
|
-
def integration_provider(self) -> Optional[pulumi.Input[str]]:
|
|
176
|
+
def integration_provider(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
172
177
|
"""
|
|
173
178
|
For alerts on integrations, use this instead of `event`. Supported by the `infra_metric` condition type.
|
|
174
179
|
"""
|
|
175
180
|
return pulumi.get(self, "integration_provider")
|
|
176
181
|
|
|
177
182
|
@integration_provider.setter
|
|
178
|
-
def integration_provider(self, value: Optional[pulumi.Input[str]]):
|
|
183
|
+
def integration_provider(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
179
184
|
pulumi.set(self, "integration_provider", value)
|
|
180
185
|
|
|
181
|
-
@property
|
|
186
|
+
@_builtins.property
|
|
182
187
|
@pulumi.getter
|
|
183
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
188
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
184
189
|
"""
|
|
185
190
|
The Infrastructure alert condition's name.
|
|
186
191
|
"""
|
|
187
192
|
return pulumi.get(self, "name")
|
|
188
193
|
|
|
189
194
|
@name.setter
|
|
190
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
195
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
191
196
|
pulumi.set(self, "name", value)
|
|
192
197
|
|
|
193
|
-
@property
|
|
198
|
+
@_builtins.property
|
|
194
199
|
@pulumi.getter(name="processWhere")
|
|
195
|
-
def process_where(self) -> Optional[pulumi.Input[str]]:
|
|
200
|
+
def process_where(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
196
201
|
"""
|
|
197
202
|
Any filters applied to processes; for example: `commandName = 'java'`. Required by the `infra_process_running` condition type.
|
|
198
203
|
"""
|
|
199
204
|
return pulumi.get(self, "process_where")
|
|
200
205
|
|
|
201
206
|
@process_where.setter
|
|
202
|
-
def process_where(self, value: Optional[pulumi.Input[str]]):
|
|
207
|
+
def process_where(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
203
208
|
pulumi.set(self, "process_where", value)
|
|
204
209
|
|
|
205
|
-
@property
|
|
210
|
+
@_builtins.property
|
|
206
211
|
@pulumi.getter(name="runbookUrl")
|
|
207
|
-
def runbook_url(self) -> Optional[pulumi.Input[str]]:
|
|
212
|
+
def runbook_url(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
208
213
|
"""
|
|
209
214
|
Runbook URL to display in notifications.
|
|
210
215
|
"""
|
|
211
216
|
return pulumi.get(self, "runbook_url")
|
|
212
217
|
|
|
213
218
|
@runbook_url.setter
|
|
214
|
-
def runbook_url(self, value: Optional[pulumi.Input[str]]):
|
|
219
|
+
def runbook_url(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
215
220
|
pulumi.set(self, "runbook_url", value)
|
|
216
221
|
|
|
217
|
-
@property
|
|
222
|
+
@_builtins.property
|
|
218
223
|
@pulumi.getter
|
|
219
|
-
def select(self) -> Optional[pulumi.Input[str]]:
|
|
224
|
+
def select(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
220
225
|
"""
|
|
221
226
|
The attribute name to identify the metric being targeted; for example, `cpuPercent`, `diskFreePercent`, or `memoryResidentSizeBytes`. The underlying API will automatically populate this value for Infrastructure integrations (for example `diskFreePercent`), so make sure to explicitly include this value to avoid diff issues. Supported by the `infra_metric` condition type.
|
|
222
227
|
"""
|
|
223
228
|
return pulumi.get(self, "select")
|
|
224
229
|
|
|
225
230
|
@select.setter
|
|
226
|
-
def select(self, value: Optional[pulumi.Input[str]]):
|
|
231
|
+
def select(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
227
232
|
pulumi.set(self, "select", value)
|
|
228
233
|
|
|
229
|
-
@property
|
|
234
|
+
@_builtins.property
|
|
230
235
|
@pulumi.getter(name="violationCloseTimer")
|
|
231
|
-
def violation_close_timer(self) -> Optional[pulumi.Input[int]]:
|
|
236
|
+
def violation_close_timer(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
232
237
|
"""
|
|
233
238
|
Determines how much time will pass (in hours) before an incident is automatically closed. Valid values are `1 2 4 8 12 24 48 72`. Defaults to 24. If `0` is provided, default of `24` is used and will have configuration drift during the apply phase until a valid value is provided.
|
|
234
239
|
|
|
235
|
-
```
|
|
236
|
-
|
|
240
|
+
```
|
|
241
|
+
Warning: This resource will use the account ID linked to your API key. At the moment it is not possible to dynamically set the account ID.
|
|
237
242
|
```
|
|
238
243
|
"""
|
|
239
244
|
return pulumi.get(self, "violation_close_timer")
|
|
240
245
|
|
|
241
246
|
@violation_close_timer.setter
|
|
242
|
-
def violation_close_timer(self, value: Optional[pulumi.Input[int]]):
|
|
247
|
+
def violation_close_timer(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
243
248
|
pulumi.set(self, "violation_close_timer", value)
|
|
244
249
|
|
|
245
|
-
@property
|
|
250
|
+
@_builtins.property
|
|
246
251
|
@pulumi.getter
|
|
247
252
|
def warning(self) -> Optional[pulumi.Input['InfraAlertConditionWarningArgs']]:
|
|
248
253
|
"""
|
|
@@ -254,64 +259,64 @@ class InfraAlertConditionArgs:
|
|
|
254
259
|
def warning(self, value: Optional[pulumi.Input['InfraAlertConditionWarningArgs']]):
|
|
255
260
|
pulumi.set(self, "warning", value)
|
|
256
261
|
|
|
257
|
-
@property
|
|
262
|
+
@_builtins.property
|
|
258
263
|
@pulumi.getter
|
|
259
|
-
def where(self) -> Optional[pulumi.Input[str]]:
|
|
264
|
+
def where(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
260
265
|
"""
|
|
261
266
|
If applicable, this identifies any Infrastructure host filters used; for example: `hostname LIKE '%cassandra%'`.
|
|
262
267
|
"""
|
|
263
268
|
return pulumi.get(self, "where")
|
|
264
269
|
|
|
265
270
|
@where.setter
|
|
266
|
-
def where(self, value: Optional[pulumi.Input[str]]):
|
|
271
|
+
def where(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
267
272
|
pulumi.set(self, "where", value)
|
|
268
273
|
|
|
269
274
|
|
|
270
275
|
@pulumi.input_type
|
|
271
276
|
class _InfraAlertConditionState:
|
|
272
277
|
def __init__(__self__, *,
|
|
273
|
-
comparison: Optional[pulumi.Input[str]] = None,
|
|
274
|
-
created_at: Optional[pulumi.Input[int]] = None,
|
|
278
|
+
comparison: Optional[pulumi.Input[_builtins.str]] = None,
|
|
279
|
+
created_at: Optional[pulumi.Input[_builtins.int]] = None,
|
|
275
280
|
critical: Optional[pulumi.Input['InfraAlertConditionCriticalArgs']] = None,
|
|
276
|
-
description: Optional[pulumi.Input[str]] = None,
|
|
277
|
-
enabled: Optional[pulumi.Input[bool]] = None,
|
|
278
|
-
entity_guid: Optional[pulumi.Input[str]] = None,
|
|
279
|
-
event: Optional[pulumi.Input[str]] = None,
|
|
280
|
-
integration_provider: Optional[pulumi.Input[str]] = None,
|
|
281
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
282
|
-
policy_id: Optional[pulumi.Input[
|
|
283
|
-
process_where: Optional[pulumi.Input[str]] = None,
|
|
284
|
-
runbook_url: Optional[pulumi.Input[str]] = None,
|
|
285
|
-
select: Optional[pulumi.Input[str]] = None,
|
|
286
|
-
type: Optional[pulumi.Input[str]] = None,
|
|
287
|
-
updated_at: Optional[pulumi.Input[int]] = None,
|
|
288
|
-
violation_close_timer: Optional[pulumi.Input[int]] = None,
|
|
281
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
282
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
283
|
+
entity_guid: Optional[pulumi.Input[_builtins.str]] = None,
|
|
284
|
+
event: Optional[pulumi.Input[_builtins.str]] = None,
|
|
285
|
+
integration_provider: Optional[pulumi.Input[_builtins.str]] = None,
|
|
286
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
287
|
+
policy_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
288
|
+
process_where: Optional[pulumi.Input[_builtins.str]] = None,
|
|
289
|
+
runbook_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
290
|
+
select: Optional[pulumi.Input[_builtins.str]] = None,
|
|
291
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
292
|
+
updated_at: Optional[pulumi.Input[_builtins.int]] = None,
|
|
293
|
+
violation_close_timer: Optional[pulumi.Input[_builtins.int]] = None,
|
|
289
294
|
warning: Optional[pulumi.Input['InfraAlertConditionWarningArgs']] = None,
|
|
290
|
-
where: Optional[pulumi.Input[str]] = None):
|
|
295
|
+
where: Optional[pulumi.Input[_builtins.str]] = None):
|
|
291
296
|
"""
|
|
292
297
|
Input properties used for looking up and filtering InfraAlertCondition resources.
|
|
293
|
-
:param pulumi.Input[str] comparison: The operator used to evaluate the threshold value. Valid values are `above`, `below`, and `equal`. Supported by the `infra_metric` and `infra_process_running` condition types.
|
|
294
|
-
:param pulumi.Input[int] created_at: The timestamp the alert condition was created.
|
|
298
|
+
:param pulumi.Input[_builtins.str] comparison: The operator used to evaluate the threshold value. Valid values are `above`, `below`, and `equal`. Supported by the `infra_metric` and `infra_process_running` condition types.
|
|
299
|
+
:param pulumi.Input[_builtins.int] created_at: The timestamp the alert condition was created.
|
|
295
300
|
:param pulumi.Input['InfraAlertConditionCriticalArgs'] critical: Identifies the threshold parameters for opening a critical alert incident. See Thresholds below for details.
|
|
296
|
-
:param pulumi.Input[str] description: The description of the Infrastructure alert condition.
|
|
297
|
-
:param pulumi.Input[bool] enabled: Whether the condition is turned on or off. Valid values are `true` and `false`. Defaults to `true`.
|
|
298
|
-
:param pulumi.Input[str] entity_guid: The unique entity identifier of the condition in New Relic.
|
|
299
|
-
:param pulumi.Input[str] event: The metric event; for example, `SystemSample` or `StorageSample`. Supported by the `infra_metric` condition type.
|
|
300
|
-
:param pulumi.Input[str] integration_provider: For alerts on integrations, use this instead of `event`. Supported by the `infra_metric` condition type.
|
|
301
|
-
:param pulumi.Input[str] name: The Infrastructure alert condition's name.
|
|
302
|
-
:param pulumi.Input[
|
|
303
|
-
:param pulumi.Input[str] process_where: Any filters applied to processes; for example: `commandName = 'java'`. Required by the `infra_process_running` condition type.
|
|
304
|
-
:param pulumi.Input[str] runbook_url: Runbook URL to display in notifications.
|
|
305
|
-
:param pulumi.Input[str] select: The attribute name to identify the metric being targeted; for example, `cpuPercent`, `diskFreePercent`, or `memoryResidentSizeBytes`. The underlying API will automatically populate this value for Infrastructure integrations (for example `diskFreePercent`), so make sure to explicitly include this value to avoid diff issues. Supported by the `infra_metric` condition type.
|
|
306
|
-
:param pulumi.Input[str] type: The type of Infrastructure alert condition. Valid values are `infra_process_running`, `infra_metric`, and `infra_host_not_reporting`.
|
|
307
|
-
:param pulumi.Input[int] updated_at: The timestamp the alert condition was last updated.
|
|
308
|
-
:param pulumi.Input[int] violation_close_timer: Determines how much time will pass (in hours) before an incident is automatically closed. Valid values are `1 2 4 8 12 24 48 72`. Defaults to 24. If `0` is provided, default of `24` is used and will have configuration drift during the apply phase until a valid value is provided.
|
|
301
|
+
:param pulumi.Input[_builtins.str] description: The description of the Infrastructure alert condition.
|
|
302
|
+
:param pulumi.Input[_builtins.bool] enabled: Whether the condition is turned on or off. Valid values are `true` and `false`. Defaults to `true`.
|
|
303
|
+
:param pulumi.Input[_builtins.str] entity_guid: The unique entity identifier of the condition in New Relic.
|
|
304
|
+
:param pulumi.Input[_builtins.str] event: The metric event; for example, `SystemSample` or `StorageSample`. Supported by the `infra_metric` condition type.
|
|
305
|
+
:param pulumi.Input[_builtins.str] integration_provider: For alerts on integrations, use this instead of `event`. Supported by the `infra_metric` condition type.
|
|
306
|
+
:param pulumi.Input[_builtins.str] name: The Infrastructure alert condition's name.
|
|
307
|
+
:param pulumi.Input[_builtins.str] policy_id: The ID of the alert policy where this condition should be used.
|
|
308
|
+
:param pulumi.Input[_builtins.str] process_where: Any filters applied to processes; for example: `commandName = 'java'`. Required by the `infra_process_running` condition type.
|
|
309
|
+
:param pulumi.Input[_builtins.str] runbook_url: Runbook URL to display in notifications.
|
|
310
|
+
:param pulumi.Input[_builtins.str] select: The attribute name to identify the metric being targeted; for example, `cpuPercent`, `diskFreePercent`, or `memoryResidentSizeBytes`. The underlying API will automatically populate this value for Infrastructure integrations (for example `diskFreePercent`), so make sure to explicitly include this value to avoid diff issues. Supported by the `infra_metric` condition type.
|
|
311
|
+
:param pulumi.Input[_builtins.str] type: The type of Infrastructure alert condition. Valid values are `infra_process_running`, `infra_metric`, and `infra_host_not_reporting`.
|
|
312
|
+
:param pulumi.Input[_builtins.int] updated_at: The timestamp the alert condition was last updated.
|
|
313
|
+
:param pulumi.Input[_builtins.int] violation_close_timer: Determines how much time will pass (in hours) before an incident is automatically closed. Valid values are `1 2 4 8 12 24 48 72`. Defaults to 24. If `0` is provided, default of `24` is used and will have configuration drift during the apply phase until a valid value is provided.
|
|
309
314
|
|
|
310
|
-
```
|
|
311
|
-
|
|
315
|
+
```
|
|
316
|
+
Warning: This resource will use the account ID linked to your API key. At the moment it is not possible to dynamically set the account ID.
|
|
312
317
|
```
|
|
313
318
|
:param pulumi.Input['InfraAlertConditionWarningArgs'] warning: Identifies the threshold parameters for opening a warning alert incident. See Thresholds below for details.
|
|
314
|
-
:param pulumi.Input[str] where: If applicable, this identifies any Infrastructure host filters used; for example: `hostname LIKE '%cassandra%'`.
|
|
319
|
+
:param pulumi.Input[_builtins.str] where: If applicable, this identifies any Infrastructure host filters used; for example: `hostname LIKE '%cassandra%'`.
|
|
315
320
|
"""
|
|
316
321
|
if comparison is not None:
|
|
317
322
|
pulumi.set(__self__, "comparison", comparison)
|
|
@@ -350,31 +355,31 @@ class _InfraAlertConditionState:
|
|
|
350
355
|
if where is not None:
|
|
351
356
|
pulumi.set(__self__, "where", where)
|
|
352
357
|
|
|
353
|
-
@property
|
|
358
|
+
@_builtins.property
|
|
354
359
|
@pulumi.getter
|
|
355
|
-
def comparison(self) -> Optional[pulumi.Input[str]]:
|
|
360
|
+
def comparison(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
356
361
|
"""
|
|
357
362
|
The operator used to evaluate the threshold value. Valid values are `above`, `below`, and `equal`. Supported by the `infra_metric` and `infra_process_running` condition types.
|
|
358
363
|
"""
|
|
359
364
|
return pulumi.get(self, "comparison")
|
|
360
365
|
|
|
361
366
|
@comparison.setter
|
|
362
|
-
def comparison(self, value: Optional[pulumi.Input[str]]):
|
|
367
|
+
def comparison(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
363
368
|
pulumi.set(self, "comparison", value)
|
|
364
369
|
|
|
365
|
-
@property
|
|
370
|
+
@_builtins.property
|
|
366
371
|
@pulumi.getter(name="createdAt")
|
|
367
|
-
def created_at(self) -> Optional[pulumi.Input[int]]:
|
|
372
|
+
def created_at(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
368
373
|
"""
|
|
369
374
|
The timestamp the alert condition was created.
|
|
370
375
|
"""
|
|
371
376
|
return pulumi.get(self, "created_at")
|
|
372
377
|
|
|
373
378
|
@created_at.setter
|
|
374
|
-
def created_at(self, value: Optional[pulumi.Input[int]]):
|
|
379
|
+
def created_at(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
375
380
|
pulumi.set(self, "created_at", value)
|
|
376
381
|
|
|
377
|
-
@property
|
|
382
|
+
@_builtins.property
|
|
378
383
|
@pulumi.getter
|
|
379
384
|
def critical(self) -> Optional[pulumi.Input['InfraAlertConditionCriticalArgs']]:
|
|
380
385
|
"""
|
|
@@ -386,167 +391,167 @@ class _InfraAlertConditionState:
|
|
|
386
391
|
def critical(self, value: Optional[pulumi.Input['InfraAlertConditionCriticalArgs']]):
|
|
387
392
|
pulumi.set(self, "critical", value)
|
|
388
393
|
|
|
389
|
-
@property
|
|
394
|
+
@_builtins.property
|
|
390
395
|
@pulumi.getter
|
|
391
|
-
def description(self) -> Optional[pulumi.Input[str]]:
|
|
396
|
+
def description(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
392
397
|
"""
|
|
393
398
|
The description of the Infrastructure alert condition.
|
|
394
399
|
"""
|
|
395
400
|
return pulumi.get(self, "description")
|
|
396
401
|
|
|
397
402
|
@description.setter
|
|
398
|
-
def description(self, value: Optional[pulumi.Input[str]]):
|
|
403
|
+
def description(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
399
404
|
pulumi.set(self, "description", value)
|
|
400
405
|
|
|
401
|
-
@property
|
|
406
|
+
@_builtins.property
|
|
402
407
|
@pulumi.getter
|
|
403
|
-
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
408
|
+
def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
404
409
|
"""
|
|
405
410
|
Whether the condition is turned on or off. Valid values are `true` and `false`. Defaults to `true`.
|
|
406
411
|
"""
|
|
407
412
|
return pulumi.get(self, "enabled")
|
|
408
413
|
|
|
409
414
|
@enabled.setter
|
|
410
|
-
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
415
|
+
def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
411
416
|
pulumi.set(self, "enabled", value)
|
|
412
417
|
|
|
413
|
-
@property
|
|
418
|
+
@_builtins.property
|
|
414
419
|
@pulumi.getter(name="entityGuid")
|
|
415
|
-
def entity_guid(self) -> Optional[pulumi.Input[str]]:
|
|
420
|
+
def entity_guid(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
416
421
|
"""
|
|
417
422
|
The unique entity identifier of the condition in New Relic.
|
|
418
423
|
"""
|
|
419
424
|
return pulumi.get(self, "entity_guid")
|
|
420
425
|
|
|
421
426
|
@entity_guid.setter
|
|
422
|
-
def entity_guid(self, value: Optional[pulumi.Input[str]]):
|
|
427
|
+
def entity_guid(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
423
428
|
pulumi.set(self, "entity_guid", value)
|
|
424
429
|
|
|
425
|
-
@property
|
|
430
|
+
@_builtins.property
|
|
426
431
|
@pulumi.getter
|
|
427
|
-
def event(self) -> Optional[pulumi.Input[str]]:
|
|
432
|
+
def event(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
428
433
|
"""
|
|
429
434
|
The metric event; for example, `SystemSample` or `StorageSample`. Supported by the `infra_metric` condition type.
|
|
430
435
|
"""
|
|
431
436
|
return pulumi.get(self, "event")
|
|
432
437
|
|
|
433
438
|
@event.setter
|
|
434
|
-
def event(self, value: Optional[pulumi.Input[str]]):
|
|
439
|
+
def event(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
435
440
|
pulumi.set(self, "event", value)
|
|
436
441
|
|
|
437
|
-
@property
|
|
442
|
+
@_builtins.property
|
|
438
443
|
@pulumi.getter(name="integrationProvider")
|
|
439
|
-
def integration_provider(self) -> Optional[pulumi.Input[str]]:
|
|
444
|
+
def integration_provider(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
440
445
|
"""
|
|
441
446
|
For alerts on integrations, use this instead of `event`. Supported by the `infra_metric` condition type.
|
|
442
447
|
"""
|
|
443
448
|
return pulumi.get(self, "integration_provider")
|
|
444
449
|
|
|
445
450
|
@integration_provider.setter
|
|
446
|
-
def integration_provider(self, value: Optional[pulumi.Input[str]]):
|
|
451
|
+
def integration_provider(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
447
452
|
pulumi.set(self, "integration_provider", value)
|
|
448
453
|
|
|
449
|
-
@property
|
|
454
|
+
@_builtins.property
|
|
450
455
|
@pulumi.getter
|
|
451
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
456
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
452
457
|
"""
|
|
453
458
|
The Infrastructure alert condition's name.
|
|
454
459
|
"""
|
|
455
460
|
return pulumi.get(self, "name")
|
|
456
461
|
|
|
457
462
|
@name.setter
|
|
458
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
463
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
459
464
|
pulumi.set(self, "name", value)
|
|
460
465
|
|
|
461
|
-
@property
|
|
466
|
+
@_builtins.property
|
|
462
467
|
@pulumi.getter(name="policyId")
|
|
463
|
-
def policy_id(self) -> Optional[pulumi.Input[
|
|
468
|
+
def policy_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
464
469
|
"""
|
|
465
470
|
The ID of the alert policy where this condition should be used.
|
|
466
471
|
"""
|
|
467
472
|
return pulumi.get(self, "policy_id")
|
|
468
473
|
|
|
469
474
|
@policy_id.setter
|
|
470
|
-
def policy_id(self, value: Optional[pulumi.Input[
|
|
475
|
+
def policy_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
471
476
|
pulumi.set(self, "policy_id", value)
|
|
472
477
|
|
|
473
|
-
@property
|
|
478
|
+
@_builtins.property
|
|
474
479
|
@pulumi.getter(name="processWhere")
|
|
475
|
-
def process_where(self) -> Optional[pulumi.Input[str]]:
|
|
480
|
+
def process_where(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
476
481
|
"""
|
|
477
482
|
Any filters applied to processes; for example: `commandName = 'java'`. Required by the `infra_process_running` condition type.
|
|
478
483
|
"""
|
|
479
484
|
return pulumi.get(self, "process_where")
|
|
480
485
|
|
|
481
486
|
@process_where.setter
|
|
482
|
-
def process_where(self, value: Optional[pulumi.Input[str]]):
|
|
487
|
+
def process_where(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
483
488
|
pulumi.set(self, "process_where", value)
|
|
484
489
|
|
|
485
|
-
@property
|
|
490
|
+
@_builtins.property
|
|
486
491
|
@pulumi.getter(name="runbookUrl")
|
|
487
|
-
def runbook_url(self) -> Optional[pulumi.Input[str]]:
|
|
492
|
+
def runbook_url(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
488
493
|
"""
|
|
489
494
|
Runbook URL to display in notifications.
|
|
490
495
|
"""
|
|
491
496
|
return pulumi.get(self, "runbook_url")
|
|
492
497
|
|
|
493
498
|
@runbook_url.setter
|
|
494
|
-
def runbook_url(self, value: Optional[pulumi.Input[str]]):
|
|
499
|
+
def runbook_url(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
495
500
|
pulumi.set(self, "runbook_url", value)
|
|
496
501
|
|
|
497
|
-
@property
|
|
502
|
+
@_builtins.property
|
|
498
503
|
@pulumi.getter
|
|
499
|
-
def select(self) -> Optional[pulumi.Input[str]]:
|
|
504
|
+
def select(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
500
505
|
"""
|
|
501
506
|
The attribute name to identify the metric being targeted; for example, `cpuPercent`, `diskFreePercent`, or `memoryResidentSizeBytes`. The underlying API will automatically populate this value for Infrastructure integrations (for example `diskFreePercent`), so make sure to explicitly include this value to avoid diff issues. Supported by the `infra_metric` condition type.
|
|
502
507
|
"""
|
|
503
508
|
return pulumi.get(self, "select")
|
|
504
509
|
|
|
505
510
|
@select.setter
|
|
506
|
-
def select(self, value: Optional[pulumi.Input[str]]):
|
|
511
|
+
def select(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
507
512
|
pulumi.set(self, "select", value)
|
|
508
513
|
|
|
509
|
-
@property
|
|
514
|
+
@_builtins.property
|
|
510
515
|
@pulumi.getter
|
|
511
|
-
def type(self) -> Optional[pulumi.Input[str]]:
|
|
516
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
512
517
|
"""
|
|
513
518
|
The type of Infrastructure alert condition. Valid values are `infra_process_running`, `infra_metric`, and `infra_host_not_reporting`.
|
|
514
519
|
"""
|
|
515
520
|
return pulumi.get(self, "type")
|
|
516
521
|
|
|
517
522
|
@type.setter
|
|
518
|
-
def type(self, value: Optional[pulumi.Input[str]]):
|
|
523
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
519
524
|
pulumi.set(self, "type", value)
|
|
520
525
|
|
|
521
|
-
@property
|
|
526
|
+
@_builtins.property
|
|
522
527
|
@pulumi.getter(name="updatedAt")
|
|
523
|
-
def updated_at(self) -> Optional[pulumi.Input[int]]:
|
|
528
|
+
def updated_at(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
524
529
|
"""
|
|
525
530
|
The timestamp the alert condition was last updated.
|
|
526
531
|
"""
|
|
527
532
|
return pulumi.get(self, "updated_at")
|
|
528
533
|
|
|
529
534
|
@updated_at.setter
|
|
530
|
-
def updated_at(self, value: Optional[pulumi.Input[int]]):
|
|
535
|
+
def updated_at(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
531
536
|
pulumi.set(self, "updated_at", value)
|
|
532
537
|
|
|
533
|
-
@property
|
|
538
|
+
@_builtins.property
|
|
534
539
|
@pulumi.getter(name="violationCloseTimer")
|
|
535
|
-
def violation_close_timer(self) -> Optional[pulumi.Input[int]]:
|
|
540
|
+
def violation_close_timer(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
536
541
|
"""
|
|
537
542
|
Determines how much time will pass (in hours) before an incident is automatically closed. Valid values are `1 2 4 8 12 24 48 72`. Defaults to 24. If `0` is provided, default of `24` is used and will have configuration drift during the apply phase until a valid value is provided.
|
|
538
543
|
|
|
539
|
-
```
|
|
540
|
-
|
|
544
|
+
```
|
|
545
|
+
Warning: This resource will use the account ID linked to your API key. At the moment it is not possible to dynamically set the account ID.
|
|
541
546
|
```
|
|
542
547
|
"""
|
|
543
548
|
return pulumi.get(self, "violation_close_timer")
|
|
544
549
|
|
|
545
550
|
@violation_close_timer.setter
|
|
546
|
-
def violation_close_timer(self, value: Optional[pulumi.Input[int]]):
|
|
551
|
+
def violation_close_timer(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
547
552
|
pulumi.set(self, "violation_close_timer", value)
|
|
548
553
|
|
|
549
|
-
@property
|
|
554
|
+
@_builtins.property
|
|
550
555
|
@pulumi.getter
|
|
551
556
|
def warning(self) -> Optional[pulumi.Input['InfraAlertConditionWarningArgs']]:
|
|
552
557
|
"""
|
|
@@ -558,44 +563,45 @@ class _InfraAlertConditionState:
|
|
|
558
563
|
def warning(self, value: Optional[pulumi.Input['InfraAlertConditionWarningArgs']]):
|
|
559
564
|
pulumi.set(self, "warning", value)
|
|
560
565
|
|
|
561
|
-
@property
|
|
566
|
+
@_builtins.property
|
|
562
567
|
@pulumi.getter
|
|
563
|
-
def where(self) -> Optional[pulumi.Input[str]]:
|
|
568
|
+
def where(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
564
569
|
"""
|
|
565
570
|
If applicable, this identifies any Infrastructure host filters used; for example: `hostname LIKE '%cassandra%'`.
|
|
566
571
|
"""
|
|
567
572
|
return pulumi.get(self, "where")
|
|
568
573
|
|
|
569
574
|
@where.setter
|
|
570
|
-
def where(self, value: Optional[pulumi.Input[str]]):
|
|
575
|
+
def where(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
571
576
|
pulumi.set(self, "where", value)
|
|
572
577
|
|
|
573
578
|
|
|
579
|
+
@pulumi.type_token("newrelic:index/infraAlertCondition:InfraAlertCondition")
|
|
574
580
|
class InfraAlertCondition(pulumi.CustomResource):
|
|
575
581
|
@overload
|
|
576
582
|
def __init__(__self__,
|
|
577
583
|
resource_name: str,
|
|
578
584
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
579
|
-
comparison: Optional[pulumi.Input[str]] = None,
|
|
580
|
-
critical: Optional[pulumi.Input[
|
|
581
|
-
description: Optional[pulumi.Input[str]] = None,
|
|
582
|
-
enabled: Optional[pulumi.Input[bool]] = None,
|
|
583
|
-
event: Optional[pulumi.Input[str]] = None,
|
|
584
|
-
integration_provider: Optional[pulumi.Input[str]] = None,
|
|
585
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
586
|
-
policy_id: Optional[pulumi.Input[
|
|
587
|
-
process_where: Optional[pulumi.Input[str]] = None,
|
|
588
|
-
runbook_url: Optional[pulumi.Input[str]] = None,
|
|
589
|
-
select: Optional[pulumi.Input[str]] = None,
|
|
590
|
-
type: Optional[pulumi.Input[str]] = None,
|
|
591
|
-
violation_close_timer: Optional[pulumi.Input[int]] = None,
|
|
592
|
-
warning: Optional[pulumi.Input[
|
|
593
|
-
where: Optional[pulumi.Input[str]] = None,
|
|
585
|
+
comparison: Optional[pulumi.Input[_builtins.str]] = None,
|
|
586
|
+
critical: Optional[pulumi.Input[Union['InfraAlertConditionCriticalArgs', 'InfraAlertConditionCriticalArgsDict']]] = None,
|
|
587
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
588
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
589
|
+
event: Optional[pulumi.Input[_builtins.str]] = None,
|
|
590
|
+
integration_provider: Optional[pulumi.Input[_builtins.str]] = None,
|
|
591
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
592
|
+
policy_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
593
|
+
process_where: Optional[pulumi.Input[_builtins.str]] = None,
|
|
594
|
+
runbook_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
595
|
+
select: Optional[pulumi.Input[_builtins.str]] = None,
|
|
596
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
597
|
+
violation_close_timer: Optional[pulumi.Input[_builtins.int]] = None,
|
|
598
|
+
warning: Optional[pulumi.Input[Union['InfraAlertConditionWarningArgs', 'InfraAlertConditionWarningArgsDict']]] = None,
|
|
599
|
+
where: Optional[pulumi.Input[_builtins.str]] = None,
|
|
594
600
|
__props__=None):
|
|
595
601
|
"""
|
|
596
602
|
Use this resource to create and manage Infrastructure alert conditions in New Relic.
|
|
597
603
|
|
|
598
|
-
> **
|
|
604
|
+
> **WARNING:** The `InfraAlertCondition` resource is deprecated and will be removed in the next major release. The resource NrqlAlertCondition would be a preferred alternative to configure alert conditions - in most cases, feature parity can be achieved with a NRQL query. For more details and examples on moving away from infra alert conditions to the NRQL based alternative, please check out these examples.
|
|
599
605
|
|
|
600
606
|
## Example Usage
|
|
601
607
|
|
|
@@ -603,27 +609,29 @@ class InfraAlertCondition(pulumi.CustomResource):
|
|
|
603
609
|
import pulumi
|
|
604
610
|
import pulumi_newrelic as newrelic
|
|
605
611
|
|
|
606
|
-
foo = newrelic.AlertPolicy("foo")
|
|
607
|
-
high_disk_usage = newrelic.InfraAlertCondition("
|
|
612
|
+
foo = newrelic.AlertPolicy("foo", name="foo")
|
|
613
|
+
high_disk_usage = newrelic.InfraAlertCondition("high_disk_usage",
|
|
608
614
|
policy_id=foo.id,
|
|
615
|
+
name="High disk usage",
|
|
609
616
|
description="Warning if disk usage goes above 80% and critical alert if goes above 90%",
|
|
610
617
|
type="infra_metric",
|
|
611
618
|
event="StorageSample",
|
|
612
619
|
select="diskUsedPercent",
|
|
613
620
|
comparison="above",
|
|
614
621
|
where="(hostname LIKE '%frontend%')",
|
|
615
|
-
critical=
|
|
616
|
-
duration
|
|
617
|
-
value
|
|
618
|
-
time_function
|
|
619
|
-
|
|
620
|
-
warning=
|
|
621
|
-
duration
|
|
622
|
-
value
|
|
623
|
-
time_function
|
|
624
|
-
)
|
|
625
|
-
high_db_conn_count = newrelic.InfraAlertCondition("
|
|
622
|
+
critical={
|
|
623
|
+
"duration": 25,
|
|
624
|
+
"value": 90,
|
|
625
|
+
"time_function": "all",
|
|
626
|
+
},
|
|
627
|
+
warning={
|
|
628
|
+
"duration": 10,
|
|
629
|
+
"value": 80,
|
|
630
|
+
"time_function": "all",
|
|
631
|
+
})
|
|
632
|
+
high_db_conn_count = newrelic.InfraAlertCondition("high_db_conn_count",
|
|
626
633
|
policy_id=foo.id,
|
|
634
|
+
name="High database connection count",
|
|
627
635
|
description="Critical alert when the number of database connections goes above 90",
|
|
628
636
|
type="infra_metric",
|
|
629
637
|
event="DatastoreSample",
|
|
@@ -631,31 +639,34 @@ class InfraAlertCondition(pulumi.CustomResource):
|
|
|
631
639
|
comparison="above",
|
|
632
640
|
where="(hostname LIKE '%db%')",
|
|
633
641
|
integration_provider="RdsDbInstance",
|
|
634
|
-
critical=
|
|
635
|
-
duration
|
|
636
|
-
value
|
|
637
|
-
time_function
|
|
638
|
-
)
|
|
639
|
-
process_not_running = newrelic.InfraAlertCondition("
|
|
642
|
+
critical={
|
|
643
|
+
"duration": 25,
|
|
644
|
+
"value": 90,
|
|
645
|
+
"time_function": "all",
|
|
646
|
+
})
|
|
647
|
+
process_not_running = newrelic.InfraAlertCondition("process_not_running",
|
|
640
648
|
policy_id=foo.id,
|
|
649
|
+
name="Process not running (/usr/bin/ruby)",
|
|
641
650
|
description="Critical alert when ruby isn't running",
|
|
642
651
|
type="infra_process_running",
|
|
643
652
|
comparison="equal",
|
|
644
653
|
where="hostname = 'web01'",
|
|
645
654
|
process_where="commandName = '/usr/bin/ruby'",
|
|
646
|
-
critical=
|
|
647
|
-
duration
|
|
648
|
-
value
|
|
649
|
-
)
|
|
650
|
-
host_not_reporting = newrelic.InfraAlertCondition("
|
|
655
|
+
critical={
|
|
656
|
+
"duration": 5,
|
|
657
|
+
"value": 0,
|
|
658
|
+
})
|
|
659
|
+
host_not_reporting = newrelic.InfraAlertCondition("host_not_reporting",
|
|
651
660
|
policy_id=foo.id,
|
|
661
|
+
name="Host not reporting",
|
|
652
662
|
description="Critical alert when the host is not reporting",
|
|
653
663
|
type="infra_host_not_reporting",
|
|
654
664
|
where="(hostname LIKE '%frontend%')",
|
|
655
|
-
critical=
|
|
656
|
-
duration
|
|
657
|
-
)
|
|
665
|
+
critical={
|
|
666
|
+
"duration": 5,
|
|
667
|
+
})
|
|
658
668
|
```
|
|
669
|
+
|
|
659
670
|
## Thresholds
|
|
660
671
|
|
|
661
672
|
The `critical` and `warning` threshold mapping supports the following arguments:
|
|
@@ -672,39 +683,40 @@ class InfraAlertCondition(pulumi.CustomResource):
|
|
|
672
683
|
import pulumi
|
|
673
684
|
import pulumi_newrelic as newrelic
|
|
674
685
|
|
|
675
|
-
|
|
676
|
-
foo_infra_alert_condition = newrelic.InfraAlertCondition("
|
|
677
|
-
policy_id=
|
|
686
|
+
foo = newrelic.AlertPolicy("foo", name="foo policy")
|
|
687
|
+
foo_infra_alert_condition = newrelic.InfraAlertCondition("foo",
|
|
688
|
+
policy_id=foo.id,
|
|
689
|
+
name="foo infra condition",
|
|
678
690
|
description="Warning if disk usage goes above 80% and critical alert if goes above 90%",
|
|
679
691
|
type="infra_metric",
|
|
680
692
|
event="StorageSample",
|
|
681
693
|
select="diskUsedPercent",
|
|
682
694
|
comparison="above",
|
|
683
695
|
where="(hostname LIKE '%frontend%')",
|
|
684
|
-
critical=
|
|
685
|
-
duration
|
|
686
|
-
value
|
|
687
|
-
time_function
|
|
688
|
-
|
|
689
|
-
warning=
|
|
690
|
-
duration
|
|
691
|
-
value
|
|
692
|
-
time_function
|
|
693
|
-
)
|
|
694
|
-
my_condition_entity_tags = newrelic.EntityTags("
|
|
696
|
+
critical={
|
|
697
|
+
"duration": 25,
|
|
698
|
+
"value": 90,
|
|
699
|
+
"time_function": "all",
|
|
700
|
+
},
|
|
701
|
+
warning={
|
|
702
|
+
"duration": 10,
|
|
703
|
+
"value": 80,
|
|
704
|
+
"time_function": "all",
|
|
705
|
+
})
|
|
706
|
+
my_condition_entity_tags = newrelic.EntityTags("my_condition_entity_tags",
|
|
695
707
|
guid=foo_infra_alert_condition.entity_guid,
|
|
696
708
|
tags=[
|
|
697
|
-
|
|
698
|
-
key
|
|
699
|
-
values
|
|
709
|
+
{
|
|
710
|
+
"key": "my-key",
|
|
711
|
+
"values": [
|
|
700
712
|
"my-value",
|
|
701
713
|
"my-other-value",
|
|
702
714
|
],
|
|
703
|
-
|
|
704
|
-
|
|
705
|
-
key
|
|
706
|
-
values
|
|
707
|
-
|
|
715
|
+
},
|
|
716
|
+
{
|
|
717
|
+
"key": "my-key-2",
|
|
718
|
+
"values": ["my-value-2"],
|
|
719
|
+
},
|
|
708
720
|
])
|
|
709
721
|
```
|
|
710
722
|
|
|
@@ -713,30 +725,30 @@ class InfraAlertCondition(pulumi.CustomResource):
|
|
|
713
725
|
Infrastructure alert conditions can be imported using a composite ID of `<policy_id>:<condition_id>`, e.g.
|
|
714
726
|
|
|
715
727
|
```sh
|
|
716
|
-
|
|
728
|
+
$ pulumi import newrelic:index/infraAlertCondition:InfraAlertCondition main 12345:67890
|
|
717
729
|
```
|
|
718
730
|
|
|
719
731
|
:param str resource_name: The name of the resource.
|
|
720
732
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
721
|
-
:param pulumi.Input[str] comparison: The operator used to evaluate the threshold value. Valid values are `above`, `below`, and `equal`. Supported by the `infra_metric` and `infra_process_running` condition types.
|
|
722
|
-
:param pulumi.Input[
|
|
723
|
-
:param pulumi.Input[str] description: The description of the Infrastructure alert condition.
|
|
724
|
-
:param pulumi.Input[bool] enabled: Whether the condition is turned on or off. Valid values are `true` and `false`. Defaults to `true`.
|
|
725
|
-
:param pulumi.Input[str] event: The metric event; for example, `SystemSample` or `StorageSample`. Supported by the `infra_metric` condition type.
|
|
726
|
-
:param pulumi.Input[str] integration_provider: For alerts on integrations, use this instead of `event`. Supported by the `infra_metric` condition type.
|
|
727
|
-
:param pulumi.Input[str] name: The Infrastructure alert condition's name.
|
|
728
|
-
:param pulumi.Input[
|
|
729
|
-
:param pulumi.Input[str] process_where: Any filters applied to processes; for example: `commandName = 'java'`. Required by the `infra_process_running` condition type.
|
|
730
|
-
:param pulumi.Input[str] runbook_url: Runbook URL to display in notifications.
|
|
731
|
-
:param pulumi.Input[str] select: The attribute name to identify the metric being targeted; for example, `cpuPercent`, `diskFreePercent`, or `memoryResidentSizeBytes`. The underlying API will automatically populate this value for Infrastructure integrations (for example `diskFreePercent`), so make sure to explicitly include this value to avoid diff issues. Supported by the `infra_metric` condition type.
|
|
732
|
-
:param pulumi.Input[str] type: The type of Infrastructure alert condition. Valid values are `infra_process_running`, `infra_metric`, and `infra_host_not_reporting`.
|
|
733
|
-
:param pulumi.Input[int] violation_close_timer: Determines how much time will pass (in hours) before an incident is automatically closed. Valid values are `1 2 4 8 12 24 48 72`. Defaults to 24. If `0` is provided, default of `24` is used and will have configuration drift during the apply phase until a valid value is provided.
|
|
733
|
+
:param pulumi.Input[_builtins.str] comparison: The operator used to evaluate the threshold value. Valid values are `above`, `below`, and `equal`. Supported by the `infra_metric` and `infra_process_running` condition types.
|
|
734
|
+
:param pulumi.Input[Union['InfraAlertConditionCriticalArgs', 'InfraAlertConditionCriticalArgsDict']] critical: Identifies the threshold parameters for opening a critical alert incident. See Thresholds below for details.
|
|
735
|
+
:param pulumi.Input[_builtins.str] description: The description of the Infrastructure alert condition.
|
|
736
|
+
:param pulumi.Input[_builtins.bool] enabled: Whether the condition is turned on or off. Valid values are `true` and `false`. Defaults to `true`.
|
|
737
|
+
:param pulumi.Input[_builtins.str] event: The metric event; for example, `SystemSample` or `StorageSample`. Supported by the `infra_metric` condition type.
|
|
738
|
+
:param pulumi.Input[_builtins.str] integration_provider: For alerts on integrations, use this instead of `event`. Supported by the `infra_metric` condition type.
|
|
739
|
+
:param pulumi.Input[_builtins.str] name: The Infrastructure alert condition's name.
|
|
740
|
+
:param pulumi.Input[_builtins.str] policy_id: The ID of the alert policy where this condition should be used.
|
|
741
|
+
:param pulumi.Input[_builtins.str] process_where: Any filters applied to processes; for example: `commandName = 'java'`. Required by the `infra_process_running` condition type.
|
|
742
|
+
:param pulumi.Input[_builtins.str] runbook_url: Runbook URL to display in notifications.
|
|
743
|
+
:param pulumi.Input[_builtins.str] select: The attribute name to identify the metric being targeted; for example, `cpuPercent`, `diskFreePercent`, or `memoryResidentSizeBytes`. The underlying API will automatically populate this value for Infrastructure integrations (for example `diskFreePercent`), so make sure to explicitly include this value to avoid diff issues. Supported by the `infra_metric` condition type.
|
|
744
|
+
:param pulumi.Input[_builtins.str] type: The type of Infrastructure alert condition. Valid values are `infra_process_running`, `infra_metric`, and `infra_host_not_reporting`.
|
|
745
|
+
:param pulumi.Input[_builtins.int] violation_close_timer: Determines how much time will pass (in hours) before an incident is automatically closed. Valid values are `1 2 4 8 12 24 48 72`. Defaults to 24. If `0` is provided, default of `24` is used and will have configuration drift during the apply phase until a valid value is provided.
|
|
734
746
|
|
|
735
|
-
```python
|
|
736
|
-
import pulumi
|
|
737
747
|
```
|
|
738
|
-
|
|
739
|
-
|
|
748
|
+
Warning: This resource will use the account ID linked to your API key. At the moment it is not possible to dynamically set the account ID.
|
|
749
|
+
```
|
|
750
|
+
:param pulumi.Input[Union['InfraAlertConditionWarningArgs', 'InfraAlertConditionWarningArgsDict']] warning: Identifies the threshold parameters for opening a warning alert incident. See Thresholds below for details.
|
|
751
|
+
:param pulumi.Input[_builtins.str] where: If applicable, this identifies any Infrastructure host filters used; for example: `hostname LIKE '%cassandra%'`.
|
|
740
752
|
"""
|
|
741
753
|
...
|
|
742
754
|
@overload
|
|
@@ -747,7 +759,7 @@ class InfraAlertCondition(pulumi.CustomResource):
|
|
|
747
759
|
"""
|
|
748
760
|
Use this resource to create and manage Infrastructure alert conditions in New Relic.
|
|
749
761
|
|
|
750
|
-
> **
|
|
762
|
+
> **WARNING:** The `InfraAlertCondition` resource is deprecated and will be removed in the next major release. The resource NrqlAlertCondition would be a preferred alternative to configure alert conditions - in most cases, feature parity can be achieved with a NRQL query. For more details and examples on moving away from infra alert conditions to the NRQL based alternative, please check out these examples.
|
|
751
763
|
|
|
752
764
|
## Example Usage
|
|
753
765
|
|
|
@@ -755,27 +767,29 @@ class InfraAlertCondition(pulumi.CustomResource):
|
|
|
755
767
|
import pulumi
|
|
756
768
|
import pulumi_newrelic as newrelic
|
|
757
769
|
|
|
758
|
-
foo = newrelic.AlertPolicy("foo")
|
|
759
|
-
high_disk_usage = newrelic.InfraAlertCondition("
|
|
770
|
+
foo = newrelic.AlertPolicy("foo", name="foo")
|
|
771
|
+
high_disk_usage = newrelic.InfraAlertCondition("high_disk_usage",
|
|
760
772
|
policy_id=foo.id,
|
|
773
|
+
name="High disk usage",
|
|
761
774
|
description="Warning if disk usage goes above 80% and critical alert if goes above 90%",
|
|
762
775
|
type="infra_metric",
|
|
763
776
|
event="StorageSample",
|
|
764
777
|
select="diskUsedPercent",
|
|
765
778
|
comparison="above",
|
|
766
779
|
where="(hostname LIKE '%frontend%')",
|
|
767
|
-
critical=
|
|
768
|
-
duration
|
|
769
|
-
value
|
|
770
|
-
time_function
|
|
771
|
-
|
|
772
|
-
warning=
|
|
773
|
-
duration
|
|
774
|
-
value
|
|
775
|
-
time_function
|
|
776
|
-
)
|
|
777
|
-
high_db_conn_count = newrelic.InfraAlertCondition("
|
|
780
|
+
critical={
|
|
781
|
+
"duration": 25,
|
|
782
|
+
"value": 90,
|
|
783
|
+
"time_function": "all",
|
|
784
|
+
},
|
|
785
|
+
warning={
|
|
786
|
+
"duration": 10,
|
|
787
|
+
"value": 80,
|
|
788
|
+
"time_function": "all",
|
|
789
|
+
})
|
|
790
|
+
high_db_conn_count = newrelic.InfraAlertCondition("high_db_conn_count",
|
|
778
791
|
policy_id=foo.id,
|
|
792
|
+
name="High database connection count",
|
|
779
793
|
description="Critical alert when the number of database connections goes above 90",
|
|
780
794
|
type="infra_metric",
|
|
781
795
|
event="DatastoreSample",
|
|
@@ -783,31 +797,34 @@ class InfraAlertCondition(pulumi.CustomResource):
|
|
|
783
797
|
comparison="above",
|
|
784
798
|
where="(hostname LIKE '%db%')",
|
|
785
799
|
integration_provider="RdsDbInstance",
|
|
786
|
-
critical=
|
|
787
|
-
duration
|
|
788
|
-
value
|
|
789
|
-
time_function
|
|
790
|
-
)
|
|
791
|
-
process_not_running = newrelic.InfraAlertCondition("
|
|
800
|
+
critical={
|
|
801
|
+
"duration": 25,
|
|
802
|
+
"value": 90,
|
|
803
|
+
"time_function": "all",
|
|
804
|
+
})
|
|
805
|
+
process_not_running = newrelic.InfraAlertCondition("process_not_running",
|
|
792
806
|
policy_id=foo.id,
|
|
807
|
+
name="Process not running (/usr/bin/ruby)",
|
|
793
808
|
description="Critical alert when ruby isn't running",
|
|
794
809
|
type="infra_process_running",
|
|
795
810
|
comparison="equal",
|
|
796
811
|
where="hostname = 'web01'",
|
|
797
812
|
process_where="commandName = '/usr/bin/ruby'",
|
|
798
|
-
critical=
|
|
799
|
-
duration
|
|
800
|
-
value
|
|
801
|
-
)
|
|
802
|
-
host_not_reporting = newrelic.InfraAlertCondition("
|
|
813
|
+
critical={
|
|
814
|
+
"duration": 5,
|
|
815
|
+
"value": 0,
|
|
816
|
+
})
|
|
817
|
+
host_not_reporting = newrelic.InfraAlertCondition("host_not_reporting",
|
|
803
818
|
policy_id=foo.id,
|
|
819
|
+
name="Host not reporting",
|
|
804
820
|
description="Critical alert when the host is not reporting",
|
|
805
821
|
type="infra_host_not_reporting",
|
|
806
822
|
where="(hostname LIKE '%frontend%')",
|
|
807
|
-
critical=
|
|
808
|
-
duration
|
|
809
|
-
)
|
|
823
|
+
critical={
|
|
824
|
+
"duration": 5,
|
|
825
|
+
})
|
|
810
826
|
```
|
|
827
|
+
|
|
811
828
|
## Thresholds
|
|
812
829
|
|
|
813
830
|
The `critical` and `warning` threshold mapping supports the following arguments:
|
|
@@ -824,39 +841,40 @@ class InfraAlertCondition(pulumi.CustomResource):
|
|
|
824
841
|
import pulumi
|
|
825
842
|
import pulumi_newrelic as newrelic
|
|
826
843
|
|
|
827
|
-
|
|
828
|
-
foo_infra_alert_condition = newrelic.InfraAlertCondition("
|
|
829
|
-
policy_id=
|
|
844
|
+
foo = newrelic.AlertPolicy("foo", name="foo policy")
|
|
845
|
+
foo_infra_alert_condition = newrelic.InfraAlertCondition("foo",
|
|
846
|
+
policy_id=foo.id,
|
|
847
|
+
name="foo infra condition",
|
|
830
848
|
description="Warning if disk usage goes above 80% and critical alert if goes above 90%",
|
|
831
849
|
type="infra_metric",
|
|
832
850
|
event="StorageSample",
|
|
833
851
|
select="diskUsedPercent",
|
|
834
852
|
comparison="above",
|
|
835
853
|
where="(hostname LIKE '%frontend%')",
|
|
836
|
-
critical=
|
|
837
|
-
duration
|
|
838
|
-
value
|
|
839
|
-
time_function
|
|
840
|
-
|
|
841
|
-
warning=
|
|
842
|
-
duration
|
|
843
|
-
value
|
|
844
|
-
time_function
|
|
845
|
-
)
|
|
846
|
-
my_condition_entity_tags = newrelic.EntityTags("
|
|
854
|
+
critical={
|
|
855
|
+
"duration": 25,
|
|
856
|
+
"value": 90,
|
|
857
|
+
"time_function": "all",
|
|
858
|
+
},
|
|
859
|
+
warning={
|
|
860
|
+
"duration": 10,
|
|
861
|
+
"value": 80,
|
|
862
|
+
"time_function": "all",
|
|
863
|
+
})
|
|
864
|
+
my_condition_entity_tags = newrelic.EntityTags("my_condition_entity_tags",
|
|
847
865
|
guid=foo_infra_alert_condition.entity_guid,
|
|
848
866
|
tags=[
|
|
849
|
-
|
|
850
|
-
key
|
|
851
|
-
values
|
|
867
|
+
{
|
|
868
|
+
"key": "my-key",
|
|
869
|
+
"values": [
|
|
852
870
|
"my-value",
|
|
853
871
|
"my-other-value",
|
|
854
872
|
],
|
|
855
|
-
|
|
856
|
-
|
|
857
|
-
key
|
|
858
|
-
values
|
|
859
|
-
|
|
873
|
+
},
|
|
874
|
+
{
|
|
875
|
+
"key": "my-key-2",
|
|
876
|
+
"values": ["my-value-2"],
|
|
877
|
+
},
|
|
860
878
|
])
|
|
861
879
|
```
|
|
862
880
|
|
|
@@ -865,7 +883,7 @@ class InfraAlertCondition(pulumi.CustomResource):
|
|
|
865
883
|
Infrastructure alert conditions can be imported using a composite ID of `<policy_id>:<condition_id>`, e.g.
|
|
866
884
|
|
|
867
885
|
```sh
|
|
868
|
-
|
|
886
|
+
$ pulumi import newrelic:index/infraAlertCondition:InfraAlertCondition main 12345:67890
|
|
869
887
|
```
|
|
870
888
|
|
|
871
889
|
:param str resource_name: The name of the resource.
|
|
@@ -883,21 +901,21 @@ class InfraAlertCondition(pulumi.CustomResource):
|
|
|
883
901
|
def _internal_init(__self__,
|
|
884
902
|
resource_name: str,
|
|
885
903
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
886
|
-
comparison: Optional[pulumi.Input[str]] = None,
|
|
887
|
-
critical: Optional[pulumi.Input[
|
|
888
|
-
description: Optional[pulumi.Input[str]] = None,
|
|
889
|
-
enabled: Optional[pulumi.Input[bool]] = None,
|
|
890
|
-
event: Optional[pulumi.Input[str]] = None,
|
|
891
|
-
integration_provider: Optional[pulumi.Input[str]] = None,
|
|
892
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
893
|
-
policy_id: Optional[pulumi.Input[
|
|
894
|
-
process_where: Optional[pulumi.Input[str]] = None,
|
|
895
|
-
runbook_url: Optional[pulumi.Input[str]] = None,
|
|
896
|
-
select: Optional[pulumi.Input[str]] = None,
|
|
897
|
-
type: Optional[pulumi.Input[str]] = None,
|
|
898
|
-
violation_close_timer: Optional[pulumi.Input[int]] = None,
|
|
899
|
-
warning: Optional[pulumi.Input[
|
|
900
|
-
where: Optional[pulumi.Input[str]] = None,
|
|
904
|
+
comparison: Optional[pulumi.Input[_builtins.str]] = None,
|
|
905
|
+
critical: Optional[pulumi.Input[Union['InfraAlertConditionCriticalArgs', 'InfraAlertConditionCriticalArgsDict']]] = None,
|
|
906
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
907
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
908
|
+
event: Optional[pulumi.Input[_builtins.str]] = None,
|
|
909
|
+
integration_provider: Optional[pulumi.Input[_builtins.str]] = None,
|
|
910
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
911
|
+
policy_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
912
|
+
process_where: Optional[pulumi.Input[_builtins.str]] = None,
|
|
913
|
+
runbook_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
914
|
+
select: Optional[pulumi.Input[_builtins.str]] = None,
|
|
915
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
916
|
+
violation_close_timer: Optional[pulumi.Input[_builtins.int]] = None,
|
|
917
|
+
warning: Optional[pulumi.Input[Union['InfraAlertConditionWarningArgs', 'InfraAlertConditionWarningArgsDict']]] = None,
|
|
918
|
+
where: Optional[pulumi.Input[_builtins.str]] = None,
|
|
901
919
|
__props__=None):
|
|
902
920
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
903
921
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -939,24 +957,24 @@ class InfraAlertCondition(pulumi.CustomResource):
|
|
|
939
957
|
def get(resource_name: str,
|
|
940
958
|
id: pulumi.Input[str],
|
|
941
959
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
942
|
-
comparison: Optional[pulumi.Input[str]] = None,
|
|
943
|
-
created_at: Optional[pulumi.Input[int]] = None,
|
|
944
|
-
critical: Optional[pulumi.Input[
|
|
945
|
-
description: Optional[pulumi.Input[str]] = None,
|
|
946
|
-
enabled: Optional[pulumi.Input[bool]] = None,
|
|
947
|
-
entity_guid: Optional[pulumi.Input[str]] = None,
|
|
948
|
-
event: Optional[pulumi.Input[str]] = None,
|
|
949
|
-
integration_provider: Optional[pulumi.Input[str]] = None,
|
|
950
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
951
|
-
policy_id: Optional[pulumi.Input[
|
|
952
|
-
process_where: Optional[pulumi.Input[str]] = None,
|
|
953
|
-
runbook_url: Optional[pulumi.Input[str]] = None,
|
|
954
|
-
select: Optional[pulumi.Input[str]] = None,
|
|
955
|
-
type: Optional[pulumi.Input[str]] = None,
|
|
956
|
-
updated_at: Optional[pulumi.Input[int]] = None,
|
|
957
|
-
violation_close_timer: Optional[pulumi.Input[int]] = None,
|
|
958
|
-
warning: Optional[pulumi.Input[
|
|
959
|
-
where: Optional[pulumi.Input[str]] = None) -> 'InfraAlertCondition':
|
|
960
|
+
comparison: Optional[pulumi.Input[_builtins.str]] = None,
|
|
961
|
+
created_at: Optional[pulumi.Input[_builtins.int]] = None,
|
|
962
|
+
critical: Optional[pulumi.Input[Union['InfraAlertConditionCriticalArgs', 'InfraAlertConditionCriticalArgsDict']]] = None,
|
|
963
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
964
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
965
|
+
entity_guid: Optional[pulumi.Input[_builtins.str]] = None,
|
|
966
|
+
event: Optional[pulumi.Input[_builtins.str]] = None,
|
|
967
|
+
integration_provider: Optional[pulumi.Input[_builtins.str]] = None,
|
|
968
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
969
|
+
policy_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
970
|
+
process_where: Optional[pulumi.Input[_builtins.str]] = None,
|
|
971
|
+
runbook_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
972
|
+
select: Optional[pulumi.Input[_builtins.str]] = None,
|
|
973
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
974
|
+
updated_at: Optional[pulumi.Input[_builtins.int]] = None,
|
|
975
|
+
violation_close_timer: Optional[pulumi.Input[_builtins.int]] = None,
|
|
976
|
+
warning: Optional[pulumi.Input[Union['InfraAlertConditionWarningArgs', 'InfraAlertConditionWarningArgsDict']]] = None,
|
|
977
|
+
where: Optional[pulumi.Input[_builtins.str]] = None) -> 'InfraAlertCondition':
|
|
960
978
|
"""
|
|
961
979
|
Get an existing InfraAlertCondition resource's state with the given name, id, and optional extra
|
|
962
980
|
properties used to qualify the lookup.
|
|
@@ -964,28 +982,28 @@ class InfraAlertCondition(pulumi.CustomResource):
|
|
|
964
982
|
:param str resource_name: The unique name of the resulting resource.
|
|
965
983
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
966
984
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
967
|
-
:param pulumi.Input[str] comparison: The operator used to evaluate the threshold value. Valid values are `above`, `below`, and `equal`. Supported by the `infra_metric` and `infra_process_running` condition types.
|
|
968
|
-
:param pulumi.Input[int] created_at: The timestamp the alert condition was created.
|
|
969
|
-
:param pulumi.Input[
|
|
970
|
-
:param pulumi.Input[str] description: The description of the Infrastructure alert condition.
|
|
971
|
-
:param pulumi.Input[bool] enabled: Whether the condition is turned on or off. Valid values are `true` and `false`. Defaults to `true`.
|
|
972
|
-
:param pulumi.Input[str] entity_guid: The unique entity identifier of the condition in New Relic.
|
|
973
|
-
:param pulumi.Input[str] event: The metric event; for example, `SystemSample` or `StorageSample`. Supported by the `infra_metric` condition type.
|
|
974
|
-
:param pulumi.Input[str] integration_provider: For alerts on integrations, use this instead of `event`. Supported by the `infra_metric` condition type.
|
|
975
|
-
:param pulumi.Input[str] name: The Infrastructure alert condition's name.
|
|
976
|
-
:param pulumi.Input[
|
|
977
|
-
:param pulumi.Input[str] process_where: Any filters applied to processes; for example: `commandName = 'java'`. Required by the `infra_process_running` condition type.
|
|
978
|
-
:param pulumi.Input[str] runbook_url: Runbook URL to display in notifications.
|
|
979
|
-
:param pulumi.Input[str] select: The attribute name to identify the metric being targeted; for example, `cpuPercent`, `diskFreePercent`, or `memoryResidentSizeBytes`. The underlying API will automatically populate this value for Infrastructure integrations (for example `diskFreePercent`), so make sure to explicitly include this value to avoid diff issues. Supported by the `infra_metric` condition type.
|
|
980
|
-
:param pulumi.Input[str] type: The type of Infrastructure alert condition. Valid values are `infra_process_running`, `infra_metric`, and `infra_host_not_reporting`.
|
|
981
|
-
:param pulumi.Input[int] updated_at: The timestamp the alert condition was last updated.
|
|
982
|
-
:param pulumi.Input[int] violation_close_timer: Determines how much time will pass (in hours) before an incident is automatically closed. Valid values are `1 2 4 8 12 24 48 72`. Defaults to 24. If `0` is provided, default of `24` is used and will have configuration drift during the apply phase until a valid value is provided.
|
|
985
|
+
:param pulumi.Input[_builtins.str] comparison: The operator used to evaluate the threshold value. Valid values are `above`, `below`, and `equal`. Supported by the `infra_metric` and `infra_process_running` condition types.
|
|
986
|
+
:param pulumi.Input[_builtins.int] created_at: The timestamp the alert condition was created.
|
|
987
|
+
:param pulumi.Input[Union['InfraAlertConditionCriticalArgs', 'InfraAlertConditionCriticalArgsDict']] critical: Identifies the threshold parameters for opening a critical alert incident. See Thresholds below for details.
|
|
988
|
+
:param pulumi.Input[_builtins.str] description: The description of the Infrastructure alert condition.
|
|
989
|
+
:param pulumi.Input[_builtins.bool] enabled: Whether the condition is turned on or off. Valid values are `true` and `false`. Defaults to `true`.
|
|
990
|
+
:param pulumi.Input[_builtins.str] entity_guid: The unique entity identifier of the condition in New Relic.
|
|
991
|
+
:param pulumi.Input[_builtins.str] event: The metric event; for example, `SystemSample` or `StorageSample`. Supported by the `infra_metric` condition type.
|
|
992
|
+
:param pulumi.Input[_builtins.str] integration_provider: For alerts on integrations, use this instead of `event`. Supported by the `infra_metric` condition type.
|
|
993
|
+
:param pulumi.Input[_builtins.str] name: The Infrastructure alert condition's name.
|
|
994
|
+
:param pulumi.Input[_builtins.str] policy_id: The ID of the alert policy where this condition should be used.
|
|
995
|
+
:param pulumi.Input[_builtins.str] process_where: Any filters applied to processes; for example: `commandName = 'java'`. Required by the `infra_process_running` condition type.
|
|
996
|
+
:param pulumi.Input[_builtins.str] runbook_url: Runbook URL to display in notifications.
|
|
997
|
+
:param pulumi.Input[_builtins.str] select: The attribute name to identify the metric being targeted; for example, `cpuPercent`, `diskFreePercent`, or `memoryResidentSizeBytes`. The underlying API will automatically populate this value for Infrastructure integrations (for example `diskFreePercent`), so make sure to explicitly include this value to avoid diff issues. Supported by the `infra_metric` condition type.
|
|
998
|
+
:param pulumi.Input[_builtins.str] type: The type of Infrastructure alert condition. Valid values are `infra_process_running`, `infra_metric`, and `infra_host_not_reporting`.
|
|
999
|
+
:param pulumi.Input[_builtins.int] updated_at: The timestamp the alert condition was last updated.
|
|
1000
|
+
:param pulumi.Input[_builtins.int] violation_close_timer: Determines how much time will pass (in hours) before an incident is automatically closed. Valid values are `1 2 4 8 12 24 48 72`. Defaults to 24. If `0` is provided, default of `24` is used and will have configuration drift during the apply phase until a valid value is provided.
|
|
983
1001
|
|
|
984
|
-
```python
|
|
985
|
-
import pulumi
|
|
986
1002
|
```
|
|
987
|
-
|
|
988
|
-
|
|
1003
|
+
Warning: This resource will use the account ID linked to your API key. At the moment it is not possible to dynamically set the account ID.
|
|
1004
|
+
```
|
|
1005
|
+
:param pulumi.Input[Union['InfraAlertConditionWarningArgs', 'InfraAlertConditionWarningArgsDict']] warning: Identifies the threshold parameters for opening a warning alert incident. See Thresholds below for details.
|
|
1006
|
+
:param pulumi.Input[_builtins.str] where: If applicable, this identifies any Infrastructure host filters used; for example: `hostname LIKE '%cassandra%'`.
|
|
989
1007
|
"""
|
|
990
1008
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
991
1009
|
|
|
@@ -1011,23 +1029,23 @@ class InfraAlertCondition(pulumi.CustomResource):
|
|
|
1011
1029
|
__props__.__dict__["where"] = where
|
|
1012
1030
|
return InfraAlertCondition(resource_name, opts=opts, __props__=__props__)
|
|
1013
1031
|
|
|
1014
|
-
@property
|
|
1032
|
+
@_builtins.property
|
|
1015
1033
|
@pulumi.getter
|
|
1016
|
-
def comparison(self) -> pulumi.Output[Optional[str]]:
|
|
1034
|
+
def comparison(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1017
1035
|
"""
|
|
1018
1036
|
The operator used to evaluate the threshold value. Valid values are `above`, `below`, and `equal`. Supported by the `infra_metric` and `infra_process_running` condition types.
|
|
1019
1037
|
"""
|
|
1020
1038
|
return pulumi.get(self, "comparison")
|
|
1021
1039
|
|
|
1022
|
-
@property
|
|
1040
|
+
@_builtins.property
|
|
1023
1041
|
@pulumi.getter(name="createdAt")
|
|
1024
|
-
def created_at(self) -> pulumi.Output[int]:
|
|
1042
|
+
def created_at(self) -> pulumi.Output[_builtins.int]:
|
|
1025
1043
|
"""
|
|
1026
1044
|
The timestamp the alert condition was created.
|
|
1027
1045
|
"""
|
|
1028
1046
|
return pulumi.get(self, "created_at")
|
|
1029
1047
|
|
|
1030
|
-
@property
|
|
1048
|
+
@_builtins.property
|
|
1031
1049
|
@pulumi.getter
|
|
1032
1050
|
def critical(self) -> pulumi.Output[Optional['outputs.InfraAlertConditionCritical']]:
|
|
1033
1051
|
"""
|
|
@@ -1035,115 +1053,115 @@ class InfraAlertCondition(pulumi.CustomResource):
|
|
|
1035
1053
|
"""
|
|
1036
1054
|
return pulumi.get(self, "critical")
|
|
1037
1055
|
|
|
1038
|
-
@property
|
|
1056
|
+
@_builtins.property
|
|
1039
1057
|
@pulumi.getter
|
|
1040
|
-
def description(self) -> pulumi.Output[Optional[str]]:
|
|
1058
|
+
def description(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1041
1059
|
"""
|
|
1042
1060
|
The description of the Infrastructure alert condition.
|
|
1043
1061
|
"""
|
|
1044
1062
|
return pulumi.get(self, "description")
|
|
1045
1063
|
|
|
1046
|
-
@property
|
|
1064
|
+
@_builtins.property
|
|
1047
1065
|
@pulumi.getter
|
|
1048
|
-
def enabled(self) -> pulumi.Output[Optional[bool]]:
|
|
1066
|
+
def enabled(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1049
1067
|
"""
|
|
1050
1068
|
Whether the condition is turned on or off. Valid values are `true` and `false`. Defaults to `true`.
|
|
1051
1069
|
"""
|
|
1052
1070
|
return pulumi.get(self, "enabled")
|
|
1053
1071
|
|
|
1054
|
-
@property
|
|
1072
|
+
@_builtins.property
|
|
1055
1073
|
@pulumi.getter(name="entityGuid")
|
|
1056
|
-
def entity_guid(self) -> pulumi.Output[str]:
|
|
1074
|
+
def entity_guid(self) -> pulumi.Output[_builtins.str]:
|
|
1057
1075
|
"""
|
|
1058
1076
|
The unique entity identifier of the condition in New Relic.
|
|
1059
1077
|
"""
|
|
1060
1078
|
return pulumi.get(self, "entity_guid")
|
|
1061
1079
|
|
|
1062
|
-
@property
|
|
1080
|
+
@_builtins.property
|
|
1063
1081
|
@pulumi.getter
|
|
1064
|
-
def event(self) -> pulumi.Output[str]:
|
|
1082
|
+
def event(self) -> pulumi.Output[_builtins.str]:
|
|
1065
1083
|
"""
|
|
1066
1084
|
The metric event; for example, `SystemSample` or `StorageSample`. Supported by the `infra_metric` condition type.
|
|
1067
1085
|
"""
|
|
1068
1086
|
return pulumi.get(self, "event")
|
|
1069
1087
|
|
|
1070
|
-
@property
|
|
1088
|
+
@_builtins.property
|
|
1071
1089
|
@pulumi.getter(name="integrationProvider")
|
|
1072
|
-
def integration_provider(self) -> pulumi.Output[Optional[str]]:
|
|
1090
|
+
def integration_provider(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1073
1091
|
"""
|
|
1074
1092
|
For alerts on integrations, use this instead of `event`. Supported by the `infra_metric` condition type.
|
|
1075
1093
|
"""
|
|
1076
1094
|
return pulumi.get(self, "integration_provider")
|
|
1077
1095
|
|
|
1078
|
-
@property
|
|
1096
|
+
@_builtins.property
|
|
1079
1097
|
@pulumi.getter
|
|
1080
|
-
def name(self) -> pulumi.Output[str]:
|
|
1098
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
1081
1099
|
"""
|
|
1082
1100
|
The Infrastructure alert condition's name.
|
|
1083
1101
|
"""
|
|
1084
1102
|
return pulumi.get(self, "name")
|
|
1085
1103
|
|
|
1086
|
-
@property
|
|
1104
|
+
@_builtins.property
|
|
1087
1105
|
@pulumi.getter(name="policyId")
|
|
1088
|
-
def policy_id(self) -> pulumi.Output[
|
|
1106
|
+
def policy_id(self) -> pulumi.Output[_builtins.str]:
|
|
1089
1107
|
"""
|
|
1090
1108
|
The ID of the alert policy where this condition should be used.
|
|
1091
1109
|
"""
|
|
1092
1110
|
return pulumi.get(self, "policy_id")
|
|
1093
1111
|
|
|
1094
|
-
@property
|
|
1112
|
+
@_builtins.property
|
|
1095
1113
|
@pulumi.getter(name="processWhere")
|
|
1096
|
-
def process_where(self) -> pulumi.Output[Optional[str]]:
|
|
1114
|
+
def process_where(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1097
1115
|
"""
|
|
1098
1116
|
Any filters applied to processes; for example: `commandName = 'java'`. Required by the `infra_process_running` condition type.
|
|
1099
1117
|
"""
|
|
1100
1118
|
return pulumi.get(self, "process_where")
|
|
1101
1119
|
|
|
1102
|
-
@property
|
|
1120
|
+
@_builtins.property
|
|
1103
1121
|
@pulumi.getter(name="runbookUrl")
|
|
1104
|
-
def runbook_url(self) -> pulumi.Output[Optional[str]]:
|
|
1122
|
+
def runbook_url(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1105
1123
|
"""
|
|
1106
1124
|
Runbook URL to display in notifications.
|
|
1107
1125
|
"""
|
|
1108
1126
|
return pulumi.get(self, "runbook_url")
|
|
1109
1127
|
|
|
1110
|
-
@property
|
|
1128
|
+
@_builtins.property
|
|
1111
1129
|
@pulumi.getter
|
|
1112
|
-
def select(self) -> pulumi.Output[Optional[str]]:
|
|
1130
|
+
def select(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1113
1131
|
"""
|
|
1114
1132
|
The attribute name to identify the metric being targeted; for example, `cpuPercent`, `diskFreePercent`, or `memoryResidentSizeBytes`. The underlying API will automatically populate this value for Infrastructure integrations (for example `diskFreePercent`), so make sure to explicitly include this value to avoid diff issues. Supported by the `infra_metric` condition type.
|
|
1115
1133
|
"""
|
|
1116
1134
|
return pulumi.get(self, "select")
|
|
1117
1135
|
|
|
1118
|
-
@property
|
|
1136
|
+
@_builtins.property
|
|
1119
1137
|
@pulumi.getter
|
|
1120
|
-
def type(self) -> pulumi.Output[str]:
|
|
1138
|
+
def type(self) -> pulumi.Output[_builtins.str]:
|
|
1121
1139
|
"""
|
|
1122
1140
|
The type of Infrastructure alert condition. Valid values are `infra_process_running`, `infra_metric`, and `infra_host_not_reporting`.
|
|
1123
1141
|
"""
|
|
1124
1142
|
return pulumi.get(self, "type")
|
|
1125
1143
|
|
|
1126
|
-
@property
|
|
1144
|
+
@_builtins.property
|
|
1127
1145
|
@pulumi.getter(name="updatedAt")
|
|
1128
|
-
def updated_at(self) -> pulumi.Output[int]:
|
|
1146
|
+
def updated_at(self) -> pulumi.Output[_builtins.int]:
|
|
1129
1147
|
"""
|
|
1130
1148
|
The timestamp the alert condition was last updated.
|
|
1131
1149
|
"""
|
|
1132
1150
|
return pulumi.get(self, "updated_at")
|
|
1133
1151
|
|
|
1134
|
-
@property
|
|
1152
|
+
@_builtins.property
|
|
1135
1153
|
@pulumi.getter(name="violationCloseTimer")
|
|
1136
|
-
def violation_close_timer(self) -> pulumi.Output[Optional[int]]:
|
|
1154
|
+
def violation_close_timer(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1137
1155
|
"""
|
|
1138
1156
|
Determines how much time will pass (in hours) before an incident is automatically closed. Valid values are `1 2 4 8 12 24 48 72`. Defaults to 24. If `0` is provided, default of `24` is used and will have configuration drift during the apply phase until a valid value is provided.
|
|
1139
1157
|
|
|
1140
|
-
```
|
|
1141
|
-
|
|
1158
|
+
```
|
|
1159
|
+
Warning: This resource will use the account ID linked to your API key. At the moment it is not possible to dynamically set the account ID.
|
|
1142
1160
|
```
|
|
1143
1161
|
"""
|
|
1144
1162
|
return pulumi.get(self, "violation_close_timer")
|
|
1145
1163
|
|
|
1146
|
-
@property
|
|
1164
|
+
@_builtins.property
|
|
1147
1165
|
@pulumi.getter
|
|
1148
1166
|
def warning(self) -> pulumi.Output[Optional['outputs.InfraAlertConditionWarning']]:
|
|
1149
1167
|
"""
|
|
@@ -1151,9 +1169,9 @@ class InfraAlertCondition(pulumi.CustomResource):
|
|
|
1151
1169
|
"""
|
|
1152
1170
|
return pulumi.get(self, "warning")
|
|
1153
1171
|
|
|
1154
|
-
@property
|
|
1172
|
+
@_builtins.property
|
|
1155
1173
|
@pulumi.getter
|
|
1156
|
-
def where(self) -> pulumi.Output[Optional[str]]:
|
|
1174
|
+
def where(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1157
1175
|
"""
|
|
1158
1176
|
If applicable, this identifies any Infrastructure host filters used; for example: `hostname LIKE '%cassandra%'`.
|
|
1159
1177
|
"""
|