pulumi-newrelic 5.40.0a1738908234__py3-none-any.whl → 5.41.0__py3-none-any.whl
Sign up to get free protection for your applications and to get access to all the features.
- pulumi_newrelic/_inputs.py +222 -0
- pulumi_newrelic/_utilities.py +8 -4
- pulumi_newrelic/cloud/aws_govcloud_link_account.py +76 -172
- pulumi_newrelic/nrql_alert_condition.py +24 -0
- pulumi_newrelic/outputs.py +189 -0
- pulumi_newrelic/pulumi-plugin.json +1 -1
- {pulumi_newrelic-5.40.0a1738908234.dist-info → pulumi_newrelic-5.41.0.dist-info}/METADATA +1 -1
- {pulumi_newrelic-5.40.0a1738908234.dist-info → pulumi_newrelic-5.41.0.dist-info}/RECORD +10 -10
- {pulumi_newrelic-5.40.0a1738908234.dist-info → pulumi_newrelic-5.41.0.dist-info}/WHEEL +0 -0
- {pulumi_newrelic-5.40.0a1738908234.dist-info → pulumi_newrelic-5.41.0.dist-info}/top_level.txt +0 -0
pulumi_newrelic/_inputs.py
CHANGED
|
@@ -51,12 +51,18 @@ __all__ = [
|
|
|
51
51
|
'NotificationDestinationSecureUrlArgsDict',
|
|
52
52
|
'NrqlAlertConditionCriticalArgs',
|
|
53
53
|
'NrqlAlertConditionCriticalArgsDict',
|
|
54
|
+
'NrqlAlertConditionCriticalPredictionArgs',
|
|
55
|
+
'NrqlAlertConditionCriticalPredictionArgsDict',
|
|
54
56
|
'NrqlAlertConditionNrqlArgs',
|
|
55
57
|
'NrqlAlertConditionNrqlArgsDict',
|
|
56
58
|
'NrqlAlertConditionTermArgs',
|
|
57
59
|
'NrqlAlertConditionTermArgsDict',
|
|
60
|
+
'NrqlAlertConditionTermPredictionArgs',
|
|
61
|
+
'NrqlAlertConditionTermPredictionArgsDict',
|
|
58
62
|
'NrqlAlertConditionWarningArgs',
|
|
59
63
|
'NrqlAlertConditionWarningArgsDict',
|
|
64
|
+
'NrqlAlertConditionWarningPredictionArgs',
|
|
65
|
+
'NrqlAlertConditionWarningPredictionArgsDict',
|
|
60
66
|
'ObfuscationRuleActionArgs',
|
|
61
67
|
'ObfuscationRuleActionArgsDict',
|
|
62
68
|
'OneDashboardPageArgs',
|
|
@@ -1912,6 +1918,10 @@ if not MYPY:
|
|
|
1912
1918
|
"""
|
|
1913
1919
|
One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
|
|
1914
1920
|
"""
|
|
1921
|
+
prediction: NotRequired[pulumi.Input['NrqlAlertConditionCriticalPredictionArgsDict']]
|
|
1922
|
+
"""
|
|
1923
|
+
BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
|
|
1924
|
+
"""
|
|
1915
1925
|
threshold_duration: NotRequired[pulumi.Input[int]]
|
|
1916
1926
|
"""
|
|
1917
1927
|
The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
|
|
@@ -1933,6 +1943,7 @@ class NrqlAlertConditionCriticalArgs:
|
|
|
1933
1943
|
threshold: pulumi.Input[float],
|
|
1934
1944
|
duration: Optional[pulumi.Input[int]] = None,
|
|
1935
1945
|
operator: Optional[pulumi.Input[str]] = None,
|
|
1946
|
+
prediction: Optional[pulumi.Input['NrqlAlertConditionCriticalPredictionArgs']] = None,
|
|
1936
1947
|
threshold_duration: Optional[pulumi.Input[int]] = None,
|
|
1937
1948
|
threshold_occurrences: Optional[pulumi.Input[str]] = None,
|
|
1938
1949
|
time_function: Optional[pulumi.Input[str]] = None):
|
|
@@ -1940,6 +1951,7 @@ class NrqlAlertConditionCriticalArgs:
|
|
|
1940
1951
|
:param pulumi.Input[float] threshold: For baseline conditions must be in range [1, 1000].
|
|
1941
1952
|
:param pulumi.Input[int] duration: In minutes, must be in the range of 1 to 120 (inclusive).
|
|
1942
1953
|
:param pulumi.Input[str] operator: One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
|
|
1954
|
+
:param pulumi.Input['NrqlAlertConditionCriticalPredictionArgs'] prediction: BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
|
|
1943
1955
|
:param pulumi.Input[int] threshold_duration: The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
|
|
1944
1956
|
:param pulumi.Input[str] threshold_occurrences: The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: 'ALL' or 'AT_LEAST_ONCE' (case insensitive).
|
|
1945
1957
|
:param pulumi.Input[str] time_function: Valid values are: 'all' or 'any'
|
|
@@ -1952,6 +1964,8 @@ class NrqlAlertConditionCriticalArgs:
|
|
|
1952
1964
|
pulumi.set(__self__, "duration", duration)
|
|
1953
1965
|
if operator is not None:
|
|
1954
1966
|
pulumi.set(__self__, "operator", operator)
|
|
1967
|
+
if prediction is not None:
|
|
1968
|
+
pulumi.set(__self__, "prediction", prediction)
|
|
1955
1969
|
if threshold_duration is not None:
|
|
1956
1970
|
pulumi.set(__self__, "threshold_duration", threshold_duration)
|
|
1957
1971
|
if threshold_occurrences is not None:
|
|
@@ -1999,6 +2013,18 @@ class NrqlAlertConditionCriticalArgs:
|
|
|
1999
2013
|
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
2000
2014
|
pulumi.set(self, "operator", value)
|
|
2001
2015
|
|
|
2016
|
+
@property
|
|
2017
|
+
@pulumi.getter
|
|
2018
|
+
def prediction(self) -> Optional[pulumi.Input['NrqlAlertConditionCriticalPredictionArgs']]:
|
|
2019
|
+
"""
|
|
2020
|
+
BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
|
|
2021
|
+
"""
|
|
2022
|
+
return pulumi.get(self, "prediction")
|
|
2023
|
+
|
|
2024
|
+
@prediction.setter
|
|
2025
|
+
def prediction(self, value: Optional[pulumi.Input['NrqlAlertConditionCriticalPredictionArgs']]):
|
|
2026
|
+
pulumi.set(self, "prediction", value)
|
|
2027
|
+
|
|
2002
2028
|
@property
|
|
2003
2029
|
@pulumi.getter(name="thresholdDuration")
|
|
2004
2030
|
def threshold_duration(self) -> Optional[pulumi.Input[int]]:
|
|
@@ -2037,6 +2063,58 @@ class NrqlAlertConditionCriticalArgs:
|
|
|
2037
2063
|
pulumi.set(self, "time_function", value)
|
|
2038
2064
|
|
|
2039
2065
|
|
|
2066
|
+
if not MYPY:
|
|
2067
|
+
class NrqlAlertConditionCriticalPredictionArgsDict(TypedDict):
|
|
2068
|
+
predict_by: NotRequired[pulumi.Input[int]]
|
|
2069
|
+
"""
|
|
2070
|
+
BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
|
|
2071
|
+
"""
|
|
2072
|
+
prefer_prediction_violation: NotRequired[pulumi.Input[bool]]
|
|
2073
|
+
"""
|
|
2074
|
+
BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
|
|
2075
|
+
"""
|
|
2076
|
+
elif False:
|
|
2077
|
+
NrqlAlertConditionCriticalPredictionArgsDict: TypeAlias = Mapping[str, Any]
|
|
2078
|
+
|
|
2079
|
+
@pulumi.input_type
|
|
2080
|
+
class NrqlAlertConditionCriticalPredictionArgs:
|
|
2081
|
+
def __init__(__self__, *,
|
|
2082
|
+
predict_by: Optional[pulumi.Input[int]] = None,
|
|
2083
|
+
prefer_prediction_violation: Optional[pulumi.Input[bool]] = None):
|
|
2084
|
+
"""
|
|
2085
|
+
:param pulumi.Input[int] predict_by: BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
|
|
2086
|
+
:param pulumi.Input[bool] prefer_prediction_violation: BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
|
|
2087
|
+
"""
|
|
2088
|
+
if predict_by is not None:
|
|
2089
|
+
pulumi.set(__self__, "predict_by", predict_by)
|
|
2090
|
+
if prefer_prediction_violation is not None:
|
|
2091
|
+
pulumi.set(__self__, "prefer_prediction_violation", prefer_prediction_violation)
|
|
2092
|
+
|
|
2093
|
+
@property
|
|
2094
|
+
@pulumi.getter(name="predictBy")
|
|
2095
|
+
def predict_by(self) -> Optional[pulumi.Input[int]]:
|
|
2096
|
+
"""
|
|
2097
|
+
BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
|
|
2098
|
+
"""
|
|
2099
|
+
return pulumi.get(self, "predict_by")
|
|
2100
|
+
|
|
2101
|
+
@predict_by.setter
|
|
2102
|
+
def predict_by(self, value: Optional[pulumi.Input[int]]):
|
|
2103
|
+
pulumi.set(self, "predict_by", value)
|
|
2104
|
+
|
|
2105
|
+
@property
|
|
2106
|
+
@pulumi.getter(name="preferPredictionViolation")
|
|
2107
|
+
def prefer_prediction_violation(self) -> Optional[pulumi.Input[bool]]:
|
|
2108
|
+
"""
|
|
2109
|
+
BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
|
|
2110
|
+
"""
|
|
2111
|
+
return pulumi.get(self, "prefer_prediction_violation")
|
|
2112
|
+
|
|
2113
|
+
@prefer_prediction_violation.setter
|
|
2114
|
+
def prefer_prediction_violation(self, value: Optional[pulumi.Input[bool]]):
|
|
2115
|
+
pulumi.set(self, "prefer_prediction_violation", value)
|
|
2116
|
+
|
|
2117
|
+
|
|
2040
2118
|
if not MYPY:
|
|
2041
2119
|
class NrqlAlertConditionNrqlArgsDict(TypedDict):
|
|
2042
2120
|
query: pulumi.Input[str]
|
|
@@ -2143,6 +2221,10 @@ if not MYPY:
|
|
|
2143
2221
|
"""
|
|
2144
2222
|
One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
|
|
2145
2223
|
"""
|
|
2224
|
+
prediction: NotRequired[pulumi.Input['NrqlAlertConditionTermPredictionArgsDict']]
|
|
2225
|
+
"""
|
|
2226
|
+
BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
|
|
2227
|
+
"""
|
|
2146
2228
|
priority: NotRequired[pulumi.Input[str]]
|
|
2147
2229
|
"""
|
|
2148
2230
|
One of (critical, warning). Defaults to 'critical'. At least one condition term must have priority set to 'critical'.
|
|
@@ -2168,6 +2250,7 @@ class NrqlAlertConditionTermArgs:
|
|
|
2168
2250
|
threshold: pulumi.Input[float],
|
|
2169
2251
|
duration: Optional[pulumi.Input[int]] = None,
|
|
2170
2252
|
operator: Optional[pulumi.Input[str]] = None,
|
|
2253
|
+
prediction: Optional[pulumi.Input['NrqlAlertConditionTermPredictionArgs']] = None,
|
|
2171
2254
|
priority: Optional[pulumi.Input[str]] = None,
|
|
2172
2255
|
threshold_duration: Optional[pulumi.Input[int]] = None,
|
|
2173
2256
|
threshold_occurrences: Optional[pulumi.Input[str]] = None,
|
|
@@ -2176,6 +2259,7 @@ class NrqlAlertConditionTermArgs:
|
|
|
2176
2259
|
:param pulumi.Input[float] threshold: For baseline conditions must be in range [1, 1000].
|
|
2177
2260
|
:param pulumi.Input[int] duration: In minutes, must be in the range of 1 to 120 (inclusive).
|
|
2178
2261
|
:param pulumi.Input[str] operator: One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
|
|
2262
|
+
:param pulumi.Input['NrqlAlertConditionTermPredictionArgs'] prediction: BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
|
|
2179
2263
|
:param pulumi.Input[str] priority: One of (critical, warning). Defaults to 'critical'. At least one condition term must have priority set to 'critical'.
|
|
2180
2264
|
:param pulumi.Input[int] threshold_duration: The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
|
|
2181
2265
|
:param pulumi.Input[str] threshold_occurrences: The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: 'ALL' or 'AT_LEAST_ONCE' (case insensitive).
|
|
@@ -2189,6 +2273,8 @@ class NrqlAlertConditionTermArgs:
|
|
|
2189
2273
|
pulumi.set(__self__, "duration", duration)
|
|
2190
2274
|
if operator is not None:
|
|
2191
2275
|
pulumi.set(__self__, "operator", operator)
|
|
2276
|
+
if prediction is not None:
|
|
2277
|
+
pulumi.set(__self__, "prediction", prediction)
|
|
2192
2278
|
if priority is not None:
|
|
2193
2279
|
pulumi.set(__self__, "priority", priority)
|
|
2194
2280
|
if threshold_duration is not None:
|
|
@@ -2238,6 +2324,18 @@ class NrqlAlertConditionTermArgs:
|
|
|
2238
2324
|
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
2239
2325
|
pulumi.set(self, "operator", value)
|
|
2240
2326
|
|
|
2327
|
+
@property
|
|
2328
|
+
@pulumi.getter
|
|
2329
|
+
def prediction(self) -> Optional[pulumi.Input['NrqlAlertConditionTermPredictionArgs']]:
|
|
2330
|
+
"""
|
|
2331
|
+
BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
|
|
2332
|
+
"""
|
|
2333
|
+
return pulumi.get(self, "prediction")
|
|
2334
|
+
|
|
2335
|
+
@prediction.setter
|
|
2336
|
+
def prediction(self, value: Optional[pulumi.Input['NrqlAlertConditionTermPredictionArgs']]):
|
|
2337
|
+
pulumi.set(self, "prediction", value)
|
|
2338
|
+
|
|
2241
2339
|
@property
|
|
2242
2340
|
@pulumi.getter
|
|
2243
2341
|
def priority(self) -> Optional[pulumi.Input[str]]:
|
|
@@ -2288,6 +2386,58 @@ class NrqlAlertConditionTermArgs:
|
|
|
2288
2386
|
pulumi.set(self, "time_function", value)
|
|
2289
2387
|
|
|
2290
2388
|
|
|
2389
|
+
if not MYPY:
|
|
2390
|
+
class NrqlAlertConditionTermPredictionArgsDict(TypedDict):
|
|
2391
|
+
predict_by: NotRequired[pulumi.Input[int]]
|
|
2392
|
+
"""
|
|
2393
|
+
BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
|
|
2394
|
+
"""
|
|
2395
|
+
prefer_prediction_violation: NotRequired[pulumi.Input[bool]]
|
|
2396
|
+
"""
|
|
2397
|
+
BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
|
|
2398
|
+
"""
|
|
2399
|
+
elif False:
|
|
2400
|
+
NrqlAlertConditionTermPredictionArgsDict: TypeAlias = Mapping[str, Any]
|
|
2401
|
+
|
|
2402
|
+
@pulumi.input_type
|
|
2403
|
+
class NrqlAlertConditionTermPredictionArgs:
|
|
2404
|
+
def __init__(__self__, *,
|
|
2405
|
+
predict_by: Optional[pulumi.Input[int]] = None,
|
|
2406
|
+
prefer_prediction_violation: Optional[pulumi.Input[bool]] = None):
|
|
2407
|
+
"""
|
|
2408
|
+
:param pulumi.Input[int] predict_by: BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
|
|
2409
|
+
:param pulumi.Input[bool] prefer_prediction_violation: BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
|
|
2410
|
+
"""
|
|
2411
|
+
if predict_by is not None:
|
|
2412
|
+
pulumi.set(__self__, "predict_by", predict_by)
|
|
2413
|
+
if prefer_prediction_violation is not None:
|
|
2414
|
+
pulumi.set(__self__, "prefer_prediction_violation", prefer_prediction_violation)
|
|
2415
|
+
|
|
2416
|
+
@property
|
|
2417
|
+
@pulumi.getter(name="predictBy")
|
|
2418
|
+
def predict_by(self) -> Optional[pulumi.Input[int]]:
|
|
2419
|
+
"""
|
|
2420
|
+
BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
|
|
2421
|
+
"""
|
|
2422
|
+
return pulumi.get(self, "predict_by")
|
|
2423
|
+
|
|
2424
|
+
@predict_by.setter
|
|
2425
|
+
def predict_by(self, value: Optional[pulumi.Input[int]]):
|
|
2426
|
+
pulumi.set(self, "predict_by", value)
|
|
2427
|
+
|
|
2428
|
+
@property
|
|
2429
|
+
@pulumi.getter(name="preferPredictionViolation")
|
|
2430
|
+
def prefer_prediction_violation(self) -> Optional[pulumi.Input[bool]]:
|
|
2431
|
+
"""
|
|
2432
|
+
BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
|
|
2433
|
+
"""
|
|
2434
|
+
return pulumi.get(self, "prefer_prediction_violation")
|
|
2435
|
+
|
|
2436
|
+
@prefer_prediction_violation.setter
|
|
2437
|
+
def prefer_prediction_violation(self, value: Optional[pulumi.Input[bool]]):
|
|
2438
|
+
pulumi.set(self, "prefer_prediction_violation", value)
|
|
2439
|
+
|
|
2440
|
+
|
|
2291
2441
|
if not MYPY:
|
|
2292
2442
|
class NrqlAlertConditionWarningArgsDict(TypedDict):
|
|
2293
2443
|
threshold: pulumi.Input[float]
|
|
@@ -2302,6 +2452,10 @@ if not MYPY:
|
|
|
2302
2452
|
"""
|
|
2303
2453
|
One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
|
|
2304
2454
|
"""
|
|
2455
|
+
prediction: NotRequired[pulumi.Input['NrqlAlertConditionWarningPredictionArgsDict']]
|
|
2456
|
+
"""
|
|
2457
|
+
BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
|
|
2458
|
+
"""
|
|
2305
2459
|
threshold_duration: NotRequired[pulumi.Input[int]]
|
|
2306
2460
|
"""
|
|
2307
2461
|
The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
|
|
@@ -2323,6 +2477,7 @@ class NrqlAlertConditionWarningArgs:
|
|
|
2323
2477
|
threshold: pulumi.Input[float],
|
|
2324
2478
|
duration: Optional[pulumi.Input[int]] = None,
|
|
2325
2479
|
operator: Optional[pulumi.Input[str]] = None,
|
|
2480
|
+
prediction: Optional[pulumi.Input['NrqlAlertConditionWarningPredictionArgs']] = None,
|
|
2326
2481
|
threshold_duration: Optional[pulumi.Input[int]] = None,
|
|
2327
2482
|
threshold_occurrences: Optional[pulumi.Input[str]] = None,
|
|
2328
2483
|
time_function: Optional[pulumi.Input[str]] = None):
|
|
@@ -2330,6 +2485,7 @@ class NrqlAlertConditionWarningArgs:
|
|
|
2330
2485
|
:param pulumi.Input[float] threshold: For baseline conditions must be in range [1, 1000].
|
|
2331
2486
|
:param pulumi.Input[int] duration: In minutes, must be in the range of 1 to 120 (inclusive).
|
|
2332
2487
|
:param pulumi.Input[str] operator: One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
|
|
2488
|
+
:param pulumi.Input['NrqlAlertConditionWarningPredictionArgs'] prediction: BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
|
|
2333
2489
|
:param pulumi.Input[int] threshold_duration: The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
|
|
2334
2490
|
:param pulumi.Input[str] threshold_occurrences: The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: 'ALL' or 'AT_LEAST_ONCE' (case insensitive).
|
|
2335
2491
|
:param pulumi.Input[str] time_function: Valid values are: 'all' or 'any'
|
|
@@ -2342,6 +2498,8 @@ class NrqlAlertConditionWarningArgs:
|
|
|
2342
2498
|
pulumi.set(__self__, "duration", duration)
|
|
2343
2499
|
if operator is not None:
|
|
2344
2500
|
pulumi.set(__self__, "operator", operator)
|
|
2501
|
+
if prediction is not None:
|
|
2502
|
+
pulumi.set(__self__, "prediction", prediction)
|
|
2345
2503
|
if threshold_duration is not None:
|
|
2346
2504
|
pulumi.set(__self__, "threshold_duration", threshold_duration)
|
|
2347
2505
|
if threshold_occurrences is not None:
|
|
@@ -2389,6 +2547,18 @@ class NrqlAlertConditionWarningArgs:
|
|
|
2389
2547
|
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
2390
2548
|
pulumi.set(self, "operator", value)
|
|
2391
2549
|
|
|
2550
|
+
@property
|
|
2551
|
+
@pulumi.getter
|
|
2552
|
+
def prediction(self) -> Optional[pulumi.Input['NrqlAlertConditionWarningPredictionArgs']]:
|
|
2553
|
+
"""
|
|
2554
|
+
BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
|
|
2555
|
+
"""
|
|
2556
|
+
return pulumi.get(self, "prediction")
|
|
2557
|
+
|
|
2558
|
+
@prediction.setter
|
|
2559
|
+
def prediction(self, value: Optional[pulumi.Input['NrqlAlertConditionWarningPredictionArgs']]):
|
|
2560
|
+
pulumi.set(self, "prediction", value)
|
|
2561
|
+
|
|
2392
2562
|
@property
|
|
2393
2563
|
@pulumi.getter(name="thresholdDuration")
|
|
2394
2564
|
def threshold_duration(self) -> Optional[pulumi.Input[int]]:
|
|
@@ -2427,6 +2597,58 @@ class NrqlAlertConditionWarningArgs:
|
|
|
2427
2597
|
pulumi.set(self, "time_function", value)
|
|
2428
2598
|
|
|
2429
2599
|
|
|
2600
|
+
if not MYPY:
|
|
2601
|
+
class NrqlAlertConditionWarningPredictionArgsDict(TypedDict):
|
|
2602
|
+
predict_by: NotRequired[pulumi.Input[int]]
|
|
2603
|
+
"""
|
|
2604
|
+
BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
|
|
2605
|
+
"""
|
|
2606
|
+
prefer_prediction_violation: NotRequired[pulumi.Input[bool]]
|
|
2607
|
+
"""
|
|
2608
|
+
BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
|
|
2609
|
+
"""
|
|
2610
|
+
elif False:
|
|
2611
|
+
NrqlAlertConditionWarningPredictionArgsDict: TypeAlias = Mapping[str, Any]
|
|
2612
|
+
|
|
2613
|
+
@pulumi.input_type
|
|
2614
|
+
class NrqlAlertConditionWarningPredictionArgs:
|
|
2615
|
+
def __init__(__self__, *,
|
|
2616
|
+
predict_by: Optional[pulumi.Input[int]] = None,
|
|
2617
|
+
prefer_prediction_violation: Optional[pulumi.Input[bool]] = None):
|
|
2618
|
+
"""
|
|
2619
|
+
:param pulumi.Input[int] predict_by: BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
|
|
2620
|
+
:param pulumi.Input[bool] prefer_prediction_violation: BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
|
|
2621
|
+
"""
|
|
2622
|
+
if predict_by is not None:
|
|
2623
|
+
pulumi.set(__self__, "predict_by", predict_by)
|
|
2624
|
+
if prefer_prediction_violation is not None:
|
|
2625
|
+
pulumi.set(__self__, "prefer_prediction_violation", prefer_prediction_violation)
|
|
2626
|
+
|
|
2627
|
+
@property
|
|
2628
|
+
@pulumi.getter(name="predictBy")
|
|
2629
|
+
def predict_by(self) -> Optional[pulumi.Input[int]]:
|
|
2630
|
+
"""
|
|
2631
|
+
BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
|
|
2632
|
+
"""
|
|
2633
|
+
return pulumi.get(self, "predict_by")
|
|
2634
|
+
|
|
2635
|
+
@predict_by.setter
|
|
2636
|
+
def predict_by(self, value: Optional[pulumi.Input[int]]):
|
|
2637
|
+
pulumi.set(self, "predict_by", value)
|
|
2638
|
+
|
|
2639
|
+
@property
|
|
2640
|
+
@pulumi.getter(name="preferPredictionViolation")
|
|
2641
|
+
def prefer_prediction_violation(self) -> Optional[pulumi.Input[bool]]:
|
|
2642
|
+
"""
|
|
2643
|
+
BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
|
|
2644
|
+
"""
|
|
2645
|
+
return pulumi.get(self, "prefer_prediction_violation")
|
|
2646
|
+
|
|
2647
|
+
@prefer_prediction_violation.setter
|
|
2648
|
+
def prefer_prediction_violation(self, value: Optional[pulumi.Input[bool]]):
|
|
2649
|
+
pulumi.set(self, "prefer_prediction_violation", value)
|
|
2650
|
+
|
|
2651
|
+
|
|
2430
2652
|
if not MYPY:
|
|
2431
2653
|
class ObfuscationRuleActionArgsDict(TypedDict):
|
|
2432
2654
|
attributes: pulumi.Input[Sequence[pulumi.Input[str]]]
|
pulumi_newrelic/_utilities.py
CHANGED
|
@@ -89,12 +89,16 @@ def _get_semver_version():
|
|
|
89
89
|
elif pep440_version.pre_tag == 'rc':
|
|
90
90
|
prerelease = f"rc.{pep440_version.pre}"
|
|
91
91
|
elif pep440_version.dev is not None:
|
|
92
|
+
# PEP440 has explicit support for dev builds, while semver encodes them as "prerelease" versions. To bridge
|
|
93
|
+
# between the two, we convert our dev build version into a prerelease tag. This matches what all of our other
|
|
94
|
+
# packages do when constructing their own semver string.
|
|
92
95
|
prerelease = f"dev.{pep440_version.dev}"
|
|
96
|
+
elif pep440_version.local is not None:
|
|
97
|
+
# PEP440 only allows a small set of prerelease tags, so when converting an arbitrary prerelease,
|
|
98
|
+
# PypiVersion in /pkg/codegen/python/utilities.go converts it to a local version. Therefore, we need to
|
|
99
|
+
# do the reverse conversion here and set the local version as the prerelease tag.
|
|
100
|
+
prerelease = pep440_version.local
|
|
93
101
|
|
|
94
|
-
# The only significant difference between PEP440 and semver as it pertains to us is that PEP440 has explicit support
|
|
95
|
-
# for dev builds, while semver encodes them as "prerelease" versions. In order to bridge between the two, we convert
|
|
96
|
-
# our dev build version into a prerelease tag. This matches what all of our other packages do when constructing
|
|
97
|
-
# their own semver string.
|
|
98
102
|
return SemverVersion(major=major, minor=minor, patch=patch, prerelease=prerelease)
|
|
99
103
|
|
|
100
104
|
|
|
@@ -19,25 +19,21 @@ __all__ = ['AwsGovcloudLinkAccountArgs', 'AwsGovcloudLinkAccount']
|
|
|
19
19
|
@pulumi.input_type
|
|
20
20
|
class AwsGovcloudLinkAccountArgs:
|
|
21
21
|
def __init__(__self__, *,
|
|
22
|
-
|
|
23
|
-
aws_account_id: pulumi.Input[str],
|
|
24
|
-
secret_access_key: pulumi.Input[str],
|
|
22
|
+
arn: pulumi.Input[str],
|
|
25
23
|
account_id: Optional[pulumi.Input[str]] = None,
|
|
26
24
|
metric_collection_mode: Optional[pulumi.Input[str]] = None,
|
|
27
25
|
name: Optional[pulumi.Input[str]] = None):
|
|
28
26
|
"""
|
|
29
27
|
The set of arguments for constructing a AwsGovcloudLinkAccount resource.
|
|
30
|
-
:param pulumi.Input[str]
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
:param pulumi.Input[str] account_id: The New Relic account ID to operate on. This allows the user to override the `account_id` attribute set on the provider. Defaults to the environment variable `NEW_RELIC_ACCOUNT_ID
|
|
34
|
-
:param pulumi.Input[str] metric_collection_mode: The mode by which metric data is to be collected from the linked AWS GovCloud account.
|
|
35
|
-
-
|
|
28
|
+
:param pulumi.Input[str] arn: The Amazon Resource Name (ARN) of the IAM role.
|
|
29
|
+
|
|
30
|
+
> **NOTE:** Altering the `account_id` (or) `metric_collection_mode` of an already applied `cloud.AwsGovcloudLinkAccount` resource shall trigger a recreation of the resource, instead of an update.
|
|
31
|
+
:param pulumi.Input[str] account_id: The New Relic account ID to operate on. This allows the user to override the `account_id` attribute set on the provider. Defaults to the environment variable `NEW_RELIC_ACCOUNT_ID`, if not specified in the configuration.
|
|
32
|
+
:param pulumi.Input[str] metric_collection_mode: The mode by which metric data is to be collected from the linked AWS GovCloud account. Defaults to `PULL`, if not specified in the configuration.
|
|
33
|
+
- Use `PUSH` for Metric Streams and `PULL` for API Polling based metric collection respectively.
|
|
36
34
|
:param pulumi.Input[str] name: The name/identifier of the AWS GovCloud - New Relic 'linked' account.
|
|
37
35
|
"""
|
|
38
|
-
pulumi.set(__self__, "
|
|
39
|
-
pulumi.set(__self__, "aws_account_id", aws_account_id)
|
|
40
|
-
pulumi.set(__self__, "secret_access_key", secret_access_key)
|
|
36
|
+
pulumi.set(__self__, "arn", arn)
|
|
41
37
|
if account_id is not None:
|
|
42
38
|
pulumi.set(__self__, "account_id", account_id)
|
|
43
39
|
if metric_collection_mode is not None:
|
|
@@ -46,46 +42,24 @@ class AwsGovcloudLinkAccountArgs:
|
|
|
46
42
|
pulumi.set(__self__, "name", name)
|
|
47
43
|
|
|
48
44
|
@property
|
|
49
|
-
@pulumi.getter
|
|
50
|
-
def
|
|
51
|
-
"""
|
|
52
|
-
The Access Key used to programmatically access the AWS GovCloud account.
|
|
53
|
-
"""
|
|
54
|
-
return pulumi.get(self, "access_key_id")
|
|
55
|
-
|
|
56
|
-
@access_key_id.setter
|
|
57
|
-
def access_key_id(self, value: pulumi.Input[str]):
|
|
58
|
-
pulumi.set(self, "access_key_id", value)
|
|
59
|
-
|
|
60
|
-
@property
|
|
61
|
-
@pulumi.getter(name="awsAccountId")
|
|
62
|
-
def aws_account_id(self) -> pulumi.Input[str]:
|
|
63
|
-
"""
|
|
64
|
-
The ID of the AWS GovCloud account.
|
|
45
|
+
@pulumi.getter
|
|
46
|
+
def arn(self) -> pulumi.Input[str]:
|
|
65
47
|
"""
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
@aws_account_id.setter
|
|
69
|
-
def aws_account_id(self, value: pulumi.Input[str]):
|
|
70
|
-
pulumi.set(self, "aws_account_id", value)
|
|
48
|
+
The Amazon Resource Name (ARN) of the IAM role.
|
|
71
49
|
|
|
72
|
-
|
|
73
|
-
@pulumi.getter(name="secretAccessKey")
|
|
74
|
-
def secret_access_key(self) -> pulumi.Input[str]:
|
|
75
|
-
"""
|
|
76
|
-
The Secret Access Key used to programmatically access the AWS GovCloud account.
|
|
50
|
+
> **NOTE:** Altering the `account_id` (or) `metric_collection_mode` of an already applied `cloud.AwsGovcloudLinkAccount` resource shall trigger a recreation of the resource, instead of an update.
|
|
77
51
|
"""
|
|
78
|
-
return pulumi.get(self, "
|
|
52
|
+
return pulumi.get(self, "arn")
|
|
79
53
|
|
|
80
|
-
@
|
|
81
|
-
def
|
|
82
|
-
pulumi.set(self, "
|
|
54
|
+
@arn.setter
|
|
55
|
+
def arn(self, value: pulumi.Input[str]):
|
|
56
|
+
pulumi.set(self, "arn", value)
|
|
83
57
|
|
|
84
58
|
@property
|
|
85
59
|
@pulumi.getter(name="accountId")
|
|
86
60
|
def account_id(self) -> Optional[pulumi.Input[str]]:
|
|
87
61
|
"""
|
|
88
|
-
The New Relic account ID to operate on. This allows the user to override the `account_id` attribute set on the provider. Defaults to the environment variable `NEW_RELIC_ACCOUNT_ID
|
|
62
|
+
The New Relic account ID to operate on. This allows the user to override the `account_id` attribute set on the provider. Defaults to the environment variable `NEW_RELIC_ACCOUNT_ID`, if not specified in the configuration.
|
|
89
63
|
"""
|
|
90
64
|
return pulumi.get(self, "account_id")
|
|
91
65
|
|
|
@@ -97,8 +71,8 @@ class AwsGovcloudLinkAccountArgs:
|
|
|
97
71
|
@pulumi.getter(name="metricCollectionMode")
|
|
98
72
|
def metric_collection_mode(self) -> Optional[pulumi.Input[str]]:
|
|
99
73
|
"""
|
|
100
|
-
The mode by which metric data is to be collected from the linked AWS GovCloud account.
|
|
101
|
-
-
|
|
74
|
+
The mode by which metric data is to be collected from the linked AWS GovCloud account. Defaults to `PULL`, if not specified in the configuration.
|
|
75
|
+
- Use `PUSH` for Metric Streams and `PULL` for API Polling based metric collection respectively.
|
|
102
76
|
"""
|
|
103
77
|
return pulumi.get(self, "metric_collection_mode")
|
|
104
78
|
|
|
@@ -122,52 +96,34 @@ class AwsGovcloudLinkAccountArgs:
|
|
|
122
96
|
@pulumi.input_type
|
|
123
97
|
class _AwsGovcloudLinkAccountState:
|
|
124
98
|
def __init__(__self__, *,
|
|
125
|
-
access_key_id: Optional[pulumi.Input[str]] = None,
|
|
126
99
|
account_id: Optional[pulumi.Input[str]] = None,
|
|
127
|
-
|
|
100
|
+
arn: Optional[pulumi.Input[str]] = None,
|
|
128
101
|
metric_collection_mode: Optional[pulumi.Input[str]] = None,
|
|
129
|
-
name: Optional[pulumi.Input[str]] = None
|
|
130
|
-
secret_access_key: Optional[pulumi.Input[str]] = None):
|
|
102
|
+
name: Optional[pulumi.Input[str]] = None):
|
|
131
103
|
"""
|
|
132
104
|
Input properties used for looking up and filtering AwsGovcloudLinkAccount resources.
|
|
133
|
-
:param pulumi.Input[str]
|
|
134
|
-
:param pulumi.Input[str]
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
105
|
+
:param pulumi.Input[str] account_id: The New Relic account ID to operate on. This allows the user to override the `account_id` attribute set on the provider. Defaults to the environment variable `NEW_RELIC_ACCOUNT_ID`, if not specified in the configuration.
|
|
106
|
+
:param pulumi.Input[str] arn: The Amazon Resource Name (ARN) of the IAM role.
|
|
107
|
+
|
|
108
|
+
> **NOTE:** Altering the `account_id` (or) `metric_collection_mode` of an already applied `cloud.AwsGovcloudLinkAccount` resource shall trigger a recreation of the resource, instead of an update.
|
|
109
|
+
:param pulumi.Input[str] metric_collection_mode: The mode by which metric data is to be collected from the linked AWS GovCloud account. Defaults to `PULL`, if not specified in the configuration.
|
|
110
|
+
- Use `PUSH` for Metric Streams and `PULL` for API Polling based metric collection respectively.
|
|
138
111
|
:param pulumi.Input[str] name: The name/identifier of the AWS GovCloud - New Relic 'linked' account.
|
|
139
|
-
:param pulumi.Input[str] secret_access_key: The Secret Access Key used to programmatically access the AWS GovCloud account.
|
|
140
112
|
"""
|
|
141
|
-
if access_key_id is not None:
|
|
142
|
-
pulumi.set(__self__, "access_key_id", access_key_id)
|
|
143
113
|
if account_id is not None:
|
|
144
114
|
pulumi.set(__self__, "account_id", account_id)
|
|
145
|
-
if
|
|
146
|
-
pulumi.set(__self__, "
|
|
115
|
+
if arn is not None:
|
|
116
|
+
pulumi.set(__self__, "arn", arn)
|
|
147
117
|
if metric_collection_mode is not None:
|
|
148
118
|
pulumi.set(__self__, "metric_collection_mode", metric_collection_mode)
|
|
149
119
|
if name is not None:
|
|
150
120
|
pulumi.set(__self__, "name", name)
|
|
151
|
-
if secret_access_key is not None:
|
|
152
|
-
pulumi.set(__self__, "secret_access_key", secret_access_key)
|
|
153
|
-
|
|
154
|
-
@property
|
|
155
|
-
@pulumi.getter(name="accessKeyId")
|
|
156
|
-
def access_key_id(self) -> Optional[pulumi.Input[str]]:
|
|
157
|
-
"""
|
|
158
|
-
The Access Key used to programmatically access the AWS GovCloud account.
|
|
159
|
-
"""
|
|
160
|
-
return pulumi.get(self, "access_key_id")
|
|
161
|
-
|
|
162
|
-
@access_key_id.setter
|
|
163
|
-
def access_key_id(self, value: Optional[pulumi.Input[str]]):
|
|
164
|
-
pulumi.set(self, "access_key_id", value)
|
|
165
121
|
|
|
166
122
|
@property
|
|
167
123
|
@pulumi.getter(name="accountId")
|
|
168
124
|
def account_id(self) -> Optional[pulumi.Input[str]]:
|
|
169
125
|
"""
|
|
170
|
-
The New Relic account ID to operate on. This allows the user to override the `account_id` attribute set on the provider. Defaults to the environment variable `NEW_RELIC_ACCOUNT_ID
|
|
126
|
+
The New Relic account ID to operate on. This allows the user to override the `account_id` attribute set on the provider. Defaults to the environment variable `NEW_RELIC_ACCOUNT_ID`, if not specified in the configuration.
|
|
171
127
|
"""
|
|
172
128
|
return pulumi.get(self, "account_id")
|
|
173
129
|
|
|
@@ -176,23 +132,25 @@ class _AwsGovcloudLinkAccountState:
|
|
|
176
132
|
pulumi.set(self, "account_id", value)
|
|
177
133
|
|
|
178
134
|
@property
|
|
179
|
-
@pulumi.getter
|
|
180
|
-
def
|
|
135
|
+
@pulumi.getter
|
|
136
|
+
def arn(self) -> Optional[pulumi.Input[str]]:
|
|
181
137
|
"""
|
|
182
|
-
The
|
|
138
|
+
The Amazon Resource Name (ARN) of the IAM role.
|
|
139
|
+
|
|
140
|
+
> **NOTE:** Altering the `account_id` (or) `metric_collection_mode` of an already applied `cloud.AwsGovcloudLinkAccount` resource shall trigger a recreation of the resource, instead of an update.
|
|
183
141
|
"""
|
|
184
|
-
return pulumi.get(self, "
|
|
142
|
+
return pulumi.get(self, "arn")
|
|
185
143
|
|
|
186
|
-
@
|
|
187
|
-
def
|
|
188
|
-
pulumi.set(self, "
|
|
144
|
+
@arn.setter
|
|
145
|
+
def arn(self, value: Optional[pulumi.Input[str]]):
|
|
146
|
+
pulumi.set(self, "arn", value)
|
|
189
147
|
|
|
190
148
|
@property
|
|
191
149
|
@pulumi.getter(name="metricCollectionMode")
|
|
192
150
|
def metric_collection_mode(self) -> Optional[pulumi.Input[str]]:
|
|
193
151
|
"""
|
|
194
|
-
The mode by which metric data is to be collected from the linked AWS GovCloud account.
|
|
195
|
-
-
|
|
152
|
+
The mode by which metric data is to be collected from the linked AWS GovCloud account. Defaults to `PULL`, if not specified in the configuration.
|
|
153
|
+
- Use `PUSH` for Metric Streams and `PULL` for API Polling based metric collection respectively.
|
|
196
154
|
"""
|
|
197
155
|
return pulumi.get(self, "metric_collection_mode")
|
|
198
156
|
|
|
@@ -212,43 +170,25 @@ class _AwsGovcloudLinkAccountState:
|
|
|
212
170
|
def name(self, value: Optional[pulumi.Input[str]]):
|
|
213
171
|
pulumi.set(self, "name", value)
|
|
214
172
|
|
|
215
|
-
@property
|
|
216
|
-
@pulumi.getter(name="secretAccessKey")
|
|
217
|
-
def secret_access_key(self) -> Optional[pulumi.Input[str]]:
|
|
218
|
-
"""
|
|
219
|
-
The Secret Access Key used to programmatically access the AWS GovCloud account.
|
|
220
|
-
"""
|
|
221
|
-
return pulumi.get(self, "secret_access_key")
|
|
222
|
-
|
|
223
|
-
@secret_access_key.setter
|
|
224
|
-
def secret_access_key(self, value: Optional[pulumi.Input[str]]):
|
|
225
|
-
pulumi.set(self, "secret_access_key", value)
|
|
226
|
-
|
|
227
173
|
|
|
228
174
|
class AwsGovcloudLinkAccount(pulumi.CustomResource):
|
|
229
175
|
@overload
|
|
230
176
|
def __init__(__self__,
|
|
231
177
|
resource_name: str,
|
|
232
178
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
233
|
-
access_key_id: Optional[pulumi.Input[str]] = None,
|
|
234
179
|
account_id: Optional[pulumi.Input[str]] = None,
|
|
235
|
-
|
|
180
|
+
arn: Optional[pulumi.Input[str]] = None,
|
|
236
181
|
metric_collection_mode: Optional[pulumi.Input[str]] = None,
|
|
237
182
|
name: Optional[pulumi.Input[str]] = None,
|
|
238
|
-
secret_access_key: Optional[pulumi.Input[str]] = None,
|
|
239
183
|
__props__=None):
|
|
240
184
|
"""
|
|
241
|
-
> **IMPORTANT!** This resource is in alpha state, and could still contain issues and missing functionality. If you encounter any issue please create a ticket on Github with all the required information.
|
|
242
|
-
|
|
243
185
|
Use this resource to link an AWS GovCloud account to New Relic.
|
|
244
186
|
|
|
245
187
|
## Prerequisite
|
|
246
188
|
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
It is an isolated AWS region designed to host sensitive data and regulated workloads in the cloud, helping customers support their US government compliance requirements.
|
|
189
|
+
To link an AWS GovCloud account to New Relic, you need an AWS GovCloud account. AWS GovCloud is designed to address the specific regulatory needs of United States federal, state, and local agencies, educational institutions, and their supporting ecosystem. It is an isolated AWS region designed to host sensitive data and regulated workloads in the cloud, helping customers support their US government compliance requirements.
|
|
250
190
|
|
|
251
|
-
To pull data from
|
|
191
|
+
To pull data from AWS GovCloud, follow the [steps outlined here](https://docs.newrelic.com/docs/infrastructure/amazon-integrations/get-started/connect-aws-govcloud-new-relic).
|
|
252
192
|
|
|
253
193
|
## Example Usage
|
|
254
194
|
|
|
@@ -260,9 +200,7 @@ class AwsGovcloudLinkAccount(pulumi.CustomResource):
|
|
|
260
200
|
account_id="1234567",
|
|
261
201
|
name="My New Relic - AWS GovCloud Linked Account",
|
|
262
202
|
metric_collection_mode="PUSH",
|
|
263
|
-
|
|
264
|
-
access_key_id="<Your AWS GovCloud Account's Access Key ID>",
|
|
265
|
-
secret_access_key="<Your AWS GovCloud Account's Secret Access Key>")
|
|
203
|
+
arn="arn:aws:service:region:account-id:resource-id")
|
|
266
204
|
```
|
|
267
205
|
|
|
268
206
|
## Import
|
|
@@ -277,13 +215,13 @@ class AwsGovcloudLinkAccount(pulumi.CustomResource):
|
|
|
277
215
|
|
|
278
216
|
:param str resource_name: The name of the resource.
|
|
279
217
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
280
|
-
:param pulumi.Input[str]
|
|
281
|
-
:param pulumi.Input[str]
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
218
|
+
:param pulumi.Input[str] account_id: The New Relic account ID to operate on. This allows the user to override the `account_id` attribute set on the provider. Defaults to the environment variable `NEW_RELIC_ACCOUNT_ID`, if not specified in the configuration.
|
|
219
|
+
:param pulumi.Input[str] arn: The Amazon Resource Name (ARN) of the IAM role.
|
|
220
|
+
|
|
221
|
+
> **NOTE:** Altering the `account_id` (or) `metric_collection_mode` of an already applied `cloud.AwsGovcloudLinkAccount` resource shall trigger a recreation of the resource, instead of an update.
|
|
222
|
+
:param pulumi.Input[str] metric_collection_mode: The mode by which metric data is to be collected from the linked AWS GovCloud account. Defaults to `PULL`, if not specified in the configuration.
|
|
223
|
+
- Use `PUSH` for Metric Streams and `PULL` for API Polling based metric collection respectively.
|
|
285
224
|
:param pulumi.Input[str] name: The name/identifier of the AWS GovCloud - New Relic 'linked' account.
|
|
286
|
-
:param pulumi.Input[str] secret_access_key: The Secret Access Key used to programmatically access the AWS GovCloud account.
|
|
287
225
|
"""
|
|
288
226
|
...
|
|
289
227
|
@overload
|
|
@@ -292,17 +230,13 @@ class AwsGovcloudLinkAccount(pulumi.CustomResource):
|
|
|
292
230
|
args: AwsGovcloudLinkAccountArgs,
|
|
293
231
|
opts: Optional[pulumi.ResourceOptions] = None):
|
|
294
232
|
"""
|
|
295
|
-
> **IMPORTANT!** This resource is in alpha state, and could still contain issues and missing functionality. If you encounter any issue please create a ticket on Github with all the required information.
|
|
296
|
-
|
|
297
233
|
Use this resource to link an AWS GovCloud account to New Relic.
|
|
298
234
|
|
|
299
235
|
## Prerequisite
|
|
300
236
|
|
|
301
|
-
|
|
237
|
+
To link an AWS GovCloud account to New Relic, you need an AWS GovCloud account. AWS GovCloud is designed to address the specific regulatory needs of United States federal, state, and local agencies, educational institutions, and their supporting ecosystem. It is an isolated AWS region designed to host sensitive data and regulated workloads in the cloud, helping customers support their US government compliance requirements.
|
|
302
238
|
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
To pull data from AWSGovCloud, complete the [steps outlined here](https://docs.newrelic.com/docs/infrastructure/amazon-integrations/get-started/connect-aws-govcloud-new-relic).
|
|
239
|
+
To pull data from AWS GovCloud, follow the [steps outlined here](https://docs.newrelic.com/docs/infrastructure/amazon-integrations/get-started/connect-aws-govcloud-new-relic).
|
|
306
240
|
|
|
307
241
|
## Example Usage
|
|
308
242
|
|
|
@@ -314,9 +248,7 @@ class AwsGovcloudLinkAccount(pulumi.CustomResource):
|
|
|
314
248
|
account_id="1234567",
|
|
315
249
|
name="My New Relic - AWS GovCloud Linked Account",
|
|
316
250
|
metric_collection_mode="PUSH",
|
|
317
|
-
|
|
318
|
-
access_key_id="<Your AWS GovCloud Account's Access Key ID>",
|
|
319
|
-
secret_access_key="<Your AWS GovCloud Account's Secret Access Key>")
|
|
251
|
+
arn="arn:aws:service:region:account-id:resource-id")
|
|
320
252
|
```
|
|
321
253
|
|
|
322
254
|
## Import
|
|
@@ -344,12 +276,10 @@ class AwsGovcloudLinkAccount(pulumi.CustomResource):
|
|
|
344
276
|
def _internal_init(__self__,
|
|
345
277
|
resource_name: str,
|
|
346
278
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
347
|
-
access_key_id: Optional[pulumi.Input[str]] = None,
|
|
348
279
|
account_id: Optional[pulumi.Input[str]] = None,
|
|
349
|
-
|
|
280
|
+
arn: Optional[pulumi.Input[str]] = None,
|
|
350
281
|
metric_collection_mode: Optional[pulumi.Input[str]] = None,
|
|
351
282
|
name: Optional[pulumi.Input[str]] = None,
|
|
352
|
-
secret_access_key: Optional[pulumi.Input[str]] = None,
|
|
353
283
|
__props__=None):
|
|
354
284
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
355
285
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -359,20 +289,12 @@ class AwsGovcloudLinkAccount(pulumi.CustomResource):
|
|
|
359
289
|
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
|
|
360
290
|
__props__ = AwsGovcloudLinkAccountArgs.__new__(AwsGovcloudLinkAccountArgs)
|
|
361
291
|
|
|
362
|
-
if access_key_id is None and not opts.urn:
|
|
363
|
-
raise TypeError("Missing required property 'access_key_id'")
|
|
364
|
-
__props__.__dict__["access_key_id"] = None if access_key_id is None else pulumi.Output.secret(access_key_id)
|
|
365
292
|
__props__.__dict__["account_id"] = account_id
|
|
366
|
-
if
|
|
367
|
-
raise TypeError("Missing required property '
|
|
368
|
-
__props__.__dict__["
|
|
293
|
+
if arn is None and not opts.urn:
|
|
294
|
+
raise TypeError("Missing required property 'arn'")
|
|
295
|
+
__props__.__dict__["arn"] = arn
|
|
369
296
|
__props__.__dict__["metric_collection_mode"] = metric_collection_mode
|
|
370
297
|
__props__.__dict__["name"] = name
|
|
371
|
-
if secret_access_key is None and not opts.urn:
|
|
372
|
-
raise TypeError("Missing required property 'secret_access_key'")
|
|
373
|
-
__props__.__dict__["secret_access_key"] = None if secret_access_key is None else pulumi.Output.secret(secret_access_key)
|
|
374
|
-
secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["accessKeyId", "secretAccessKey"])
|
|
375
|
-
opts = pulumi.ResourceOptions.merge(opts, secret_opts)
|
|
376
298
|
super(AwsGovcloudLinkAccount, __self__).__init__(
|
|
377
299
|
'newrelic:cloud/awsGovcloudLinkAccount:AwsGovcloudLinkAccount',
|
|
378
300
|
resource_name,
|
|
@@ -383,12 +305,10 @@ class AwsGovcloudLinkAccount(pulumi.CustomResource):
|
|
|
383
305
|
def get(resource_name: str,
|
|
384
306
|
id: pulumi.Input[str],
|
|
385
307
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
386
|
-
access_key_id: Optional[pulumi.Input[str]] = None,
|
|
387
308
|
account_id: Optional[pulumi.Input[str]] = None,
|
|
388
|
-
|
|
309
|
+
arn: Optional[pulumi.Input[str]] = None,
|
|
389
310
|
metric_collection_mode: Optional[pulumi.Input[str]] = None,
|
|
390
|
-
name: Optional[pulumi.Input[str]] = None
|
|
391
|
-
secret_access_key: Optional[pulumi.Input[str]] = None) -> 'AwsGovcloudLinkAccount':
|
|
311
|
+
name: Optional[pulumi.Input[str]] = None) -> 'AwsGovcloudLinkAccount':
|
|
392
312
|
"""
|
|
393
313
|
Get an existing AwsGovcloudLinkAccount resource's state with the given name, id, and optional extra
|
|
394
314
|
properties used to qualify the lookup.
|
|
@@ -396,56 +316,48 @@ class AwsGovcloudLinkAccount(pulumi.CustomResource):
|
|
|
396
316
|
:param str resource_name: The unique name of the resulting resource.
|
|
397
317
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
398
318
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
399
|
-
:param pulumi.Input[str]
|
|
400
|
-
:param pulumi.Input[str]
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
|
|
319
|
+
:param pulumi.Input[str] account_id: The New Relic account ID to operate on. This allows the user to override the `account_id` attribute set on the provider. Defaults to the environment variable `NEW_RELIC_ACCOUNT_ID`, if not specified in the configuration.
|
|
320
|
+
:param pulumi.Input[str] arn: The Amazon Resource Name (ARN) of the IAM role.
|
|
321
|
+
|
|
322
|
+
> **NOTE:** Altering the `account_id` (or) `metric_collection_mode` of an already applied `cloud.AwsGovcloudLinkAccount` resource shall trigger a recreation of the resource, instead of an update.
|
|
323
|
+
:param pulumi.Input[str] metric_collection_mode: The mode by which metric data is to be collected from the linked AWS GovCloud account. Defaults to `PULL`, if not specified in the configuration.
|
|
324
|
+
- Use `PUSH` for Metric Streams and `PULL` for API Polling based metric collection respectively.
|
|
404
325
|
:param pulumi.Input[str] name: The name/identifier of the AWS GovCloud - New Relic 'linked' account.
|
|
405
|
-
:param pulumi.Input[str] secret_access_key: The Secret Access Key used to programmatically access the AWS GovCloud account.
|
|
406
326
|
"""
|
|
407
327
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
408
328
|
|
|
409
329
|
__props__ = _AwsGovcloudLinkAccountState.__new__(_AwsGovcloudLinkAccountState)
|
|
410
330
|
|
|
411
|
-
__props__.__dict__["access_key_id"] = access_key_id
|
|
412
331
|
__props__.__dict__["account_id"] = account_id
|
|
413
|
-
__props__.__dict__["
|
|
332
|
+
__props__.__dict__["arn"] = arn
|
|
414
333
|
__props__.__dict__["metric_collection_mode"] = metric_collection_mode
|
|
415
334
|
__props__.__dict__["name"] = name
|
|
416
|
-
__props__.__dict__["secret_access_key"] = secret_access_key
|
|
417
335
|
return AwsGovcloudLinkAccount(resource_name, opts=opts, __props__=__props__)
|
|
418
336
|
|
|
419
|
-
@property
|
|
420
|
-
@pulumi.getter(name="accessKeyId")
|
|
421
|
-
def access_key_id(self) -> pulumi.Output[str]:
|
|
422
|
-
"""
|
|
423
|
-
The Access Key used to programmatically access the AWS GovCloud account.
|
|
424
|
-
"""
|
|
425
|
-
return pulumi.get(self, "access_key_id")
|
|
426
|
-
|
|
427
337
|
@property
|
|
428
338
|
@pulumi.getter(name="accountId")
|
|
429
339
|
def account_id(self) -> pulumi.Output[str]:
|
|
430
340
|
"""
|
|
431
|
-
The New Relic account ID to operate on. This allows the user to override the `account_id` attribute set on the provider. Defaults to the environment variable `NEW_RELIC_ACCOUNT_ID
|
|
341
|
+
The New Relic account ID to operate on. This allows the user to override the `account_id` attribute set on the provider. Defaults to the environment variable `NEW_RELIC_ACCOUNT_ID`, if not specified in the configuration.
|
|
432
342
|
"""
|
|
433
343
|
return pulumi.get(self, "account_id")
|
|
434
344
|
|
|
435
345
|
@property
|
|
436
|
-
@pulumi.getter
|
|
437
|
-
def
|
|
346
|
+
@pulumi.getter
|
|
347
|
+
def arn(self) -> pulumi.Output[str]:
|
|
438
348
|
"""
|
|
439
|
-
The
|
|
349
|
+
The Amazon Resource Name (ARN) of the IAM role.
|
|
350
|
+
|
|
351
|
+
> **NOTE:** Altering the `account_id` (or) `metric_collection_mode` of an already applied `cloud.AwsGovcloudLinkAccount` resource shall trigger a recreation of the resource, instead of an update.
|
|
440
352
|
"""
|
|
441
|
-
return pulumi.get(self, "
|
|
353
|
+
return pulumi.get(self, "arn")
|
|
442
354
|
|
|
443
355
|
@property
|
|
444
356
|
@pulumi.getter(name="metricCollectionMode")
|
|
445
357
|
def metric_collection_mode(self) -> pulumi.Output[Optional[str]]:
|
|
446
358
|
"""
|
|
447
|
-
The mode by which metric data is to be collected from the linked AWS GovCloud account.
|
|
448
|
-
-
|
|
359
|
+
The mode by which metric data is to be collected from the linked AWS GovCloud account. Defaults to `PULL`, if not specified in the configuration.
|
|
360
|
+
- Use `PUSH` for Metric Streams and `PULL` for API Polling based metric collection respectively.
|
|
449
361
|
"""
|
|
450
362
|
return pulumi.get(self, "metric_collection_mode")
|
|
451
363
|
|
|
@@ -457,11 +369,3 @@ class AwsGovcloudLinkAccount(pulumi.CustomResource):
|
|
|
457
369
|
"""
|
|
458
370
|
return pulumi.get(self, "name")
|
|
459
371
|
|
|
460
|
-
@property
|
|
461
|
-
@pulumi.getter(name="secretAccessKey")
|
|
462
|
-
def secret_access_key(self) -> pulumi.Output[str]:
|
|
463
|
-
"""
|
|
464
|
-
The Secret Access Key used to programmatically access the AWS GovCloud account.
|
|
465
|
-
"""
|
|
466
|
-
return pulumi.get(self, "secret_access_key")
|
|
467
|
-
|
|
@@ -1046,11 +1046,23 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1046
1046
|
- `threshold_occurrences` - (Optional) The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: `all` or `at_least_once` (case insensitive).
|
|
1047
1047
|
- `duration` - (Optional) **DEPRECATED:** Use `threshold_duration` instead. The duration of time, in _minutes_, that the threshold must violate for in order to create an incident. Must be within 1-120 (inclusive).
|
|
1048
1048
|
- `time_function` - (Optional) **DEPRECATED:** Use `threshold_occurrences` instead. The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: `all` or `any`.
|
|
1049
|
+
- `prediction` - (Optional) **BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis.** Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for _static_ NRQL alert conditions. See Prediction below for details.
|
|
1049
1050
|
|
|
1050
1051
|
> **NOTE:** When a `critical` or `warning` block is added to this resource, using either `duration` or `threshold_duration` (one of the two) is mandatory. Both of these should not be specified.
|
|
1051
1052
|
|
|
1052
1053
|
> **NOTE:** When a `critical` or `warning` block is added to this resource, using either `time_function` or `threshold_occurrences` (one of the two) is mandatory. Both of these should not be specified.
|
|
1053
1054
|
|
|
1055
|
+
### Prediction
|
|
1056
|
+
|
|
1057
|
+
> **BETA PREVIEW:** The `prediction` block is in limited release and only enabled for preview on a per-account basis.
|
|
1058
|
+
|
|
1059
|
+
> **NOTE:** The `prediction` block is only available for _static_ NRQL alert conditions.
|
|
1060
|
+
|
|
1061
|
+
The `prediction` block supports the following arguments:
|
|
1062
|
+
|
|
1063
|
+
- `predict_by` - (Optional) The duration, in seconds, that the prediction should look into the future. Default is 3600 seconds (1 hour).
|
|
1064
|
+
- `prefer_prediction_violation` - (Optional) If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening. Default is false.
|
|
1065
|
+
|
|
1054
1066
|
## Additional Examples
|
|
1055
1067
|
|
|
1056
1068
|
##### Type: `baseline`
|
|
@@ -1345,11 +1357,23 @@ class NrqlAlertCondition(pulumi.CustomResource):
|
|
|
1345
1357
|
- `threshold_occurrences` - (Optional) The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: `all` or `at_least_once` (case insensitive).
|
|
1346
1358
|
- `duration` - (Optional) **DEPRECATED:** Use `threshold_duration` instead. The duration of time, in _minutes_, that the threshold must violate for in order to create an incident. Must be within 1-120 (inclusive).
|
|
1347
1359
|
- `time_function` - (Optional) **DEPRECATED:** Use `threshold_occurrences` instead. The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: `all` or `any`.
|
|
1360
|
+
- `prediction` - (Optional) **BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis.** Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for _static_ NRQL alert conditions. See Prediction below for details.
|
|
1348
1361
|
|
|
1349
1362
|
> **NOTE:** When a `critical` or `warning` block is added to this resource, using either `duration` or `threshold_duration` (one of the two) is mandatory. Both of these should not be specified.
|
|
1350
1363
|
|
|
1351
1364
|
> **NOTE:** When a `critical` or `warning` block is added to this resource, using either `time_function` or `threshold_occurrences` (one of the two) is mandatory. Both of these should not be specified.
|
|
1352
1365
|
|
|
1366
|
+
### Prediction
|
|
1367
|
+
|
|
1368
|
+
> **BETA PREVIEW:** The `prediction` block is in limited release and only enabled for preview on a per-account basis.
|
|
1369
|
+
|
|
1370
|
+
> **NOTE:** The `prediction` block is only available for _static_ NRQL alert conditions.
|
|
1371
|
+
|
|
1372
|
+
The `prediction` block supports the following arguments:
|
|
1373
|
+
|
|
1374
|
+
- `predict_by` - (Optional) The duration, in seconds, that the prediction should look into the future. Default is 3600 seconds (1 hour).
|
|
1375
|
+
- `prefer_prediction_violation` - (Optional) If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening. Default is false.
|
|
1376
|
+
|
|
1353
1377
|
## Additional Examples
|
|
1354
1378
|
|
|
1355
1379
|
##### Type: `baseline`
|
pulumi_newrelic/outputs.py
CHANGED
|
@@ -34,9 +34,12 @@ __all__ = [
|
|
|
34
34
|
'NotificationDestinationProperty',
|
|
35
35
|
'NotificationDestinationSecureUrl',
|
|
36
36
|
'NrqlAlertConditionCritical',
|
|
37
|
+
'NrqlAlertConditionCriticalPrediction',
|
|
37
38
|
'NrqlAlertConditionNrql',
|
|
38
39
|
'NrqlAlertConditionTerm',
|
|
40
|
+
'NrqlAlertConditionTermPrediction',
|
|
39
41
|
'NrqlAlertConditionWarning',
|
|
42
|
+
'NrqlAlertConditionWarningPrediction',
|
|
40
43
|
'ObfuscationRuleAction',
|
|
41
44
|
'OneDashboardPage',
|
|
42
45
|
'OneDashboardPageWidgetArea',
|
|
@@ -1350,6 +1353,7 @@ class NrqlAlertConditionCritical(dict):
|
|
|
1350
1353
|
threshold: float,
|
|
1351
1354
|
duration: Optional[int] = None,
|
|
1352
1355
|
operator: Optional[str] = None,
|
|
1356
|
+
prediction: Optional['outputs.NrqlAlertConditionCriticalPrediction'] = None,
|
|
1353
1357
|
threshold_duration: Optional[int] = None,
|
|
1354
1358
|
threshold_occurrences: Optional[str] = None,
|
|
1355
1359
|
time_function: Optional[str] = None):
|
|
@@ -1357,6 +1361,7 @@ class NrqlAlertConditionCritical(dict):
|
|
|
1357
1361
|
:param float threshold: For baseline conditions must be in range [1, 1000].
|
|
1358
1362
|
:param int duration: In minutes, must be in the range of 1 to 120 (inclusive).
|
|
1359
1363
|
:param str operator: One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
|
|
1364
|
+
:param 'NrqlAlertConditionCriticalPredictionArgs' prediction: BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
|
|
1360
1365
|
:param int threshold_duration: The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
|
|
1361
1366
|
:param str threshold_occurrences: The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: 'ALL' or 'AT_LEAST_ONCE' (case insensitive).
|
|
1362
1367
|
:param str time_function: Valid values are: 'all' or 'any'
|
|
@@ -1366,6 +1371,8 @@ class NrqlAlertConditionCritical(dict):
|
|
|
1366
1371
|
pulumi.set(__self__, "duration", duration)
|
|
1367
1372
|
if operator is not None:
|
|
1368
1373
|
pulumi.set(__self__, "operator", operator)
|
|
1374
|
+
if prediction is not None:
|
|
1375
|
+
pulumi.set(__self__, "prediction", prediction)
|
|
1369
1376
|
if threshold_duration is not None:
|
|
1370
1377
|
pulumi.set(__self__, "threshold_duration", threshold_duration)
|
|
1371
1378
|
if threshold_occurrences is not None:
|
|
@@ -1398,6 +1405,14 @@ class NrqlAlertConditionCritical(dict):
|
|
|
1398
1405
|
"""
|
|
1399
1406
|
return pulumi.get(self, "operator")
|
|
1400
1407
|
|
|
1408
|
+
@property
|
|
1409
|
+
@pulumi.getter
|
|
1410
|
+
def prediction(self) -> Optional['outputs.NrqlAlertConditionCriticalPrediction']:
|
|
1411
|
+
"""
|
|
1412
|
+
BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
|
|
1413
|
+
"""
|
|
1414
|
+
return pulumi.get(self, "prediction")
|
|
1415
|
+
|
|
1401
1416
|
@property
|
|
1402
1417
|
@pulumi.getter(name="thresholdDuration")
|
|
1403
1418
|
def threshold_duration(self) -> Optional[int]:
|
|
@@ -1424,6 +1439,56 @@ class NrqlAlertConditionCritical(dict):
|
|
|
1424
1439
|
return pulumi.get(self, "time_function")
|
|
1425
1440
|
|
|
1426
1441
|
|
|
1442
|
+
@pulumi.output_type
|
|
1443
|
+
class NrqlAlertConditionCriticalPrediction(dict):
|
|
1444
|
+
@staticmethod
|
|
1445
|
+
def __key_warning(key: str):
|
|
1446
|
+
suggest = None
|
|
1447
|
+
if key == "predictBy":
|
|
1448
|
+
suggest = "predict_by"
|
|
1449
|
+
elif key == "preferPredictionViolation":
|
|
1450
|
+
suggest = "prefer_prediction_violation"
|
|
1451
|
+
|
|
1452
|
+
if suggest:
|
|
1453
|
+
pulumi.log.warn(f"Key '{key}' not found in NrqlAlertConditionCriticalPrediction. Access the value via the '{suggest}' property getter instead.")
|
|
1454
|
+
|
|
1455
|
+
def __getitem__(self, key: str) -> Any:
|
|
1456
|
+
NrqlAlertConditionCriticalPrediction.__key_warning(key)
|
|
1457
|
+
return super().__getitem__(key)
|
|
1458
|
+
|
|
1459
|
+
def get(self, key: str, default = None) -> Any:
|
|
1460
|
+
NrqlAlertConditionCriticalPrediction.__key_warning(key)
|
|
1461
|
+
return super().get(key, default)
|
|
1462
|
+
|
|
1463
|
+
def __init__(__self__, *,
|
|
1464
|
+
predict_by: Optional[int] = None,
|
|
1465
|
+
prefer_prediction_violation: Optional[bool] = None):
|
|
1466
|
+
"""
|
|
1467
|
+
:param int predict_by: BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
|
|
1468
|
+
:param bool prefer_prediction_violation: BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
|
|
1469
|
+
"""
|
|
1470
|
+
if predict_by is not None:
|
|
1471
|
+
pulumi.set(__self__, "predict_by", predict_by)
|
|
1472
|
+
if prefer_prediction_violation is not None:
|
|
1473
|
+
pulumi.set(__self__, "prefer_prediction_violation", prefer_prediction_violation)
|
|
1474
|
+
|
|
1475
|
+
@property
|
|
1476
|
+
@pulumi.getter(name="predictBy")
|
|
1477
|
+
def predict_by(self) -> Optional[int]:
|
|
1478
|
+
"""
|
|
1479
|
+
BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
|
|
1480
|
+
"""
|
|
1481
|
+
return pulumi.get(self, "predict_by")
|
|
1482
|
+
|
|
1483
|
+
@property
|
|
1484
|
+
@pulumi.getter(name="preferPredictionViolation")
|
|
1485
|
+
def prefer_prediction_violation(self) -> Optional[bool]:
|
|
1486
|
+
"""
|
|
1487
|
+
BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
|
|
1488
|
+
"""
|
|
1489
|
+
return pulumi.get(self, "prefer_prediction_violation")
|
|
1490
|
+
|
|
1491
|
+
|
|
1427
1492
|
@pulumi.output_type
|
|
1428
1493
|
class NrqlAlertConditionNrql(dict):
|
|
1429
1494
|
@staticmethod
|
|
@@ -1524,6 +1589,7 @@ class NrqlAlertConditionTerm(dict):
|
|
|
1524
1589
|
threshold: float,
|
|
1525
1590
|
duration: Optional[int] = None,
|
|
1526
1591
|
operator: Optional[str] = None,
|
|
1592
|
+
prediction: Optional['outputs.NrqlAlertConditionTermPrediction'] = None,
|
|
1527
1593
|
priority: Optional[str] = None,
|
|
1528
1594
|
threshold_duration: Optional[int] = None,
|
|
1529
1595
|
threshold_occurrences: Optional[str] = None,
|
|
@@ -1532,6 +1598,7 @@ class NrqlAlertConditionTerm(dict):
|
|
|
1532
1598
|
:param float threshold: For baseline conditions must be in range [1, 1000].
|
|
1533
1599
|
:param int duration: In minutes, must be in the range of 1 to 120 (inclusive).
|
|
1534
1600
|
:param str operator: One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
|
|
1601
|
+
:param 'NrqlAlertConditionTermPredictionArgs' prediction: BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
|
|
1535
1602
|
:param str priority: One of (critical, warning). Defaults to 'critical'. At least one condition term must have priority set to 'critical'.
|
|
1536
1603
|
:param int threshold_duration: The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
|
|
1537
1604
|
:param str threshold_occurrences: The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: 'ALL' or 'AT_LEAST_ONCE' (case insensitive).
|
|
@@ -1542,6 +1609,8 @@ class NrqlAlertConditionTerm(dict):
|
|
|
1542
1609
|
pulumi.set(__self__, "duration", duration)
|
|
1543
1610
|
if operator is not None:
|
|
1544
1611
|
pulumi.set(__self__, "operator", operator)
|
|
1612
|
+
if prediction is not None:
|
|
1613
|
+
pulumi.set(__self__, "prediction", prediction)
|
|
1545
1614
|
if priority is not None:
|
|
1546
1615
|
pulumi.set(__self__, "priority", priority)
|
|
1547
1616
|
if threshold_duration is not None:
|
|
@@ -1576,6 +1645,14 @@ class NrqlAlertConditionTerm(dict):
|
|
|
1576
1645
|
"""
|
|
1577
1646
|
return pulumi.get(self, "operator")
|
|
1578
1647
|
|
|
1648
|
+
@property
|
|
1649
|
+
@pulumi.getter
|
|
1650
|
+
def prediction(self) -> Optional['outputs.NrqlAlertConditionTermPrediction']:
|
|
1651
|
+
"""
|
|
1652
|
+
BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
|
|
1653
|
+
"""
|
|
1654
|
+
return pulumi.get(self, "prediction")
|
|
1655
|
+
|
|
1579
1656
|
@property
|
|
1580
1657
|
@pulumi.getter
|
|
1581
1658
|
def priority(self) -> Optional[str]:
|
|
@@ -1610,6 +1687,56 @@ class NrqlAlertConditionTerm(dict):
|
|
|
1610
1687
|
return pulumi.get(self, "time_function")
|
|
1611
1688
|
|
|
1612
1689
|
|
|
1690
|
+
@pulumi.output_type
|
|
1691
|
+
class NrqlAlertConditionTermPrediction(dict):
|
|
1692
|
+
@staticmethod
|
|
1693
|
+
def __key_warning(key: str):
|
|
1694
|
+
suggest = None
|
|
1695
|
+
if key == "predictBy":
|
|
1696
|
+
suggest = "predict_by"
|
|
1697
|
+
elif key == "preferPredictionViolation":
|
|
1698
|
+
suggest = "prefer_prediction_violation"
|
|
1699
|
+
|
|
1700
|
+
if suggest:
|
|
1701
|
+
pulumi.log.warn(f"Key '{key}' not found in NrqlAlertConditionTermPrediction. Access the value via the '{suggest}' property getter instead.")
|
|
1702
|
+
|
|
1703
|
+
def __getitem__(self, key: str) -> Any:
|
|
1704
|
+
NrqlAlertConditionTermPrediction.__key_warning(key)
|
|
1705
|
+
return super().__getitem__(key)
|
|
1706
|
+
|
|
1707
|
+
def get(self, key: str, default = None) -> Any:
|
|
1708
|
+
NrqlAlertConditionTermPrediction.__key_warning(key)
|
|
1709
|
+
return super().get(key, default)
|
|
1710
|
+
|
|
1711
|
+
def __init__(__self__, *,
|
|
1712
|
+
predict_by: Optional[int] = None,
|
|
1713
|
+
prefer_prediction_violation: Optional[bool] = None):
|
|
1714
|
+
"""
|
|
1715
|
+
:param int predict_by: BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
|
|
1716
|
+
:param bool prefer_prediction_violation: BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
|
|
1717
|
+
"""
|
|
1718
|
+
if predict_by is not None:
|
|
1719
|
+
pulumi.set(__self__, "predict_by", predict_by)
|
|
1720
|
+
if prefer_prediction_violation is not None:
|
|
1721
|
+
pulumi.set(__self__, "prefer_prediction_violation", prefer_prediction_violation)
|
|
1722
|
+
|
|
1723
|
+
@property
|
|
1724
|
+
@pulumi.getter(name="predictBy")
|
|
1725
|
+
def predict_by(self) -> Optional[int]:
|
|
1726
|
+
"""
|
|
1727
|
+
BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
|
|
1728
|
+
"""
|
|
1729
|
+
return pulumi.get(self, "predict_by")
|
|
1730
|
+
|
|
1731
|
+
@property
|
|
1732
|
+
@pulumi.getter(name="preferPredictionViolation")
|
|
1733
|
+
def prefer_prediction_violation(self) -> Optional[bool]:
|
|
1734
|
+
"""
|
|
1735
|
+
BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
|
|
1736
|
+
"""
|
|
1737
|
+
return pulumi.get(self, "prefer_prediction_violation")
|
|
1738
|
+
|
|
1739
|
+
|
|
1613
1740
|
@pulumi.output_type
|
|
1614
1741
|
class NrqlAlertConditionWarning(dict):
|
|
1615
1742
|
@staticmethod
|
|
@@ -1637,6 +1764,7 @@ class NrqlAlertConditionWarning(dict):
|
|
|
1637
1764
|
threshold: float,
|
|
1638
1765
|
duration: Optional[int] = None,
|
|
1639
1766
|
operator: Optional[str] = None,
|
|
1767
|
+
prediction: Optional['outputs.NrqlAlertConditionWarningPrediction'] = None,
|
|
1640
1768
|
threshold_duration: Optional[int] = None,
|
|
1641
1769
|
threshold_occurrences: Optional[str] = None,
|
|
1642
1770
|
time_function: Optional[str] = None):
|
|
@@ -1644,6 +1772,7 @@ class NrqlAlertConditionWarning(dict):
|
|
|
1644
1772
|
:param float threshold: For baseline conditions must be in range [1, 1000].
|
|
1645
1773
|
:param int duration: In minutes, must be in the range of 1 to 120 (inclusive).
|
|
1646
1774
|
:param str operator: One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
|
|
1775
|
+
:param 'NrqlAlertConditionWarningPredictionArgs' prediction: BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
|
|
1647
1776
|
:param int threshold_duration: The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
|
|
1648
1777
|
:param str threshold_occurrences: The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: 'ALL' or 'AT_LEAST_ONCE' (case insensitive).
|
|
1649
1778
|
:param str time_function: Valid values are: 'all' or 'any'
|
|
@@ -1653,6 +1782,8 @@ class NrqlAlertConditionWarning(dict):
|
|
|
1653
1782
|
pulumi.set(__self__, "duration", duration)
|
|
1654
1783
|
if operator is not None:
|
|
1655
1784
|
pulumi.set(__self__, "operator", operator)
|
|
1785
|
+
if prediction is not None:
|
|
1786
|
+
pulumi.set(__self__, "prediction", prediction)
|
|
1656
1787
|
if threshold_duration is not None:
|
|
1657
1788
|
pulumi.set(__self__, "threshold_duration", threshold_duration)
|
|
1658
1789
|
if threshold_occurrences is not None:
|
|
@@ -1685,6 +1816,14 @@ class NrqlAlertConditionWarning(dict):
|
|
|
1685
1816
|
"""
|
|
1686
1817
|
return pulumi.get(self, "operator")
|
|
1687
1818
|
|
|
1819
|
+
@property
|
|
1820
|
+
@pulumi.getter
|
|
1821
|
+
def prediction(self) -> Optional['outputs.NrqlAlertConditionWarningPrediction']:
|
|
1822
|
+
"""
|
|
1823
|
+
BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
|
|
1824
|
+
"""
|
|
1825
|
+
return pulumi.get(self, "prediction")
|
|
1826
|
+
|
|
1688
1827
|
@property
|
|
1689
1828
|
@pulumi.getter(name="thresholdDuration")
|
|
1690
1829
|
def threshold_duration(self) -> Optional[int]:
|
|
@@ -1711,6 +1850,56 @@ class NrqlAlertConditionWarning(dict):
|
|
|
1711
1850
|
return pulumi.get(self, "time_function")
|
|
1712
1851
|
|
|
1713
1852
|
|
|
1853
|
+
@pulumi.output_type
|
|
1854
|
+
class NrqlAlertConditionWarningPrediction(dict):
|
|
1855
|
+
@staticmethod
|
|
1856
|
+
def __key_warning(key: str):
|
|
1857
|
+
suggest = None
|
|
1858
|
+
if key == "predictBy":
|
|
1859
|
+
suggest = "predict_by"
|
|
1860
|
+
elif key == "preferPredictionViolation":
|
|
1861
|
+
suggest = "prefer_prediction_violation"
|
|
1862
|
+
|
|
1863
|
+
if suggest:
|
|
1864
|
+
pulumi.log.warn(f"Key '{key}' not found in NrqlAlertConditionWarningPrediction. Access the value via the '{suggest}' property getter instead.")
|
|
1865
|
+
|
|
1866
|
+
def __getitem__(self, key: str) -> Any:
|
|
1867
|
+
NrqlAlertConditionWarningPrediction.__key_warning(key)
|
|
1868
|
+
return super().__getitem__(key)
|
|
1869
|
+
|
|
1870
|
+
def get(self, key: str, default = None) -> Any:
|
|
1871
|
+
NrqlAlertConditionWarningPrediction.__key_warning(key)
|
|
1872
|
+
return super().get(key, default)
|
|
1873
|
+
|
|
1874
|
+
def __init__(__self__, *,
|
|
1875
|
+
predict_by: Optional[int] = None,
|
|
1876
|
+
prefer_prediction_violation: Optional[bool] = None):
|
|
1877
|
+
"""
|
|
1878
|
+
:param int predict_by: BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
|
|
1879
|
+
:param bool prefer_prediction_violation: BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
|
|
1880
|
+
"""
|
|
1881
|
+
if predict_by is not None:
|
|
1882
|
+
pulumi.set(__self__, "predict_by", predict_by)
|
|
1883
|
+
if prefer_prediction_violation is not None:
|
|
1884
|
+
pulumi.set(__self__, "prefer_prediction_violation", prefer_prediction_violation)
|
|
1885
|
+
|
|
1886
|
+
@property
|
|
1887
|
+
@pulumi.getter(name="predictBy")
|
|
1888
|
+
def predict_by(self) -> Optional[int]:
|
|
1889
|
+
"""
|
|
1890
|
+
BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
|
|
1891
|
+
"""
|
|
1892
|
+
return pulumi.get(self, "predict_by")
|
|
1893
|
+
|
|
1894
|
+
@property
|
|
1895
|
+
@pulumi.getter(name="preferPredictionViolation")
|
|
1896
|
+
def prefer_prediction_violation(self) -> Optional[bool]:
|
|
1897
|
+
"""
|
|
1898
|
+
BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
|
|
1899
|
+
"""
|
|
1900
|
+
return pulumi.get(self, "prefer_prediction_violation")
|
|
1901
|
+
|
|
1902
|
+
|
|
1714
1903
|
@pulumi.output_type
|
|
1715
1904
|
class ObfuscationRuleAction(dict):
|
|
1716
1905
|
@staticmethod
|
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
pulumi_newrelic/__init__.py,sha256=q0NdPqgZC1kS4XOkgRZa7J_iuaWxIkMKXQfOnC5CysU,11535
|
|
2
|
-
pulumi_newrelic/_inputs.py,sha256=
|
|
3
|
-
pulumi_newrelic/_utilities.py,sha256
|
|
2
|
+
pulumi_newrelic/_inputs.py,sha256=P3qXyc_wIl3Rk01kIClfgnZbLGyG9osKt5yEc44OgLU,813264
|
|
3
|
+
pulumi_newrelic/_utilities.py,sha256=yyuODPikZ9pto3JWJRfMJo98dWmQ5_y45-TVcZG_K8Y,10807
|
|
4
4
|
pulumi_newrelic/account_management.py,sha256=qFD7xsT6kNFNY3ZEO-15E4T6mSIOQ6uw_Goqf7-NkTU,8963
|
|
5
5
|
pulumi_newrelic/alert_channel.py,sha256=QNF_jzaDJLKD78qxtBnDpRaAVMJigmGYQtSWuCEIC7g,21825
|
|
6
6
|
pulumi_newrelic/alert_condition.py,sha256=1Z6zrlx82N6hrQDpIMCAATUx4YH8oXiS1pNmGiW94bQ,46708
|
|
@@ -33,16 +33,16 @@ pulumi_newrelic/log_parsing_rule.py,sha256=HOCj_6SaSGNkJdhXalrETqRapE550cdnpe1PJ
|
|
|
33
33
|
pulumi_newrelic/monitor_downtime.py,sha256=OKeKMevKKOTn4t3C2uhRX4rXuG-OikhQZTmRy6JtBfQ,40862
|
|
34
34
|
pulumi_newrelic/notification_channel.py,sha256=5M1toakKA-65WA5pec0HMp4t7eX9OkcSFs53pNcUQTI,47179
|
|
35
35
|
pulumi_newrelic/notification_destination.py,sha256=l7BC67LiRM4EXCtf3eNnWnrb-o1P7_9RmpsC4Rga6q4,39181
|
|
36
|
-
pulumi_newrelic/nrql_alert_condition.py,sha256=
|
|
36
|
+
pulumi_newrelic/nrql_alert_condition.py,sha256=KGZDpiXD29I79e42ASD6-gWz_MOyiAb57h4qVmgUXBc,114429
|
|
37
37
|
pulumi_newrelic/nrql_drop_rule.py,sha256=T33XlLYt7RfQQeazJzF2_GtLrJL1lxiG1PmXRdFL8eA,17712
|
|
38
38
|
pulumi_newrelic/obfuscation_expression.py,sha256=V3YlnP1ZHyCbWnCgykm6uOHgyj0IUYqxpWllM7z43fE,12517
|
|
39
39
|
pulumi_newrelic/obfuscation_rule.py,sha256=HzyDhyK3-qkrgiERkAZs0HiC1ToH8vaeXXoLjx6fyss,18043
|
|
40
40
|
pulumi_newrelic/one_dashboard.py,sha256=91XJ8Dic5u66ZvUx7-uyZpNZJ306BOq9mLBULMe7-oQ,20854
|
|
41
41
|
pulumi_newrelic/one_dashboard_json.py,sha256=EZqg6akwsh-SqsRjCmQzDjgsjvbIfKsX2zt3vjQ8bYE,12796
|
|
42
42
|
pulumi_newrelic/one_dashboard_raw.py,sha256=__3ZuSPVubBaC5iPa9V6q1SG7lHFcpNdVsLXQie5c7U,23668
|
|
43
|
-
pulumi_newrelic/outputs.py,sha256=
|
|
43
|
+
pulumi_newrelic/outputs.py,sha256=1S09iXWXxMCrDIuG5-A4yWmYhp-cps-O3zMKak2Q1qc,588609
|
|
44
44
|
pulumi_newrelic/provider.py,sha256=OjBqZT1L0Jt_1-c3zMSSGA03zIZjgif7RrThna-ojng,18493
|
|
45
|
-
pulumi_newrelic/pulumi-plugin.json,sha256=
|
|
45
|
+
pulumi_newrelic/pulumi-plugin.json,sha256=u7MnYrw6NTu2anuvZMESIL0fDbqKXL-olL7xwnp4cAk,68
|
|
46
46
|
pulumi_newrelic/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
47
47
|
pulumi_newrelic/service_level.py,sha256=Dk_AoEFTmaJAg5v8SKBN4-a4T-MGXDbPubxsnB98sFk,28980
|
|
48
48
|
pulumi_newrelic/user.py,sha256=guVvPGAeuR-mQ6_bA_MvBP7GY2grEmnbdNkc_5hs1us,19116
|
|
@@ -50,7 +50,7 @@ pulumi_newrelic/workflow.py,sha256=Ka0qEJke18DRFRdDjDUgwZd-sbOufowesAUaWZLg85U,4
|
|
|
50
50
|
pulumi_newrelic/cloud/__init__.py,sha256=iv3_NQivZ9OvaZzsRb81j-_v55U3fjpbV-q2T8oW6i8,592
|
|
51
51
|
pulumi_newrelic/cloud/_inputs.py,sha256=4rFcDJGO0GjsfxZG8USBt-SPnXdyvjMbmtzqpqHSi7o,381862
|
|
52
52
|
pulumi_newrelic/cloud/aws_govcloud_integrations.py,sha256=xRgN1R3xWAG0q0sTv_5Vba1h0P5KtH3jk10I7ZokvkQ,65413
|
|
53
|
-
pulumi_newrelic/cloud/aws_govcloud_link_account.py,sha256=
|
|
53
|
+
pulumi_newrelic/cloud/aws_govcloud_link_account.py,sha256=Ib6_PdEcre4DX5eHS0gvKEV4g8Pwwd_bnsgzL3CqC44,18752
|
|
54
54
|
pulumi_newrelic/cloud/aws_integrations.py,sha256=PggxGS3ECz71g6VydQGUpr9Z10wMQT-AKQCJku29Py8,128568
|
|
55
55
|
pulumi_newrelic/cloud/aws_link_account.py,sha256=-MfVXLan_qDRuMkgy54dJ3h6tPgCNLQDHPEw7R38PZY,15669
|
|
56
56
|
pulumi_newrelic/cloud/azure_integrations.py,sha256=Tr1j9QEMnTrNL1W7s7Jr3IhJTeGzE9CXhC7XrmASseQ,114191
|
|
@@ -84,7 +84,7 @@ pulumi_newrelic/synthetics/private_location.py,sha256=-pj6W9dg9fB-jtnrTH8wnd7o_j
|
|
|
84
84
|
pulumi_newrelic/synthetics/script_monitor.py,sha256=fwRaviLtkQ0ViK3V1W98npxcN_qBXFevwuHgHArl3m0,66220
|
|
85
85
|
pulumi_newrelic/synthetics/secure_credential.py,sha256=EilBGvvvqmADHo1VPeWfQkCdc2GYRO8Dq9-lktE7Y3M,15776
|
|
86
86
|
pulumi_newrelic/synthetics/step_monitor.py,sha256=7tqzQ9InEMRdfAr9K_vpLm-OCPHyIKEH4f8CT2BxaLQ,49116
|
|
87
|
-
pulumi_newrelic-5.
|
|
88
|
-
pulumi_newrelic-5.
|
|
89
|
-
pulumi_newrelic-5.
|
|
90
|
-
pulumi_newrelic-5.
|
|
87
|
+
pulumi_newrelic-5.41.0.dist-info/METADATA,sha256=qdvL_elkg0AUalafCyZ5AVFlVDCvTZZtily7mqYzWKQ,3952
|
|
88
|
+
pulumi_newrelic-5.41.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
|
|
89
|
+
pulumi_newrelic-5.41.0.dist-info/top_level.txt,sha256=BjE1Wsu6Ah_A7k08uV5vRSZ2R_5uY3wFvSWJaa7ZoQk,16
|
|
90
|
+
pulumi_newrelic-5.41.0.dist-info/RECORD,,
|
|
File without changes
|
{pulumi_newrelic-5.40.0a1738908234.dist-info → pulumi_newrelic-5.41.0.dist-info}/top_level.txt
RENAMED
|
File without changes
|