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