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,42 +21,40 @@ __all__ = ['AlertConditionArgs', 'AlertCondition']
|
|
|
16
21
|
@pulumi.input_type
|
|
17
22
|
class AlertConditionArgs:
|
|
18
23
|
def __init__(__self__, *,
|
|
19
|
-
entities: pulumi.Input[Sequence[pulumi.Input[
|
|
20
|
-
metric: pulumi.Input[str],
|
|
21
|
-
policy_id: pulumi.Input[
|
|
24
|
+
entities: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
|
|
25
|
+
metric: pulumi.Input[_builtins.str],
|
|
26
|
+
policy_id: pulumi.Input[_builtins.str],
|
|
22
27
|
terms: pulumi.Input[Sequence[pulumi.Input['AlertConditionTermArgs']]],
|
|
23
|
-
type: pulumi.Input[str],
|
|
24
|
-
condition_scope: Optional[pulumi.Input[str]] = None,
|
|
25
|
-
enabled: Optional[pulumi.Input[bool]] = None,
|
|
26
|
-
gc_metric: Optional[pulumi.Input[str]] = None,
|
|
27
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
28
|
-
runbook_url: Optional[pulumi.Input[str]] = None,
|
|
29
|
-
user_defined_metric: Optional[pulumi.Input[str]] = None,
|
|
30
|
-
user_defined_value_function: Optional[pulumi.Input[str]] = None,
|
|
31
|
-
violation_close_timer: Optional[pulumi.Input[int]] = None):
|
|
28
|
+
type: pulumi.Input[_builtins.str],
|
|
29
|
+
condition_scope: Optional[pulumi.Input[_builtins.str]] = None,
|
|
30
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
31
|
+
gc_metric: Optional[pulumi.Input[_builtins.str]] = None,
|
|
32
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
33
|
+
runbook_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
34
|
+
user_defined_metric: Optional[pulumi.Input[_builtins.str]] = None,
|
|
35
|
+
user_defined_value_function: Optional[pulumi.Input[_builtins.str]] = None,
|
|
36
|
+
violation_close_timer: Optional[pulumi.Input[_builtins.int]] = None):
|
|
32
37
|
"""
|
|
33
38
|
The set of arguments for constructing a AlertCondition resource.
|
|
34
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
35
|
-
:param pulumi.Input[str] metric: The metric field accepts parameters based on the `type` set. One of these metrics based on `type`:
|
|
36
|
-
:param pulumi.Input[
|
|
39
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] entities: The instance IDs associated with this condition.
|
|
40
|
+
:param pulumi.Input[_builtins.str] metric: The metric field accepts parameters based on the `type` set. One of these metrics based on `type`:
|
|
41
|
+
:param pulumi.Input[_builtins.str] policy_id: The ID of the policy where this condition should be used.
|
|
37
42
|
:param pulumi.Input[Sequence[pulumi.Input['AlertConditionTermArgs']]] terms: A list of terms for this condition. See Terms below for details.
|
|
38
|
-
:param pulumi.Input[str] type: The type of condition. One of: `apm_app_metric`, `apm_jvm_metric`, `apm_kt_metric`, `browser_metric`, `mobile_metric`
|
|
39
|
-
:param pulumi.Input[str] condition_scope: `application` or `instance`. Choose `application` for most scenarios. If you are using the JVM plugin in New Relic, the `instance` setting allows your condition to trigger [for specific app instances](https://docs.newrelic.com/docs/alerts/new-relic-alerts/defining-conditions/scope-alert-thresholds-specific-instances).
|
|
40
|
-
:param pulumi.Input[bool] enabled: Whether the condition is enabled or not. Defaults to true.
|
|
41
|
-
:param pulumi.Input[str] gc_metric: A valid Garbage Collection metric e.g. `GC/G1 Young Generation`.
|
|
42
|
-
:param pulumi.Input[str] name: The title of the condition. Must be between 1 and 64 characters, inclusive.
|
|
43
|
-
:param pulumi.Input[str] runbook_url: Runbook URL to display in notifications.
|
|
44
|
-
:param pulumi.Input[str] user_defined_metric: A custom metric to be evaluated.
|
|
45
|
-
:param pulumi.Input[str] user_defined_value_function: One of: `average`, `min`, `max`, `total`, `sample_size`, `rate` or `percent`.
|
|
43
|
+
:param pulumi.Input[_builtins.str] type: The type of condition. One of: `apm_app_metric`, `apm_jvm_metric`, `apm_kt_metric`, `browser_metric`, `mobile_metric`
|
|
44
|
+
:param pulumi.Input[_builtins.str] condition_scope: `application` or `instance`. Choose `application` for most scenarios. If you are using the JVM plugin in New Relic, the `instance` setting allows your condition to trigger [for specific app instances](https://docs.newrelic.com/docs/alerts/new-relic-alerts/defining-conditions/scope-alert-thresholds-specific-instances).
|
|
45
|
+
:param pulumi.Input[_builtins.bool] enabled: Whether the condition is enabled or not. Defaults to true.
|
|
46
|
+
:param pulumi.Input[_builtins.str] gc_metric: A valid Garbage Collection metric e.g. `GC/G1 Young Generation`.
|
|
47
|
+
:param pulumi.Input[_builtins.str] name: The title of the condition. Must be between 1 and 64 characters, inclusive.
|
|
48
|
+
:param pulumi.Input[_builtins.str] runbook_url: Runbook URL to display in notifications.
|
|
49
|
+
:param pulumi.Input[_builtins.str] user_defined_metric: A custom metric to be evaluated.
|
|
50
|
+
:param pulumi.Input[_builtins.str] user_defined_value_function: One of: `average`, `min`, `max`, `total`, `sample_size`, `rate` or `percent`.
|
|
46
51
|
|
|
47
52
|
> **NOTE:** The `user_defined_value_function` can have `rate` or `percent` only when the `type` is `mobile_metric`.
|
|
48
53
|
|
|
49
|
-
<!--Start PulumiCodeChooser -->
|
|
50
|
-
```python
|
|
51
|
-
import pulumi
|
|
52
54
|
```
|
|
53
|
-
|
|
54
|
-
|
|
55
|
+
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.
|
|
56
|
+
```
|
|
57
|
+
:param pulumi.Input[_builtins.int] violation_close_timer: Automatically close instance-based incidents, including JVM health metric incidents, after the number of hours specified. Must be between 1 and 720 hours. Must be specified in the following two cases, to prevent drift:
|
|
55
58
|
* when `type` = `apm_app_metric` and `condition_scope` = `instance`
|
|
56
59
|
* when `type` = `apm_jvm_metric`
|
|
57
60
|
"""
|
|
@@ -77,43 +80,43 @@ class AlertConditionArgs:
|
|
|
77
80
|
if violation_close_timer is not None:
|
|
78
81
|
pulumi.set(__self__, "violation_close_timer", violation_close_timer)
|
|
79
82
|
|
|
80
|
-
@property
|
|
83
|
+
@_builtins.property
|
|
81
84
|
@pulumi.getter
|
|
82
|
-
def entities(self) -> pulumi.Input[Sequence[pulumi.Input[
|
|
85
|
+
def entities(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
83
86
|
"""
|
|
84
87
|
The instance IDs associated with this condition.
|
|
85
88
|
"""
|
|
86
89
|
return pulumi.get(self, "entities")
|
|
87
90
|
|
|
88
91
|
@entities.setter
|
|
89
|
-
def entities(self, value: pulumi.Input[Sequence[pulumi.Input[
|
|
92
|
+
def entities(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
90
93
|
pulumi.set(self, "entities", value)
|
|
91
94
|
|
|
92
|
-
@property
|
|
95
|
+
@_builtins.property
|
|
93
96
|
@pulumi.getter
|
|
94
|
-
def metric(self) -> pulumi.Input[str]:
|
|
97
|
+
def metric(self) -> pulumi.Input[_builtins.str]:
|
|
95
98
|
"""
|
|
96
99
|
The metric field accepts parameters based on the `type` set. One of these metrics based on `type`:
|
|
97
100
|
"""
|
|
98
101
|
return pulumi.get(self, "metric")
|
|
99
102
|
|
|
100
103
|
@metric.setter
|
|
101
|
-
def metric(self, value: pulumi.Input[str]):
|
|
104
|
+
def metric(self, value: pulumi.Input[_builtins.str]):
|
|
102
105
|
pulumi.set(self, "metric", value)
|
|
103
106
|
|
|
104
|
-
@property
|
|
107
|
+
@_builtins.property
|
|
105
108
|
@pulumi.getter(name="policyId")
|
|
106
|
-
def policy_id(self) -> pulumi.Input[
|
|
109
|
+
def policy_id(self) -> pulumi.Input[_builtins.str]:
|
|
107
110
|
"""
|
|
108
111
|
The ID of the policy where this condition should be used.
|
|
109
112
|
"""
|
|
110
113
|
return pulumi.get(self, "policy_id")
|
|
111
114
|
|
|
112
115
|
@policy_id.setter
|
|
113
|
-
def policy_id(self, value: pulumi.Input[
|
|
116
|
+
def policy_id(self, value: pulumi.Input[_builtins.str]):
|
|
114
117
|
pulumi.set(self, "policy_id", value)
|
|
115
118
|
|
|
116
|
-
@property
|
|
119
|
+
@_builtins.property
|
|
117
120
|
@pulumi.getter
|
|
118
121
|
def terms(self) -> pulumi.Input[Sequence[pulumi.Input['AlertConditionTermArgs']]]:
|
|
119
122
|
"""
|
|
@@ -125,113 +128,111 @@ class AlertConditionArgs:
|
|
|
125
128
|
def terms(self, value: pulumi.Input[Sequence[pulumi.Input['AlertConditionTermArgs']]]):
|
|
126
129
|
pulumi.set(self, "terms", value)
|
|
127
130
|
|
|
128
|
-
@property
|
|
131
|
+
@_builtins.property
|
|
129
132
|
@pulumi.getter
|
|
130
|
-
def type(self) -> pulumi.Input[str]:
|
|
133
|
+
def type(self) -> pulumi.Input[_builtins.str]:
|
|
131
134
|
"""
|
|
132
135
|
The type of condition. One of: `apm_app_metric`, `apm_jvm_metric`, `apm_kt_metric`, `browser_metric`, `mobile_metric`
|
|
133
136
|
"""
|
|
134
137
|
return pulumi.get(self, "type")
|
|
135
138
|
|
|
136
139
|
@type.setter
|
|
137
|
-
def type(self, value: pulumi.Input[str]):
|
|
140
|
+
def type(self, value: pulumi.Input[_builtins.str]):
|
|
138
141
|
pulumi.set(self, "type", value)
|
|
139
142
|
|
|
140
|
-
@property
|
|
143
|
+
@_builtins.property
|
|
141
144
|
@pulumi.getter(name="conditionScope")
|
|
142
|
-
def condition_scope(self) -> Optional[pulumi.Input[str]]:
|
|
145
|
+
def condition_scope(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
143
146
|
"""
|
|
144
147
|
`application` or `instance`. Choose `application` for most scenarios. If you are using the JVM plugin in New Relic, the `instance` setting allows your condition to trigger [for specific app instances](https://docs.newrelic.com/docs/alerts/new-relic-alerts/defining-conditions/scope-alert-thresholds-specific-instances).
|
|
145
148
|
"""
|
|
146
149
|
return pulumi.get(self, "condition_scope")
|
|
147
150
|
|
|
148
151
|
@condition_scope.setter
|
|
149
|
-
def condition_scope(self, value: Optional[pulumi.Input[str]]):
|
|
152
|
+
def condition_scope(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
150
153
|
pulumi.set(self, "condition_scope", value)
|
|
151
154
|
|
|
152
|
-
@property
|
|
155
|
+
@_builtins.property
|
|
153
156
|
@pulumi.getter
|
|
154
|
-
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
157
|
+
def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
155
158
|
"""
|
|
156
159
|
Whether the condition is enabled or not. Defaults to true.
|
|
157
160
|
"""
|
|
158
161
|
return pulumi.get(self, "enabled")
|
|
159
162
|
|
|
160
163
|
@enabled.setter
|
|
161
|
-
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
164
|
+
def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
162
165
|
pulumi.set(self, "enabled", value)
|
|
163
166
|
|
|
164
|
-
@property
|
|
167
|
+
@_builtins.property
|
|
165
168
|
@pulumi.getter(name="gcMetric")
|
|
166
|
-
def gc_metric(self) -> Optional[pulumi.Input[str]]:
|
|
169
|
+
def gc_metric(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
167
170
|
"""
|
|
168
171
|
A valid Garbage Collection metric e.g. `GC/G1 Young Generation`.
|
|
169
172
|
"""
|
|
170
173
|
return pulumi.get(self, "gc_metric")
|
|
171
174
|
|
|
172
175
|
@gc_metric.setter
|
|
173
|
-
def gc_metric(self, value: Optional[pulumi.Input[str]]):
|
|
176
|
+
def gc_metric(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
174
177
|
pulumi.set(self, "gc_metric", value)
|
|
175
178
|
|
|
176
|
-
@property
|
|
179
|
+
@_builtins.property
|
|
177
180
|
@pulumi.getter
|
|
178
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
181
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
179
182
|
"""
|
|
180
183
|
The title of the condition. Must be between 1 and 64 characters, inclusive.
|
|
181
184
|
"""
|
|
182
185
|
return pulumi.get(self, "name")
|
|
183
186
|
|
|
184
187
|
@name.setter
|
|
185
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
188
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
186
189
|
pulumi.set(self, "name", value)
|
|
187
190
|
|
|
188
|
-
@property
|
|
191
|
+
@_builtins.property
|
|
189
192
|
@pulumi.getter(name="runbookUrl")
|
|
190
|
-
def runbook_url(self) -> Optional[pulumi.Input[str]]:
|
|
193
|
+
def runbook_url(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
191
194
|
"""
|
|
192
195
|
Runbook URL to display in notifications.
|
|
193
196
|
"""
|
|
194
197
|
return pulumi.get(self, "runbook_url")
|
|
195
198
|
|
|
196
199
|
@runbook_url.setter
|
|
197
|
-
def runbook_url(self, value: Optional[pulumi.Input[str]]):
|
|
200
|
+
def runbook_url(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
198
201
|
pulumi.set(self, "runbook_url", value)
|
|
199
202
|
|
|
200
|
-
@property
|
|
203
|
+
@_builtins.property
|
|
201
204
|
@pulumi.getter(name="userDefinedMetric")
|
|
202
|
-
def user_defined_metric(self) -> Optional[pulumi.Input[str]]:
|
|
205
|
+
def user_defined_metric(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
203
206
|
"""
|
|
204
207
|
A custom metric to be evaluated.
|
|
205
208
|
"""
|
|
206
209
|
return pulumi.get(self, "user_defined_metric")
|
|
207
210
|
|
|
208
211
|
@user_defined_metric.setter
|
|
209
|
-
def user_defined_metric(self, value: Optional[pulumi.Input[str]]):
|
|
212
|
+
def user_defined_metric(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
210
213
|
pulumi.set(self, "user_defined_metric", value)
|
|
211
214
|
|
|
212
|
-
@property
|
|
215
|
+
@_builtins.property
|
|
213
216
|
@pulumi.getter(name="userDefinedValueFunction")
|
|
214
|
-
def user_defined_value_function(self) -> Optional[pulumi.Input[str]]:
|
|
217
|
+
def user_defined_value_function(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
215
218
|
"""
|
|
216
219
|
One of: `average`, `min`, `max`, `total`, `sample_size`, `rate` or `percent`.
|
|
217
220
|
|
|
218
221
|
> **NOTE:** The `user_defined_value_function` can have `rate` or `percent` only when the `type` is `mobile_metric`.
|
|
219
222
|
|
|
220
|
-
<!--Start PulumiCodeChooser -->
|
|
221
|
-
```python
|
|
222
|
-
import pulumi
|
|
223
223
|
```
|
|
224
|
-
|
|
224
|
+
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.
|
|
225
|
+
```
|
|
225
226
|
"""
|
|
226
227
|
return pulumi.get(self, "user_defined_value_function")
|
|
227
228
|
|
|
228
229
|
@user_defined_value_function.setter
|
|
229
|
-
def user_defined_value_function(self, value: Optional[pulumi.Input[str]]):
|
|
230
|
+
def user_defined_value_function(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
230
231
|
pulumi.set(self, "user_defined_value_function", value)
|
|
231
232
|
|
|
232
|
-
@property
|
|
233
|
+
@_builtins.property
|
|
233
234
|
@pulumi.getter(name="violationCloseTimer")
|
|
234
|
-
def violation_close_timer(self) -> Optional[pulumi.Input[int]]:
|
|
235
|
+
def violation_close_timer(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
235
236
|
"""
|
|
236
237
|
Automatically close instance-based incidents, including JVM health metric incidents, after the number of hours specified. Must be between 1 and 720 hours. Must be specified in the following two cases, to prevent drift:
|
|
237
238
|
* when `type` = `apm_app_metric` and `condition_scope` = `instance`
|
|
@@ -240,51 +241,49 @@ class AlertConditionArgs:
|
|
|
240
241
|
return pulumi.get(self, "violation_close_timer")
|
|
241
242
|
|
|
242
243
|
@violation_close_timer.setter
|
|
243
|
-
def violation_close_timer(self, value: Optional[pulumi.Input[int]]):
|
|
244
|
+
def violation_close_timer(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
244
245
|
pulumi.set(self, "violation_close_timer", value)
|
|
245
246
|
|
|
246
247
|
|
|
247
248
|
@pulumi.input_type
|
|
248
249
|
class _AlertConditionState:
|
|
249
250
|
def __init__(__self__, *,
|
|
250
|
-
condition_scope: Optional[pulumi.Input[str]] = None,
|
|
251
|
-
enabled: Optional[pulumi.Input[bool]] = None,
|
|
252
|
-
entities: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
253
|
-
entity_guid: Optional[pulumi.Input[str]] = None,
|
|
254
|
-
gc_metric: Optional[pulumi.Input[str]] = None,
|
|
255
|
-
metric: Optional[pulumi.Input[str]] = None,
|
|
256
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
257
|
-
policy_id: Optional[pulumi.Input[
|
|
258
|
-
runbook_url: Optional[pulumi.Input[str]] = None,
|
|
251
|
+
condition_scope: Optional[pulumi.Input[_builtins.str]] = None,
|
|
252
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
253
|
+
entities: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
254
|
+
entity_guid: Optional[pulumi.Input[_builtins.str]] = None,
|
|
255
|
+
gc_metric: Optional[pulumi.Input[_builtins.str]] = None,
|
|
256
|
+
metric: Optional[pulumi.Input[_builtins.str]] = None,
|
|
257
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
258
|
+
policy_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
259
|
+
runbook_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
259
260
|
terms: Optional[pulumi.Input[Sequence[pulumi.Input['AlertConditionTermArgs']]]] = None,
|
|
260
|
-
type: Optional[pulumi.Input[str]] = None,
|
|
261
|
-
user_defined_metric: Optional[pulumi.Input[str]] = None,
|
|
262
|
-
user_defined_value_function: Optional[pulumi.Input[str]] = None,
|
|
263
|
-
violation_close_timer: Optional[pulumi.Input[int]] = None):
|
|
261
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
262
|
+
user_defined_metric: Optional[pulumi.Input[_builtins.str]] = None,
|
|
263
|
+
user_defined_value_function: Optional[pulumi.Input[_builtins.str]] = None,
|
|
264
|
+
violation_close_timer: Optional[pulumi.Input[_builtins.int]] = None):
|
|
264
265
|
"""
|
|
265
266
|
Input properties used for looking up and filtering AlertCondition resources.
|
|
266
|
-
:param pulumi.Input[str] condition_scope: `application` or `instance`. Choose `application` for most scenarios. If you are using the JVM plugin in New Relic, the `instance` setting allows your condition to trigger [for specific app instances](https://docs.newrelic.com/docs/alerts/new-relic-alerts/defining-conditions/scope-alert-thresholds-specific-instances).
|
|
267
|
-
:param pulumi.Input[bool] enabled: Whether the condition is enabled or not. Defaults to true.
|
|
268
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
269
|
-
:param pulumi.Input[str] entity_guid: The unique entity identifier of the condition in New Relic.
|
|
270
|
-
:param pulumi.Input[str] gc_metric: A valid Garbage Collection metric e.g. `GC/G1 Young Generation`.
|
|
271
|
-
:param pulumi.Input[str] metric: The metric field accepts parameters based on the `type` set. One of these metrics based on `type`:
|
|
272
|
-
:param pulumi.Input[str] name: The title of the condition. Must be between 1 and 64 characters, inclusive.
|
|
273
|
-
:param pulumi.Input[
|
|
274
|
-
:param pulumi.Input[str] runbook_url: Runbook URL to display in notifications.
|
|
267
|
+
:param pulumi.Input[_builtins.str] condition_scope: `application` or `instance`. Choose `application` for most scenarios. If you are using the JVM plugin in New Relic, the `instance` setting allows your condition to trigger [for specific app instances](https://docs.newrelic.com/docs/alerts/new-relic-alerts/defining-conditions/scope-alert-thresholds-specific-instances).
|
|
268
|
+
:param pulumi.Input[_builtins.bool] enabled: Whether the condition is enabled or not. Defaults to true.
|
|
269
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] entities: The instance IDs associated with this condition.
|
|
270
|
+
:param pulumi.Input[_builtins.str] entity_guid: The unique entity identifier of the condition in New Relic.
|
|
271
|
+
:param pulumi.Input[_builtins.str] gc_metric: A valid Garbage Collection metric e.g. `GC/G1 Young Generation`.
|
|
272
|
+
:param pulumi.Input[_builtins.str] metric: The metric field accepts parameters based on the `type` set. One of these metrics based on `type`:
|
|
273
|
+
:param pulumi.Input[_builtins.str] name: The title of the condition. Must be between 1 and 64 characters, inclusive.
|
|
274
|
+
:param pulumi.Input[_builtins.str] policy_id: The ID of the policy where this condition should be used.
|
|
275
|
+
:param pulumi.Input[_builtins.str] runbook_url: Runbook URL to display in notifications.
|
|
275
276
|
:param pulumi.Input[Sequence[pulumi.Input['AlertConditionTermArgs']]] terms: A list of terms for this condition. See Terms below for details.
|
|
276
|
-
:param pulumi.Input[str] type: The type of condition. One of: `apm_app_metric`, `apm_jvm_metric`, `apm_kt_metric`, `browser_metric`, `mobile_metric`
|
|
277
|
-
:param pulumi.Input[str] user_defined_metric: A custom metric to be evaluated.
|
|
278
|
-
:param pulumi.Input[str] user_defined_value_function: One of: `average`, `min`, `max`, `total`, `sample_size`, `rate` or `percent`.
|
|
277
|
+
:param pulumi.Input[_builtins.str] type: The type of condition. One of: `apm_app_metric`, `apm_jvm_metric`, `apm_kt_metric`, `browser_metric`, `mobile_metric`
|
|
278
|
+
:param pulumi.Input[_builtins.str] user_defined_metric: A custom metric to be evaluated.
|
|
279
|
+
:param pulumi.Input[_builtins.str] user_defined_value_function: One of: `average`, `min`, `max`, `total`, `sample_size`, `rate` or `percent`.
|
|
279
280
|
|
|
280
281
|
> **NOTE:** The `user_defined_value_function` can have `rate` or `percent` only when the `type` is `mobile_metric`.
|
|
281
282
|
|
|
282
|
-
<!--Start PulumiCodeChooser -->
|
|
283
|
-
```python
|
|
284
|
-
import pulumi
|
|
285
283
|
```
|
|
286
|
-
|
|
287
|
-
|
|
284
|
+
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.
|
|
285
|
+
```
|
|
286
|
+
:param pulumi.Input[_builtins.int] violation_close_timer: Automatically close instance-based incidents, including JVM health metric incidents, after the number of hours specified. Must be between 1 and 720 hours. Must be specified in the following two cases, to prevent drift:
|
|
288
287
|
* when `type` = `apm_app_metric` and `condition_scope` = `instance`
|
|
289
288
|
* when `type` = `apm_jvm_metric`
|
|
290
289
|
"""
|
|
@@ -317,115 +316,115 @@ class _AlertConditionState:
|
|
|
317
316
|
if violation_close_timer is not None:
|
|
318
317
|
pulumi.set(__self__, "violation_close_timer", violation_close_timer)
|
|
319
318
|
|
|
320
|
-
@property
|
|
319
|
+
@_builtins.property
|
|
321
320
|
@pulumi.getter(name="conditionScope")
|
|
322
|
-
def condition_scope(self) -> Optional[pulumi.Input[str]]:
|
|
321
|
+
def condition_scope(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
323
322
|
"""
|
|
324
323
|
`application` or `instance`. Choose `application` for most scenarios. If you are using the JVM plugin in New Relic, the `instance` setting allows your condition to trigger [for specific app instances](https://docs.newrelic.com/docs/alerts/new-relic-alerts/defining-conditions/scope-alert-thresholds-specific-instances).
|
|
325
324
|
"""
|
|
326
325
|
return pulumi.get(self, "condition_scope")
|
|
327
326
|
|
|
328
327
|
@condition_scope.setter
|
|
329
|
-
def condition_scope(self, value: Optional[pulumi.Input[str]]):
|
|
328
|
+
def condition_scope(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
330
329
|
pulumi.set(self, "condition_scope", value)
|
|
331
330
|
|
|
332
|
-
@property
|
|
331
|
+
@_builtins.property
|
|
333
332
|
@pulumi.getter
|
|
334
|
-
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
333
|
+
def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
335
334
|
"""
|
|
336
335
|
Whether the condition is enabled or not. Defaults to true.
|
|
337
336
|
"""
|
|
338
337
|
return pulumi.get(self, "enabled")
|
|
339
338
|
|
|
340
339
|
@enabled.setter
|
|
341
|
-
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
340
|
+
def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
342
341
|
pulumi.set(self, "enabled", value)
|
|
343
342
|
|
|
344
|
-
@property
|
|
343
|
+
@_builtins.property
|
|
345
344
|
@pulumi.getter
|
|
346
|
-
def entities(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
345
|
+
def entities(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
347
346
|
"""
|
|
348
347
|
The instance IDs associated with this condition.
|
|
349
348
|
"""
|
|
350
349
|
return pulumi.get(self, "entities")
|
|
351
350
|
|
|
352
351
|
@entities.setter
|
|
353
|
-
def entities(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
352
|
+
def entities(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
354
353
|
pulumi.set(self, "entities", value)
|
|
355
354
|
|
|
356
|
-
@property
|
|
355
|
+
@_builtins.property
|
|
357
356
|
@pulumi.getter(name="entityGuid")
|
|
358
|
-
def entity_guid(self) -> Optional[pulumi.Input[str]]:
|
|
357
|
+
def entity_guid(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
359
358
|
"""
|
|
360
359
|
The unique entity identifier of the condition in New Relic.
|
|
361
360
|
"""
|
|
362
361
|
return pulumi.get(self, "entity_guid")
|
|
363
362
|
|
|
364
363
|
@entity_guid.setter
|
|
365
|
-
def entity_guid(self, value: Optional[pulumi.Input[str]]):
|
|
364
|
+
def entity_guid(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
366
365
|
pulumi.set(self, "entity_guid", value)
|
|
367
366
|
|
|
368
|
-
@property
|
|
367
|
+
@_builtins.property
|
|
369
368
|
@pulumi.getter(name="gcMetric")
|
|
370
|
-
def gc_metric(self) -> Optional[pulumi.Input[str]]:
|
|
369
|
+
def gc_metric(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
371
370
|
"""
|
|
372
371
|
A valid Garbage Collection metric e.g. `GC/G1 Young Generation`.
|
|
373
372
|
"""
|
|
374
373
|
return pulumi.get(self, "gc_metric")
|
|
375
374
|
|
|
376
375
|
@gc_metric.setter
|
|
377
|
-
def gc_metric(self, value: Optional[pulumi.Input[str]]):
|
|
376
|
+
def gc_metric(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
378
377
|
pulumi.set(self, "gc_metric", value)
|
|
379
378
|
|
|
380
|
-
@property
|
|
379
|
+
@_builtins.property
|
|
381
380
|
@pulumi.getter
|
|
382
|
-
def metric(self) -> Optional[pulumi.Input[str]]:
|
|
381
|
+
def metric(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
383
382
|
"""
|
|
384
383
|
The metric field accepts parameters based on the `type` set. One of these metrics based on `type`:
|
|
385
384
|
"""
|
|
386
385
|
return pulumi.get(self, "metric")
|
|
387
386
|
|
|
388
387
|
@metric.setter
|
|
389
|
-
def metric(self, value: Optional[pulumi.Input[str]]):
|
|
388
|
+
def metric(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
390
389
|
pulumi.set(self, "metric", value)
|
|
391
390
|
|
|
392
|
-
@property
|
|
391
|
+
@_builtins.property
|
|
393
392
|
@pulumi.getter
|
|
394
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
393
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
395
394
|
"""
|
|
396
395
|
The title of the condition. Must be between 1 and 64 characters, inclusive.
|
|
397
396
|
"""
|
|
398
397
|
return pulumi.get(self, "name")
|
|
399
398
|
|
|
400
399
|
@name.setter
|
|
401
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
400
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
402
401
|
pulumi.set(self, "name", value)
|
|
403
402
|
|
|
404
|
-
@property
|
|
403
|
+
@_builtins.property
|
|
405
404
|
@pulumi.getter(name="policyId")
|
|
406
|
-
def policy_id(self) -> Optional[pulumi.Input[
|
|
405
|
+
def policy_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
407
406
|
"""
|
|
408
407
|
The ID of the policy where this condition should be used.
|
|
409
408
|
"""
|
|
410
409
|
return pulumi.get(self, "policy_id")
|
|
411
410
|
|
|
412
411
|
@policy_id.setter
|
|
413
|
-
def policy_id(self, value: Optional[pulumi.Input[
|
|
412
|
+
def policy_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
414
413
|
pulumi.set(self, "policy_id", value)
|
|
415
414
|
|
|
416
|
-
@property
|
|
415
|
+
@_builtins.property
|
|
417
416
|
@pulumi.getter(name="runbookUrl")
|
|
418
|
-
def runbook_url(self) -> Optional[pulumi.Input[str]]:
|
|
417
|
+
def runbook_url(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
419
418
|
"""
|
|
420
419
|
Runbook URL to display in notifications.
|
|
421
420
|
"""
|
|
422
421
|
return pulumi.get(self, "runbook_url")
|
|
423
422
|
|
|
424
423
|
@runbook_url.setter
|
|
425
|
-
def runbook_url(self, value: Optional[pulumi.Input[str]]):
|
|
424
|
+
def runbook_url(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
426
425
|
pulumi.set(self, "runbook_url", value)
|
|
427
426
|
|
|
428
|
-
@property
|
|
427
|
+
@_builtins.property
|
|
429
428
|
@pulumi.getter
|
|
430
429
|
def terms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AlertConditionTermArgs']]]]:
|
|
431
430
|
"""
|
|
@@ -437,53 +436,51 @@ class _AlertConditionState:
|
|
|
437
436
|
def terms(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AlertConditionTermArgs']]]]):
|
|
438
437
|
pulumi.set(self, "terms", value)
|
|
439
438
|
|
|
440
|
-
@property
|
|
439
|
+
@_builtins.property
|
|
441
440
|
@pulumi.getter
|
|
442
|
-
def type(self) -> Optional[pulumi.Input[str]]:
|
|
441
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
443
442
|
"""
|
|
444
443
|
The type of condition. One of: `apm_app_metric`, `apm_jvm_metric`, `apm_kt_metric`, `browser_metric`, `mobile_metric`
|
|
445
444
|
"""
|
|
446
445
|
return pulumi.get(self, "type")
|
|
447
446
|
|
|
448
447
|
@type.setter
|
|
449
|
-
def type(self, value: Optional[pulumi.Input[str]]):
|
|
448
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
450
449
|
pulumi.set(self, "type", value)
|
|
451
450
|
|
|
452
|
-
@property
|
|
451
|
+
@_builtins.property
|
|
453
452
|
@pulumi.getter(name="userDefinedMetric")
|
|
454
|
-
def user_defined_metric(self) -> Optional[pulumi.Input[str]]:
|
|
453
|
+
def user_defined_metric(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
455
454
|
"""
|
|
456
455
|
A custom metric to be evaluated.
|
|
457
456
|
"""
|
|
458
457
|
return pulumi.get(self, "user_defined_metric")
|
|
459
458
|
|
|
460
459
|
@user_defined_metric.setter
|
|
461
|
-
def user_defined_metric(self, value: Optional[pulumi.Input[str]]):
|
|
460
|
+
def user_defined_metric(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
462
461
|
pulumi.set(self, "user_defined_metric", value)
|
|
463
462
|
|
|
464
|
-
@property
|
|
463
|
+
@_builtins.property
|
|
465
464
|
@pulumi.getter(name="userDefinedValueFunction")
|
|
466
|
-
def user_defined_value_function(self) -> Optional[pulumi.Input[str]]:
|
|
465
|
+
def user_defined_value_function(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
467
466
|
"""
|
|
468
467
|
One of: `average`, `min`, `max`, `total`, `sample_size`, `rate` or `percent`.
|
|
469
468
|
|
|
470
469
|
> **NOTE:** The `user_defined_value_function` can have `rate` or `percent` only when the `type` is `mobile_metric`.
|
|
471
470
|
|
|
472
|
-
<!--Start PulumiCodeChooser -->
|
|
473
|
-
```python
|
|
474
|
-
import pulumi
|
|
475
471
|
```
|
|
476
|
-
|
|
472
|
+
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.
|
|
473
|
+
```
|
|
477
474
|
"""
|
|
478
475
|
return pulumi.get(self, "user_defined_value_function")
|
|
479
476
|
|
|
480
477
|
@user_defined_value_function.setter
|
|
481
|
-
def user_defined_value_function(self, value: Optional[pulumi.Input[str]]):
|
|
478
|
+
def user_defined_value_function(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
482
479
|
pulumi.set(self, "user_defined_value_function", value)
|
|
483
480
|
|
|
484
|
-
@property
|
|
481
|
+
@_builtins.property
|
|
485
482
|
@pulumi.getter(name="violationCloseTimer")
|
|
486
|
-
def violation_close_timer(self) -> Optional[pulumi.Input[int]]:
|
|
483
|
+
def violation_close_timer(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
487
484
|
"""
|
|
488
485
|
Automatically close instance-based incidents, including JVM health metric incidents, after the number of hours specified. Must be between 1 and 720 hours. Must be specified in the following two cases, to prevent drift:
|
|
489
486
|
* when `type` = `apm_app_metric` and `condition_scope` = `instance`
|
|
@@ -492,28 +489,29 @@ class _AlertConditionState:
|
|
|
492
489
|
return pulumi.get(self, "violation_close_timer")
|
|
493
490
|
|
|
494
491
|
@violation_close_timer.setter
|
|
495
|
-
def violation_close_timer(self, value: Optional[pulumi.Input[int]]):
|
|
492
|
+
def violation_close_timer(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
496
493
|
pulumi.set(self, "violation_close_timer", value)
|
|
497
494
|
|
|
498
495
|
|
|
496
|
+
@pulumi.type_token("newrelic:index/alertCondition:AlertCondition")
|
|
499
497
|
class AlertCondition(pulumi.CustomResource):
|
|
500
498
|
@overload
|
|
501
499
|
def __init__(__self__,
|
|
502
500
|
resource_name: str,
|
|
503
501
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
504
|
-
condition_scope: Optional[pulumi.Input[str]] = None,
|
|
505
|
-
enabled: Optional[pulumi.Input[bool]] = None,
|
|
506
|
-
entities: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
507
|
-
gc_metric: Optional[pulumi.Input[str]] = None,
|
|
508
|
-
metric: Optional[pulumi.Input[str]] = None,
|
|
509
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
510
|
-
policy_id: Optional[pulumi.Input[
|
|
511
|
-
runbook_url: Optional[pulumi.Input[str]] = None,
|
|
512
|
-
terms: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
513
|
-
type: Optional[pulumi.Input[str]] = None,
|
|
514
|
-
user_defined_metric: Optional[pulumi.Input[str]] = None,
|
|
515
|
-
user_defined_value_function: Optional[pulumi.Input[str]] = None,
|
|
516
|
-
violation_close_timer: Optional[pulumi.Input[int]] = None,
|
|
502
|
+
condition_scope: Optional[pulumi.Input[_builtins.str]] = None,
|
|
503
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
504
|
+
entities: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
505
|
+
gc_metric: Optional[pulumi.Input[_builtins.str]] = None,
|
|
506
|
+
metric: Optional[pulumi.Input[_builtins.str]] = None,
|
|
507
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
508
|
+
policy_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
509
|
+
runbook_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
510
|
+
terms: Optional[pulumi.Input[Sequence[pulumi.Input[Union['AlertConditionTermArgs', 'AlertConditionTermArgsDict']]]]] = None,
|
|
511
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
512
|
+
user_defined_metric: Optional[pulumi.Input[_builtins.str]] = None,
|
|
513
|
+
user_defined_value_function: Optional[pulumi.Input[_builtins.str]] = None,
|
|
514
|
+
violation_close_timer: Optional[pulumi.Input[_builtins.int]] = None,
|
|
517
515
|
__props__=None):
|
|
518
516
|
"""
|
|
519
517
|
Use this resource to create and manage alert conditions for APM, Browser, and Mobile in New Relic.
|
|
@@ -522,7 +520,6 @@ class AlertCondition(pulumi.CustomResource):
|
|
|
522
520
|
|
|
523
521
|
## Example Usage
|
|
524
522
|
|
|
525
|
-
<!--Start PulumiCodeChooser -->
|
|
526
523
|
```python
|
|
527
524
|
import pulumi
|
|
528
525
|
import pulumi_newrelic as newrelic
|
|
@@ -530,23 +527,23 @@ class AlertCondition(pulumi.CustomResource):
|
|
|
530
527
|
app = newrelic.get_entity(name="my-app",
|
|
531
528
|
type="APPLICATION",
|
|
532
529
|
domain="APM")
|
|
533
|
-
|
|
534
|
-
foo_alert_condition = newrelic.AlertCondition("
|
|
535
|
-
policy_id=
|
|
530
|
+
foo = newrelic.AlertPolicy("foo", name="foo")
|
|
531
|
+
foo_alert_condition = newrelic.AlertCondition("foo",
|
|
532
|
+
policy_id=foo.id,
|
|
533
|
+
name="foo",
|
|
536
534
|
type="apm_app_metric",
|
|
537
535
|
entities=[app.application_id],
|
|
538
536
|
metric="apdex",
|
|
539
537
|
runbook_url="https://www.example.com",
|
|
540
538
|
condition_scope="application",
|
|
541
|
-
terms=[
|
|
542
|
-
duration
|
|
543
|
-
operator
|
|
544
|
-
priority
|
|
545
|
-
threshold
|
|
546
|
-
time_function
|
|
547
|
-
|
|
539
|
+
terms=[{
|
|
540
|
+
"duration": 5,
|
|
541
|
+
"operator": "below",
|
|
542
|
+
"priority": "critical",
|
|
543
|
+
"threshold": 0.75,
|
|
544
|
+
"time_function": "all",
|
|
545
|
+
}])
|
|
548
546
|
```
|
|
549
|
-
<!--End PulumiCodeChooser -->
|
|
550
547
|
|
|
551
548
|
## Terms
|
|
552
549
|
|
|
@@ -562,44 +559,43 @@ class AlertCondition(pulumi.CustomResource):
|
|
|
562
559
|
|
|
563
560
|
Manage alert condition tags with `EntityTags`. For up-to-date documentation about the tagging resource, please check EntityTags
|
|
564
561
|
|
|
565
|
-
<!--Start PulumiCodeChooser -->
|
|
566
562
|
```python
|
|
567
563
|
import pulumi
|
|
568
564
|
import pulumi_newrelic as newrelic
|
|
569
565
|
|
|
570
|
-
|
|
571
|
-
foo_alert_policy = newrelic.AlertPolicy("
|
|
572
|
-
foo_alert_condition = newrelic.AlertCondition("
|
|
566
|
+
foo = newrelic.get_entity(name="foo entitiy")
|
|
567
|
+
foo_alert_policy = newrelic.AlertPolicy("foo", name="foo policy")
|
|
568
|
+
foo_alert_condition = newrelic.AlertCondition("foo",
|
|
573
569
|
policy_id=foo_alert_policy.id,
|
|
570
|
+
name="foo condition",
|
|
574
571
|
type="apm_app_metric",
|
|
575
|
-
entities=[
|
|
572
|
+
entities=[foo.application_id],
|
|
576
573
|
metric="apdex",
|
|
577
574
|
runbook_url="https://www.example.com",
|
|
578
575
|
condition_scope="application",
|
|
579
|
-
terms=[
|
|
580
|
-
duration
|
|
581
|
-
operator
|
|
582
|
-
priority
|
|
583
|
-
threshold
|
|
584
|
-
time_function
|
|
585
|
-
|
|
586
|
-
my_condition_entity_tags = newrelic.EntityTags("
|
|
576
|
+
terms=[{
|
|
577
|
+
"duration": 5,
|
|
578
|
+
"operator": "below",
|
|
579
|
+
"priority": "critical",
|
|
580
|
+
"threshold": 0.75,
|
|
581
|
+
"time_function": "all",
|
|
582
|
+
}])
|
|
583
|
+
my_condition_entity_tags = newrelic.EntityTags("my_condition_entity_tags",
|
|
587
584
|
guid=foo_alert_condition.entity_guid,
|
|
588
585
|
tags=[
|
|
589
|
-
|
|
590
|
-
key
|
|
591
|
-
values
|
|
586
|
+
{
|
|
587
|
+
"key": "my-key",
|
|
588
|
+
"values": [
|
|
592
589
|
"my-value",
|
|
593
590
|
"my-other-value",
|
|
594
591
|
],
|
|
595
|
-
|
|
596
|
-
|
|
597
|
-
key
|
|
598
|
-
values
|
|
599
|
-
|
|
592
|
+
},
|
|
593
|
+
{
|
|
594
|
+
"key": "my-key-2",
|
|
595
|
+
"values": ["my-value-2"],
|
|
596
|
+
},
|
|
600
597
|
])
|
|
601
598
|
```
|
|
602
|
-
<!--End PulumiCodeChooser -->
|
|
603
599
|
|
|
604
600
|
## Import
|
|
605
601
|
|
|
@@ -611,27 +607,25 @@ class AlertCondition(pulumi.CustomResource):
|
|
|
611
607
|
|
|
612
608
|
:param str resource_name: The name of the resource.
|
|
613
609
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
614
|
-
:param pulumi.Input[str] condition_scope: `application` or `instance`. Choose `application` for most scenarios. If you are using the JVM plugin in New Relic, the `instance` setting allows your condition to trigger [for specific app instances](https://docs.newrelic.com/docs/alerts/new-relic-alerts/defining-conditions/scope-alert-thresholds-specific-instances).
|
|
615
|
-
:param pulumi.Input[bool] enabled: Whether the condition is enabled or not. Defaults to true.
|
|
616
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
617
|
-
:param pulumi.Input[str] gc_metric: A valid Garbage Collection metric e.g. `GC/G1 Young Generation`.
|
|
618
|
-
:param pulumi.Input[str] metric: The metric field accepts parameters based on the `type` set. One of these metrics based on `type`:
|
|
619
|
-
:param pulumi.Input[str] name: The title of the condition. Must be between 1 and 64 characters, inclusive.
|
|
620
|
-
:param pulumi.Input[
|
|
621
|
-
:param pulumi.Input[str] runbook_url: Runbook URL to display in notifications.
|
|
622
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
623
|
-
:param pulumi.Input[str] type: The type of condition. One of: `apm_app_metric`, `apm_jvm_metric`, `apm_kt_metric`, `browser_metric`, `mobile_metric`
|
|
624
|
-
:param pulumi.Input[str] user_defined_metric: A custom metric to be evaluated.
|
|
625
|
-
:param pulumi.Input[str] user_defined_value_function: One of: `average`, `min`, `max`, `total`, `sample_size`, `rate` or `percent`.
|
|
610
|
+
:param pulumi.Input[_builtins.str] condition_scope: `application` or `instance`. Choose `application` for most scenarios. If you are using the JVM plugin in New Relic, the `instance` setting allows your condition to trigger [for specific app instances](https://docs.newrelic.com/docs/alerts/new-relic-alerts/defining-conditions/scope-alert-thresholds-specific-instances).
|
|
611
|
+
:param pulumi.Input[_builtins.bool] enabled: Whether the condition is enabled or not. Defaults to true.
|
|
612
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] entities: The instance IDs associated with this condition.
|
|
613
|
+
:param pulumi.Input[_builtins.str] gc_metric: A valid Garbage Collection metric e.g. `GC/G1 Young Generation`.
|
|
614
|
+
:param pulumi.Input[_builtins.str] metric: The metric field accepts parameters based on the `type` set. One of these metrics based on `type`:
|
|
615
|
+
:param pulumi.Input[_builtins.str] name: The title of the condition. Must be between 1 and 64 characters, inclusive.
|
|
616
|
+
:param pulumi.Input[_builtins.str] policy_id: The ID of the policy where this condition should be used.
|
|
617
|
+
:param pulumi.Input[_builtins.str] runbook_url: Runbook URL to display in notifications.
|
|
618
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['AlertConditionTermArgs', 'AlertConditionTermArgsDict']]]] terms: A list of terms for this condition. See Terms below for details.
|
|
619
|
+
:param pulumi.Input[_builtins.str] type: The type of condition. One of: `apm_app_metric`, `apm_jvm_metric`, `apm_kt_metric`, `browser_metric`, `mobile_metric`
|
|
620
|
+
:param pulumi.Input[_builtins.str] user_defined_metric: A custom metric to be evaluated.
|
|
621
|
+
:param pulumi.Input[_builtins.str] user_defined_value_function: One of: `average`, `min`, `max`, `total`, `sample_size`, `rate` or `percent`.
|
|
626
622
|
|
|
627
623
|
> **NOTE:** The `user_defined_value_function` can have `rate` or `percent` only when the `type` is `mobile_metric`.
|
|
628
624
|
|
|
629
|
-
<!--Start PulumiCodeChooser -->
|
|
630
|
-
```python
|
|
631
|
-
import pulumi
|
|
632
625
|
```
|
|
633
|
-
|
|
634
|
-
|
|
626
|
+
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.
|
|
627
|
+
```
|
|
628
|
+
:param pulumi.Input[_builtins.int] violation_close_timer: Automatically close instance-based incidents, including JVM health metric incidents, after the number of hours specified. Must be between 1 and 720 hours. Must be specified in the following two cases, to prevent drift:
|
|
635
629
|
* when `type` = `apm_app_metric` and `condition_scope` = `instance`
|
|
636
630
|
* when `type` = `apm_jvm_metric`
|
|
637
631
|
"""
|
|
@@ -648,7 +642,6 @@ class AlertCondition(pulumi.CustomResource):
|
|
|
648
642
|
|
|
649
643
|
## Example Usage
|
|
650
644
|
|
|
651
|
-
<!--Start PulumiCodeChooser -->
|
|
652
645
|
```python
|
|
653
646
|
import pulumi
|
|
654
647
|
import pulumi_newrelic as newrelic
|
|
@@ -656,23 +649,23 @@ class AlertCondition(pulumi.CustomResource):
|
|
|
656
649
|
app = newrelic.get_entity(name="my-app",
|
|
657
650
|
type="APPLICATION",
|
|
658
651
|
domain="APM")
|
|
659
|
-
|
|
660
|
-
foo_alert_condition = newrelic.AlertCondition("
|
|
661
|
-
policy_id=
|
|
652
|
+
foo = newrelic.AlertPolicy("foo", name="foo")
|
|
653
|
+
foo_alert_condition = newrelic.AlertCondition("foo",
|
|
654
|
+
policy_id=foo.id,
|
|
655
|
+
name="foo",
|
|
662
656
|
type="apm_app_metric",
|
|
663
657
|
entities=[app.application_id],
|
|
664
658
|
metric="apdex",
|
|
665
659
|
runbook_url="https://www.example.com",
|
|
666
660
|
condition_scope="application",
|
|
667
|
-
terms=[
|
|
668
|
-
duration
|
|
669
|
-
operator
|
|
670
|
-
priority
|
|
671
|
-
threshold
|
|
672
|
-
time_function
|
|
673
|
-
|
|
661
|
+
terms=[{
|
|
662
|
+
"duration": 5,
|
|
663
|
+
"operator": "below",
|
|
664
|
+
"priority": "critical",
|
|
665
|
+
"threshold": 0.75,
|
|
666
|
+
"time_function": "all",
|
|
667
|
+
}])
|
|
674
668
|
```
|
|
675
|
-
<!--End PulumiCodeChooser -->
|
|
676
669
|
|
|
677
670
|
## Terms
|
|
678
671
|
|
|
@@ -688,44 +681,43 @@ class AlertCondition(pulumi.CustomResource):
|
|
|
688
681
|
|
|
689
682
|
Manage alert condition tags with `EntityTags`. For up-to-date documentation about the tagging resource, please check EntityTags
|
|
690
683
|
|
|
691
|
-
<!--Start PulumiCodeChooser -->
|
|
692
684
|
```python
|
|
693
685
|
import pulumi
|
|
694
686
|
import pulumi_newrelic as newrelic
|
|
695
687
|
|
|
696
|
-
|
|
697
|
-
foo_alert_policy = newrelic.AlertPolicy("
|
|
698
|
-
foo_alert_condition = newrelic.AlertCondition("
|
|
688
|
+
foo = newrelic.get_entity(name="foo entitiy")
|
|
689
|
+
foo_alert_policy = newrelic.AlertPolicy("foo", name="foo policy")
|
|
690
|
+
foo_alert_condition = newrelic.AlertCondition("foo",
|
|
699
691
|
policy_id=foo_alert_policy.id,
|
|
692
|
+
name="foo condition",
|
|
700
693
|
type="apm_app_metric",
|
|
701
|
-
entities=[
|
|
694
|
+
entities=[foo.application_id],
|
|
702
695
|
metric="apdex",
|
|
703
696
|
runbook_url="https://www.example.com",
|
|
704
697
|
condition_scope="application",
|
|
705
|
-
terms=[
|
|
706
|
-
duration
|
|
707
|
-
operator
|
|
708
|
-
priority
|
|
709
|
-
threshold
|
|
710
|
-
time_function
|
|
711
|
-
|
|
712
|
-
my_condition_entity_tags = newrelic.EntityTags("
|
|
698
|
+
terms=[{
|
|
699
|
+
"duration": 5,
|
|
700
|
+
"operator": "below",
|
|
701
|
+
"priority": "critical",
|
|
702
|
+
"threshold": 0.75,
|
|
703
|
+
"time_function": "all",
|
|
704
|
+
}])
|
|
705
|
+
my_condition_entity_tags = newrelic.EntityTags("my_condition_entity_tags",
|
|
713
706
|
guid=foo_alert_condition.entity_guid,
|
|
714
707
|
tags=[
|
|
715
|
-
|
|
716
|
-
key
|
|
717
|
-
values
|
|
708
|
+
{
|
|
709
|
+
"key": "my-key",
|
|
710
|
+
"values": [
|
|
718
711
|
"my-value",
|
|
719
712
|
"my-other-value",
|
|
720
713
|
],
|
|
721
|
-
|
|
722
|
-
|
|
723
|
-
key
|
|
724
|
-
values
|
|
725
|
-
|
|
714
|
+
},
|
|
715
|
+
{
|
|
716
|
+
"key": "my-key-2",
|
|
717
|
+
"values": ["my-value-2"],
|
|
718
|
+
},
|
|
726
719
|
])
|
|
727
720
|
```
|
|
728
|
-
<!--End PulumiCodeChooser -->
|
|
729
721
|
|
|
730
722
|
## Import
|
|
731
723
|
|
|
@@ -750,19 +742,19 @@ class AlertCondition(pulumi.CustomResource):
|
|
|
750
742
|
def _internal_init(__self__,
|
|
751
743
|
resource_name: str,
|
|
752
744
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
753
|
-
condition_scope: Optional[pulumi.Input[str]] = None,
|
|
754
|
-
enabled: Optional[pulumi.Input[bool]] = None,
|
|
755
|
-
entities: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
756
|
-
gc_metric: Optional[pulumi.Input[str]] = None,
|
|
757
|
-
metric: Optional[pulumi.Input[str]] = None,
|
|
758
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
759
|
-
policy_id: Optional[pulumi.Input[
|
|
760
|
-
runbook_url: Optional[pulumi.Input[str]] = None,
|
|
761
|
-
terms: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
762
|
-
type: Optional[pulumi.Input[str]] = None,
|
|
763
|
-
user_defined_metric: Optional[pulumi.Input[str]] = None,
|
|
764
|
-
user_defined_value_function: Optional[pulumi.Input[str]] = None,
|
|
765
|
-
violation_close_timer: Optional[pulumi.Input[int]] = None,
|
|
745
|
+
condition_scope: Optional[pulumi.Input[_builtins.str]] = None,
|
|
746
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
747
|
+
entities: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
748
|
+
gc_metric: Optional[pulumi.Input[_builtins.str]] = None,
|
|
749
|
+
metric: Optional[pulumi.Input[_builtins.str]] = None,
|
|
750
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
751
|
+
policy_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
752
|
+
runbook_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
753
|
+
terms: Optional[pulumi.Input[Sequence[pulumi.Input[Union['AlertConditionTermArgs', 'AlertConditionTermArgsDict']]]]] = None,
|
|
754
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
755
|
+
user_defined_metric: Optional[pulumi.Input[_builtins.str]] = None,
|
|
756
|
+
user_defined_value_function: Optional[pulumi.Input[_builtins.str]] = None,
|
|
757
|
+
violation_close_timer: Optional[pulumi.Input[_builtins.int]] = None,
|
|
766
758
|
__props__=None):
|
|
767
759
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
768
760
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -806,20 +798,20 @@ class AlertCondition(pulumi.CustomResource):
|
|
|
806
798
|
def get(resource_name: str,
|
|
807
799
|
id: pulumi.Input[str],
|
|
808
800
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
809
|
-
condition_scope: Optional[pulumi.Input[str]] = None,
|
|
810
|
-
enabled: Optional[pulumi.Input[bool]] = None,
|
|
811
|
-
entities: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
812
|
-
entity_guid: Optional[pulumi.Input[str]] = None,
|
|
813
|
-
gc_metric: Optional[pulumi.Input[str]] = None,
|
|
814
|
-
metric: Optional[pulumi.Input[str]] = None,
|
|
815
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
816
|
-
policy_id: Optional[pulumi.Input[
|
|
817
|
-
runbook_url: Optional[pulumi.Input[str]] = None,
|
|
818
|
-
terms: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
819
|
-
type: Optional[pulumi.Input[str]] = None,
|
|
820
|
-
user_defined_metric: Optional[pulumi.Input[str]] = None,
|
|
821
|
-
user_defined_value_function: Optional[pulumi.Input[str]] = None,
|
|
822
|
-
violation_close_timer: Optional[pulumi.Input[int]] = None) -> 'AlertCondition':
|
|
801
|
+
condition_scope: Optional[pulumi.Input[_builtins.str]] = None,
|
|
802
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
803
|
+
entities: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
804
|
+
entity_guid: Optional[pulumi.Input[_builtins.str]] = None,
|
|
805
|
+
gc_metric: Optional[pulumi.Input[_builtins.str]] = None,
|
|
806
|
+
metric: Optional[pulumi.Input[_builtins.str]] = None,
|
|
807
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
808
|
+
policy_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
809
|
+
runbook_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
810
|
+
terms: Optional[pulumi.Input[Sequence[pulumi.Input[Union['AlertConditionTermArgs', 'AlertConditionTermArgsDict']]]]] = None,
|
|
811
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
812
|
+
user_defined_metric: Optional[pulumi.Input[_builtins.str]] = None,
|
|
813
|
+
user_defined_value_function: Optional[pulumi.Input[_builtins.str]] = None,
|
|
814
|
+
violation_close_timer: Optional[pulumi.Input[_builtins.int]] = None) -> 'AlertCondition':
|
|
823
815
|
"""
|
|
824
816
|
Get an existing AlertCondition resource's state with the given name, id, and optional extra
|
|
825
817
|
properties used to qualify the lookup.
|
|
@@ -827,28 +819,26 @@ class AlertCondition(pulumi.CustomResource):
|
|
|
827
819
|
:param str resource_name: The unique name of the resulting resource.
|
|
828
820
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
829
821
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
830
|
-
:param pulumi.Input[str] condition_scope: `application` or `instance`. Choose `application` for most scenarios. If you are using the JVM plugin in New Relic, the `instance` setting allows your condition to trigger [for specific app instances](https://docs.newrelic.com/docs/alerts/new-relic-alerts/defining-conditions/scope-alert-thresholds-specific-instances).
|
|
831
|
-
:param pulumi.Input[bool] enabled: Whether the condition is enabled or not. Defaults to true.
|
|
832
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
833
|
-
:param pulumi.Input[str] entity_guid: The unique entity identifier of the condition in New Relic.
|
|
834
|
-
:param pulumi.Input[str] gc_metric: A valid Garbage Collection metric e.g. `GC/G1 Young Generation`.
|
|
835
|
-
:param pulumi.Input[str] metric: The metric field accepts parameters based on the `type` set. One of these metrics based on `type`:
|
|
836
|
-
:param pulumi.Input[str] name: The title of the condition. Must be between 1 and 64 characters, inclusive.
|
|
837
|
-
:param pulumi.Input[
|
|
838
|
-
:param pulumi.Input[str] runbook_url: Runbook URL to display in notifications.
|
|
839
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
840
|
-
:param pulumi.Input[str] type: The type of condition. One of: `apm_app_metric`, `apm_jvm_metric`, `apm_kt_metric`, `browser_metric`, `mobile_metric`
|
|
841
|
-
:param pulumi.Input[str] user_defined_metric: A custom metric to be evaluated.
|
|
842
|
-
:param pulumi.Input[str] user_defined_value_function: One of: `average`, `min`, `max`, `total`, `sample_size`, `rate` or `percent`.
|
|
822
|
+
:param pulumi.Input[_builtins.str] condition_scope: `application` or `instance`. Choose `application` for most scenarios. If you are using the JVM plugin in New Relic, the `instance` setting allows your condition to trigger [for specific app instances](https://docs.newrelic.com/docs/alerts/new-relic-alerts/defining-conditions/scope-alert-thresholds-specific-instances).
|
|
823
|
+
:param pulumi.Input[_builtins.bool] enabled: Whether the condition is enabled or not. Defaults to true.
|
|
824
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] entities: The instance IDs associated with this condition.
|
|
825
|
+
:param pulumi.Input[_builtins.str] entity_guid: The unique entity identifier of the condition in New Relic.
|
|
826
|
+
:param pulumi.Input[_builtins.str] gc_metric: A valid Garbage Collection metric e.g. `GC/G1 Young Generation`.
|
|
827
|
+
:param pulumi.Input[_builtins.str] metric: The metric field accepts parameters based on the `type` set. One of these metrics based on `type`:
|
|
828
|
+
:param pulumi.Input[_builtins.str] name: The title of the condition. Must be between 1 and 64 characters, inclusive.
|
|
829
|
+
:param pulumi.Input[_builtins.str] policy_id: The ID of the policy where this condition should be used.
|
|
830
|
+
:param pulumi.Input[_builtins.str] runbook_url: Runbook URL to display in notifications.
|
|
831
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['AlertConditionTermArgs', 'AlertConditionTermArgsDict']]]] terms: A list of terms for this condition. See Terms below for details.
|
|
832
|
+
:param pulumi.Input[_builtins.str] type: The type of condition. One of: `apm_app_metric`, `apm_jvm_metric`, `apm_kt_metric`, `browser_metric`, `mobile_metric`
|
|
833
|
+
:param pulumi.Input[_builtins.str] user_defined_metric: A custom metric to be evaluated.
|
|
834
|
+
:param pulumi.Input[_builtins.str] user_defined_value_function: One of: `average`, `min`, `max`, `total`, `sample_size`, `rate` or `percent`.
|
|
843
835
|
|
|
844
836
|
> **NOTE:** The `user_defined_value_function` can have `rate` or `percent` only when the `type` is `mobile_metric`.
|
|
845
837
|
|
|
846
|
-
<!--Start PulumiCodeChooser -->
|
|
847
|
-
```python
|
|
848
|
-
import pulumi
|
|
849
838
|
```
|
|
850
|
-
|
|
851
|
-
|
|
839
|
+
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.
|
|
840
|
+
```
|
|
841
|
+
:param pulumi.Input[_builtins.int] violation_close_timer: Automatically close instance-based incidents, including JVM health metric incidents, after the number of hours specified. Must be between 1 and 720 hours. Must be specified in the following two cases, to prevent drift:
|
|
852
842
|
* when `type` = `apm_app_metric` and `condition_scope` = `instance`
|
|
853
843
|
* when `type` = `apm_jvm_metric`
|
|
854
844
|
"""
|
|
@@ -872,79 +862,79 @@ class AlertCondition(pulumi.CustomResource):
|
|
|
872
862
|
__props__.__dict__["violation_close_timer"] = violation_close_timer
|
|
873
863
|
return AlertCondition(resource_name, opts=opts, __props__=__props__)
|
|
874
864
|
|
|
875
|
-
@property
|
|
865
|
+
@_builtins.property
|
|
876
866
|
@pulumi.getter(name="conditionScope")
|
|
877
|
-
def condition_scope(self) -> pulumi.Output[Optional[str]]:
|
|
867
|
+
def condition_scope(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
878
868
|
"""
|
|
879
869
|
`application` or `instance`. Choose `application` for most scenarios. If you are using the JVM plugin in New Relic, the `instance` setting allows your condition to trigger [for specific app instances](https://docs.newrelic.com/docs/alerts/new-relic-alerts/defining-conditions/scope-alert-thresholds-specific-instances).
|
|
880
870
|
"""
|
|
881
871
|
return pulumi.get(self, "condition_scope")
|
|
882
872
|
|
|
883
|
-
@property
|
|
873
|
+
@_builtins.property
|
|
884
874
|
@pulumi.getter
|
|
885
|
-
def enabled(self) -> pulumi.Output[Optional[bool]]:
|
|
875
|
+
def enabled(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
886
876
|
"""
|
|
887
877
|
Whether the condition is enabled or not. Defaults to true.
|
|
888
878
|
"""
|
|
889
879
|
return pulumi.get(self, "enabled")
|
|
890
880
|
|
|
891
|
-
@property
|
|
881
|
+
@_builtins.property
|
|
892
882
|
@pulumi.getter
|
|
893
|
-
def entities(self) -> pulumi.Output[Sequence[
|
|
883
|
+
def entities(self) -> pulumi.Output[Sequence[_builtins.str]]:
|
|
894
884
|
"""
|
|
895
885
|
The instance IDs associated with this condition.
|
|
896
886
|
"""
|
|
897
887
|
return pulumi.get(self, "entities")
|
|
898
888
|
|
|
899
|
-
@property
|
|
889
|
+
@_builtins.property
|
|
900
890
|
@pulumi.getter(name="entityGuid")
|
|
901
|
-
def entity_guid(self) -> pulumi.Output[str]:
|
|
891
|
+
def entity_guid(self) -> pulumi.Output[_builtins.str]:
|
|
902
892
|
"""
|
|
903
893
|
The unique entity identifier of the condition in New Relic.
|
|
904
894
|
"""
|
|
905
895
|
return pulumi.get(self, "entity_guid")
|
|
906
896
|
|
|
907
|
-
@property
|
|
897
|
+
@_builtins.property
|
|
908
898
|
@pulumi.getter(name="gcMetric")
|
|
909
|
-
def gc_metric(self) -> pulumi.Output[Optional[str]]:
|
|
899
|
+
def gc_metric(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
910
900
|
"""
|
|
911
901
|
A valid Garbage Collection metric e.g. `GC/G1 Young Generation`.
|
|
912
902
|
"""
|
|
913
903
|
return pulumi.get(self, "gc_metric")
|
|
914
904
|
|
|
915
|
-
@property
|
|
905
|
+
@_builtins.property
|
|
916
906
|
@pulumi.getter
|
|
917
|
-
def metric(self) -> pulumi.Output[str]:
|
|
907
|
+
def metric(self) -> pulumi.Output[_builtins.str]:
|
|
918
908
|
"""
|
|
919
909
|
The metric field accepts parameters based on the `type` set. One of these metrics based on `type`:
|
|
920
910
|
"""
|
|
921
911
|
return pulumi.get(self, "metric")
|
|
922
912
|
|
|
923
|
-
@property
|
|
913
|
+
@_builtins.property
|
|
924
914
|
@pulumi.getter
|
|
925
|
-
def name(self) -> pulumi.Output[str]:
|
|
915
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
926
916
|
"""
|
|
927
917
|
The title of the condition. Must be between 1 and 64 characters, inclusive.
|
|
928
918
|
"""
|
|
929
919
|
return pulumi.get(self, "name")
|
|
930
920
|
|
|
931
|
-
@property
|
|
921
|
+
@_builtins.property
|
|
932
922
|
@pulumi.getter(name="policyId")
|
|
933
|
-
def policy_id(self) -> pulumi.Output[
|
|
923
|
+
def policy_id(self) -> pulumi.Output[_builtins.str]:
|
|
934
924
|
"""
|
|
935
925
|
The ID of the policy where this condition should be used.
|
|
936
926
|
"""
|
|
937
927
|
return pulumi.get(self, "policy_id")
|
|
938
928
|
|
|
939
|
-
@property
|
|
929
|
+
@_builtins.property
|
|
940
930
|
@pulumi.getter(name="runbookUrl")
|
|
941
|
-
def runbook_url(self) -> pulumi.Output[Optional[str]]:
|
|
931
|
+
def runbook_url(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
942
932
|
"""
|
|
943
933
|
Runbook URL to display in notifications.
|
|
944
934
|
"""
|
|
945
935
|
return pulumi.get(self, "runbook_url")
|
|
946
936
|
|
|
947
|
-
@property
|
|
937
|
+
@_builtins.property
|
|
948
938
|
@pulumi.getter
|
|
949
939
|
def terms(self) -> pulumi.Output[Sequence['outputs.AlertConditionTerm']]:
|
|
950
940
|
"""
|
|
@@ -952,41 +942,39 @@ class AlertCondition(pulumi.CustomResource):
|
|
|
952
942
|
"""
|
|
953
943
|
return pulumi.get(self, "terms")
|
|
954
944
|
|
|
955
|
-
@property
|
|
945
|
+
@_builtins.property
|
|
956
946
|
@pulumi.getter
|
|
957
|
-
def type(self) -> pulumi.Output[str]:
|
|
947
|
+
def type(self) -> pulumi.Output[_builtins.str]:
|
|
958
948
|
"""
|
|
959
949
|
The type of condition. One of: `apm_app_metric`, `apm_jvm_metric`, `apm_kt_metric`, `browser_metric`, `mobile_metric`
|
|
960
950
|
"""
|
|
961
951
|
return pulumi.get(self, "type")
|
|
962
952
|
|
|
963
|
-
@property
|
|
953
|
+
@_builtins.property
|
|
964
954
|
@pulumi.getter(name="userDefinedMetric")
|
|
965
|
-
def user_defined_metric(self) -> pulumi.Output[Optional[str]]:
|
|
955
|
+
def user_defined_metric(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
966
956
|
"""
|
|
967
957
|
A custom metric to be evaluated.
|
|
968
958
|
"""
|
|
969
959
|
return pulumi.get(self, "user_defined_metric")
|
|
970
960
|
|
|
971
|
-
@property
|
|
961
|
+
@_builtins.property
|
|
972
962
|
@pulumi.getter(name="userDefinedValueFunction")
|
|
973
|
-
def user_defined_value_function(self) -> pulumi.Output[Optional[str]]:
|
|
963
|
+
def user_defined_value_function(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
974
964
|
"""
|
|
975
965
|
One of: `average`, `min`, `max`, `total`, `sample_size`, `rate` or `percent`.
|
|
976
966
|
|
|
977
967
|
> **NOTE:** The `user_defined_value_function` can have `rate` or `percent` only when the `type` is `mobile_metric`.
|
|
978
968
|
|
|
979
|
-
<!--Start PulumiCodeChooser -->
|
|
980
|
-
```python
|
|
981
|
-
import pulumi
|
|
982
969
|
```
|
|
983
|
-
|
|
970
|
+
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.
|
|
971
|
+
```
|
|
984
972
|
"""
|
|
985
973
|
return pulumi.get(self, "user_defined_value_function")
|
|
986
974
|
|
|
987
|
-
@property
|
|
975
|
+
@_builtins.property
|
|
988
976
|
@pulumi.getter(name="violationCloseTimer")
|
|
989
|
-
def violation_close_timer(self) -> pulumi.Output[Optional[int]]:
|
|
977
|
+
def violation_close_timer(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
990
978
|
"""
|
|
991
979
|
Automatically close instance-based incidents, including JVM health metric incidents, after the number of hours specified. Must be between 1 and 720 hours. Must be specified in the following two cases, to prevent drift:
|
|
992
980
|
* when `type` = `apm_app_metric` and `condition_scope` = `instance`
|