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,57 +1,393 @@
|
|
|
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
|
|
|
12
17
|
__all__ = [
|
|
18
|
+
'ApplicationSettingsErrorCollectorArgs',
|
|
19
|
+
'ApplicationSettingsErrorCollectorArgsDict',
|
|
20
|
+
'ApplicationSettingsTransactionTracerArgs',
|
|
21
|
+
'ApplicationSettingsTransactionTracerArgsDict',
|
|
22
|
+
'ApplicationSettingsTransactionTracerExplainQueryPlanArgs',
|
|
23
|
+
'ApplicationSettingsTransactionTracerExplainQueryPlanArgsDict',
|
|
24
|
+
'ApplicationSettingsTransactionTracerSqlArgs',
|
|
25
|
+
'ApplicationSettingsTransactionTracerSqlArgsDict',
|
|
13
26
|
'WorkloadEntitySearchQueryArgs',
|
|
27
|
+
'WorkloadEntitySearchQueryArgsDict',
|
|
14
28
|
'WorkloadStatusConfigAutomaticArgs',
|
|
29
|
+
'WorkloadStatusConfigAutomaticArgsDict',
|
|
15
30
|
'WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs',
|
|
31
|
+
'WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgsDict',
|
|
16
32
|
'WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs',
|
|
33
|
+
'WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgsDict',
|
|
17
34
|
'WorkloadStatusConfigAutomaticRuleArgs',
|
|
35
|
+
'WorkloadStatusConfigAutomaticRuleArgsDict',
|
|
18
36
|
'WorkloadStatusConfigAutomaticRuleNrqlQueryArgs',
|
|
37
|
+
'WorkloadStatusConfigAutomaticRuleNrqlQueryArgsDict',
|
|
19
38
|
'WorkloadStatusConfigAutomaticRuleRollupArgs',
|
|
39
|
+
'WorkloadStatusConfigAutomaticRuleRollupArgsDict',
|
|
20
40
|
'WorkloadStatusConfigStaticArgs',
|
|
41
|
+
'WorkloadStatusConfigStaticArgsDict',
|
|
21
42
|
]
|
|
22
43
|
|
|
44
|
+
MYPY = False
|
|
45
|
+
|
|
46
|
+
if not MYPY:
|
|
47
|
+
class ApplicationSettingsErrorCollectorArgsDict(TypedDict):
|
|
48
|
+
expected_error_classes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
49
|
+
"""
|
|
50
|
+
A list of expected error classes.
|
|
51
|
+
"""
|
|
52
|
+
expected_error_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
53
|
+
"""
|
|
54
|
+
A list of expected error codes(any status code between 100-900).
|
|
55
|
+
"""
|
|
56
|
+
ignored_error_classes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
57
|
+
"""
|
|
58
|
+
A list of ignored error classes.
|
|
59
|
+
"""
|
|
60
|
+
ignored_error_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
61
|
+
"""
|
|
62
|
+
A list of ignored error codes(any status code between 100-900).
|
|
63
|
+
"""
|
|
64
|
+
elif False:
|
|
65
|
+
ApplicationSettingsErrorCollectorArgsDict: TypeAlias = Mapping[str, Any]
|
|
66
|
+
|
|
67
|
+
@pulumi.input_type
|
|
68
|
+
class ApplicationSettingsErrorCollectorArgs:
|
|
69
|
+
def __init__(__self__, *,
|
|
70
|
+
expected_error_classes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
71
|
+
expected_error_codes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
72
|
+
ignored_error_classes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
73
|
+
ignored_error_codes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
74
|
+
"""
|
|
75
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] expected_error_classes: A list of expected error classes.
|
|
76
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] expected_error_codes: A list of expected error codes(any status code between 100-900).
|
|
77
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ignored_error_classes: A list of ignored error classes.
|
|
78
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ignored_error_codes: A list of ignored error codes(any status code between 100-900).
|
|
79
|
+
"""
|
|
80
|
+
if expected_error_classes is not None:
|
|
81
|
+
pulumi.set(__self__, "expected_error_classes", expected_error_classes)
|
|
82
|
+
if expected_error_codes is not None:
|
|
83
|
+
pulumi.set(__self__, "expected_error_codes", expected_error_codes)
|
|
84
|
+
if ignored_error_classes is not None:
|
|
85
|
+
pulumi.set(__self__, "ignored_error_classes", ignored_error_classes)
|
|
86
|
+
if ignored_error_codes is not None:
|
|
87
|
+
pulumi.set(__self__, "ignored_error_codes", ignored_error_codes)
|
|
88
|
+
|
|
89
|
+
@_builtins.property
|
|
90
|
+
@pulumi.getter(name="expectedErrorClasses")
|
|
91
|
+
def expected_error_classes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
92
|
+
"""
|
|
93
|
+
A list of expected error classes.
|
|
94
|
+
"""
|
|
95
|
+
return pulumi.get(self, "expected_error_classes")
|
|
96
|
+
|
|
97
|
+
@expected_error_classes.setter
|
|
98
|
+
def expected_error_classes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
99
|
+
pulumi.set(self, "expected_error_classes", value)
|
|
100
|
+
|
|
101
|
+
@_builtins.property
|
|
102
|
+
@pulumi.getter(name="expectedErrorCodes")
|
|
103
|
+
def expected_error_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
104
|
+
"""
|
|
105
|
+
A list of expected error codes(any status code between 100-900).
|
|
106
|
+
"""
|
|
107
|
+
return pulumi.get(self, "expected_error_codes")
|
|
108
|
+
|
|
109
|
+
@expected_error_codes.setter
|
|
110
|
+
def expected_error_codes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
111
|
+
pulumi.set(self, "expected_error_codes", value)
|
|
112
|
+
|
|
113
|
+
@_builtins.property
|
|
114
|
+
@pulumi.getter(name="ignoredErrorClasses")
|
|
115
|
+
def ignored_error_classes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
116
|
+
"""
|
|
117
|
+
A list of ignored error classes.
|
|
118
|
+
"""
|
|
119
|
+
return pulumi.get(self, "ignored_error_classes")
|
|
120
|
+
|
|
121
|
+
@ignored_error_classes.setter
|
|
122
|
+
def ignored_error_classes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
123
|
+
pulumi.set(self, "ignored_error_classes", value)
|
|
124
|
+
|
|
125
|
+
@_builtins.property
|
|
126
|
+
@pulumi.getter(name="ignoredErrorCodes")
|
|
127
|
+
def ignored_error_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
128
|
+
"""
|
|
129
|
+
A list of ignored error codes(any status code between 100-900).
|
|
130
|
+
"""
|
|
131
|
+
return pulumi.get(self, "ignored_error_codes")
|
|
132
|
+
|
|
133
|
+
@ignored_error_codes.setter
|
|
134
|
+
def ignored_error_codes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
135
|
+
pulumi.set(self, "ignored_error_codes", value)
|
|
136
|
+
|
|
137
|
+
|
|
138
|
+
if not MYPY:
|
|
139
|
+
class ApplicationSettingsTransactionTracerArgsDict(TypedDict):
|
|
140
|
+
explain_query_plans: NotRequired[pulumi.Input[Sequence[pulumi.Input['ApplicationSettingsTransactionTracerExplainQueryPlanArgsDict']]]]
|
|
141
|
+
"""
|
|
142
|
+
Configuration block for query plans. Including this block enables the capture of query plans. The following arguments are supported:
|
|
143
|
+
"""
|
|
144
|
+
sql: NotRequired[pulumi.Input['ApplicationSettingsTransactionTracerSqlArgsDict']]
|
|
145
|
+
"""
|
|
146
|
+
Configuration block for SQL logging. Including this block enables SQL logging. The following arguments are supported:
|
|
147
|
+
"""
|
|
148
|
+
stack_trace_threshold_value: NotRequired[pulumi.Input[_builtins.float]]
|
|
149
|
+
"""
|
|
150
|
+
The response time threshold for collecting stack traces.
|
|
151
|
+
"""
|
|
152
|
+
transaction_threshold_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
153
|
+
"""
|
|
154
|
+
The type of threshold for transactions. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
|
|
155
|
+
"""
|
|
156
|
+
transaction_threshold_value: NotRequired[pulumi.Input[_builtins.float]]
|
|
157
|
+
"""
|
|
158
|
+
The threshold value for transactions(in seconds).
|
|
159
|
+
"""
|
|
160
|
+
elif False:
|
|
161
|
+
ApplicationSettingsTransactionTracerArgsDict: TypeAlias = Mapping[str, Any]
|
|
162
|
+
|
|
163
|
+
@pulumi.input_type
|
|
164
|
+
class ApplicationSettingsTransactionTracerArgs:
|
|
165
|
+
def __init__(__self__, *,
|
|
166
|
+
explain_query_plans: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSettingsTransactionTracerExplainQueryPlanArgs']]]] = None,
|
|
167
|
+
sql: Optional[pulumi.Input['ApplicationSettingsTransactionTracerSqlArgs']] = None,
|
|
168
|
+
stack_trace_threshold_value: Optional[pulumi.Input[_builtins.float]] = None,
|
|
169
|
+
transaction_threshold_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
170
|
+
transaction_threshold_value: Optional[pulumi.Input[_builtins.float]] = None):
|
|
171
|
+
"""
|
|
172
|
+
:param pulumi.Input[Sequence[pulumi.Input['ApplicationSettingsTransactionTracerExplainQueryPlanArgs']]] explain_query_plans: Configuration block for query plans. Including this block enables the capture of query plans. The following arguments are supported:
|
|
173
|
+
:param pulumi.Input['ApplicationSettingsTransactionTracerSqlArgs'] sql: Configuration block for SQL logging. Including this block enables SQL logging. The following arguments are supported:
|
|
174
|
+
:param pulumi.Input[_builtins.float] stack_trace_threshold_value: The response time threshold for collecting stack traces.
|
|
175
|
+
:param pulumi.Input[_builtins.str] transaction_threshold_type: The type of threshold for transactions. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
|
|
176
|
+
:param pulumi.Input[_builtins.float] transaction_threshold_value: The threshold value for transactions(in seconds).
|
|
177
|
+
"""
|
|
178
|
+
if explain_query_plans is not None:
|
|
179
|
+
pulumi.set(__self__, "explain_query_plans", explain_query_plans)
|
|
180
|
+
if sql is not None:
|
|
181
|
+
pulumi.set(__self__, "sql", sql)
|
|
182
|
+
if stack_trace_threshold_value is not None:
|
|
183
|
+
pulumi.set(__self__, "stack_trace_threshold_value", stack_trace_threshold_value)
|
|
184
|
+
if transaction_threshold_type is not None:
|
|
185
|
+
pulumi.set(__self__, "transaction_threshold_type", transaction_threshold_type)
|
|
186
|
+
if transaction_threshold_value is not None:
|
|
187
|
+
pulumi.set(__self__, "transaction_threshold_value", transaction_threshold_value)
|
|
188
|
+
|
|
189
|
+
@_builtins.property
|
|
190
|
+
@pulumi.getter(name="explainQueryPlans")
|
|
191
|
+
def explain_query_plans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSettingsTransactionTracerExplainQueryPlanArgs']]]]:
|
|
192
|
+
"""
|
|
193
|
+
Configuration block for query plans. Including this block enables the capture of query plans. The following arguments are supported:
|
|
194
|
+
"""
|
|
195
|
+
return pulumi.get(self, "explain_query_plans")
|
|
196
|
+
|
|
197
|
+
@explain_query_plans.setter
|
|
198
|
+
def explain_query_plans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSettingsTransactionTracerExplainQueryPlanArgs']]]]):
|
|
199
|
+
pulumi.set(self, "explain_query_plans", value)
|
|
200
|
+
|
|
201
|
+
@_builtins.property
|
|
202
|
+
@pulumi.getter
|
|
203
|
+
def sql(self) -> Optional[pulumi.Input['ApplicationSettingsTransactionTracerSqlArgs']]:
|
|
204
|
+
"""
|
|
205
|
+
Configuration block for SQL logging. Including this block enables SQL logging. The following arguments are supported:
|
|
206
|
+
"""
|
|
207
|
+
return pulumi.get(self, "sql")
|
|
208
|
+
|
|
209
|
+
@sql.setter
|
|
210
|
+
def sql(self, value: Optional[pulumi.Input['ApplicationSettingsTransactionTracerSqlArgs']]):
|
|
211
|
+
pulumi.set(self, "sql", value)
|
|
212
|
+
|
|
213
|
+
@_builtins.property
|
|
214
|
+
@pulumi.getter(name="stackTraceThresholdValue")
|
|
215
|
+
def stack_trace_threshold_value(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
216
|
+
"""
|
|
217
|
+
The response time threshold for collecting stack traces.
|
|
218
|
+
"""
|
|
219
|
+
return pulumi.get(self, "stack_trace_threshold_value")
|
|
220
|
+
|
|
221
|
+
@stack_trace_threshold_value.setter
|
|
222
|
+
def stack_trace_threshold_value(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
223
|
+
pulumi.set(self, "stack_trace_threshold_value", value)
|
|
224
|
+
|
|
225
|
+
@_builtins.property
|
|
226
|
+
@pulumi.getter(name="transactionThresholdType")
|
|
227
|
+
def transaction_threshold_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
228
|
+
"""
|
|
229
|
+
The type of threshold for transactions. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
|
|
230
|
+
"""
|
|
231
|
+
return pulumi.get(self, "transaction_threshold_type")
|
|
232
|
+
|
|
233
|
+
@transaction_threshold_type.setter
|
|
234
|
+
def transaction_threshold_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
235
|
+
pulumi.set(self, "transaction_threshold_type", value)
|
|
236
|
+
|
|
237
|
+
@_builtins.property
|
|
238
|
+
@pulumi.getter(name="transactionThresholdValue")
|
|
239
|
+
def transaction_threshold_value(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
240
|
+
"""
|
|
241
|
+
The threshold value for transactions(in seconds).
|
|
242
|
+
"""
|
|
243
|
+
return pulumi.get(self, "transaction_threshold_value")
|
|
244
|
+
|
|
245
|
+
@transaction_threshold_value.setter
|
|
246
|
+
def transaction_threshold_value(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
247
|
+
pulumi.set(self, "transaction_threshold_value", value)
|
|
248
|
+
|
|
249
|
+
|
|
250
|
+
if not MYPY:
|
|
251
|
+
class ApplicationSettingsTransactionTracerExplainQueryPlanArgsDict(TypedDict):
|
|
252
|
+
query_plan_threshold_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
253
|
+
"""
|
|
254
|
+
The type of threshold for query plans. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
|
|
255
|
+
"""
|
|
256
|
+
query_plan_threshold_value: NotRequired[pulumi.Input[_builtins.float]]
|
|
257
|
+
"""
|
|
258
|
+
The response time threshold for capturing query plans(in seconds).
|
|
259
|
+
"""
|
|
260
|
+
elif False:
|
|
261
|
+
ApplicationSettingsTransactionTracerExplainQueryPlanArgsDict: TypeAlias = Mapping[str, Any]
|
|
262
|
+
|
|
263
|
+
@pulumi.input_type
|
|
264
|
+
class ApplicationSettingsTransactionTracerExplainQueryPlanArgs:
|
|
265
|
+
def __init__(__self__, *,
|
|
266
|
+
query_plan_threshold_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
267
|
+
query_plan_threshold_value: Optional[pulumi.Input[_builtins.float]] = None):
|
|
268
|
+
"""
|
|
269
|
+
:param pulumi.Input[_builtins.str] query_plan_threshold_type: The type of threshold for query plans. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
|
|
270
|
+
:param pulumi.Input[_builtins.float] query_plan_threshold_value: The response time threshold for capturing query plans(in seconds).
|
|
271
|
+
"""
|
|
272
|
+
if query_plan_threshold_type is not None:
|
|
273
|
+
pulumi.set(__self__, "query_plan_threshold_type", query_plan_threshold_type)
|
|
274
|
+
if query_plan_threshold_value is not None:
|
|
275
|
+
pulumi.set(__self__, "query_plan_threshold_value", query_plan_threshold_value)
|
|
276
|
+
|
|
277
|
+
@_builtins.property
|
|
278
|
+
@pulumi.getter(name="queryPlanThresholdType")
|
|
279
|
+
def query_plan_threshold_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
280
|
+
"""
|
|
281
|
+
The type of threshold for query plans. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
|
|
282
|
+
"""
|
|
283
|
+
return pulumi.get(self, "query_plan_threshold_type")
|
|
284
|
+
|
|
285
|
+
@query_plan_threshold_type.setter
|
|
286
|
+
def query_plan_threshold_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
287
|
+
pulumi.set(self, "query_plan_threshold_type", value)
|
|
288
|
+
|
|
289
|
+
@_builtins.property
|
|
290
|
+
@pulumi.getter(name="queryPlanThresholdValue")
|
|
291
|
+
def query_plan_threshold_value(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
292
|
+
"""
|
|
293
|
+
The response time threshold for capturing query plans(in seconds).
|
|
294
|
+
"""
|
|
295
|
+
return pulumi.get(self, "query_plan_threshold_value")
|
|
296
|
+
|
|
297
|
+
@query_plan_threshold_value.setter
|
|
298
|
+
def query_plan_threshold_value(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
299
|
+
pulumi.set(self, "query_plan_threshold_value", value)
|
|
300
|
+
|
|
301
|
+
|
|
302
|
+
if not MYPY:
|
|
303
|
+
class ApplicationSettingsTransactionTracerSqlArgsDict(TypedDict):
|
|
304
|
+
record_sql: pulumi.Input[_builtins.str]
|
|
305
|
+
"""
|
|
306
|
+
The level of SQL recording. Valid values ar `OBFUSCATED`,`OFF`,`RAW` (Mandatory attribute when `sql` block is provided).
|
|
307
|
+
"""
|
|
308
|
+
elif False:
|
|
309
|
+
ApplicationSettingsTransactionTracerSqlArgsDict: TypeAlias = Mapping[str, Any]
|
|
310
|
+
|
|
311
|
+
@pulumi.input_type
|
|
312
|
+
class ApplicationSettingsTransactionTracerSqlArgs:
|
|
313
|
+
def __init__(__self__, *,
|
|
314
|
+
record_sql: pulumi.Input[_builtins.str]):
|
|
315
|
+
"""
|
|
316
|
+
:param pulumi.Input[_builtins.str] record_sql: The level of SQL recording. Valid values ar `OBFUSCATED`,`OFF`,`RAW` (Mandatory attribute when `sql` block is provided).
|
|
317
|
+
"""
|
|
318
|
+
pulumi.set(__self__, "record_sql", record_sql)
|
|
319
|
+
|
|
320
|
+
@_builtins.property
|
|
321
|
+
@pulumi.getter(name="recordSql")
|
|
322
|
+
def record_sql(self) -> pulumi.Input[_builtins.str]:
|
|
323
|
+
"""
|
|
324
|
+
The level of SQL recording. Valid values ar `OBFUSCATED`,`OFF`,`RAW` (Mandatory attribute when `sql` block is provided).
|
|
325
|
+
"""
|
|
326
|
+
return pulumi.get(self, "record_sql")
|
|
327
|
+
|
|
328
|
+
@record_sql.setter
|
|
329
|
+
def record_sql(self, value: pulumi.Input[_builtins.str]):
|
|
330
|
+
pulumi.set(self, "record_sql", value)
|
|
331
|
+
|
|
332
|
+
|
|
333
|
+
if not MYPY:
|
|
334
|
+
class WorkloadEntitySearchQueryArgsDict(TypedDict):
|
|
335
|
+
query: pulumi.Input[_builtins.str]
|
|
336
|
+
"""
|
|
337
|
+
A valid entity search query; empty, and null values are considered invalid.
|
|
338
|
+
"""
|
|
339
|
+
elif False:
|
|
340
|
+
WorkloadEntitySearchQueryArgsDict: TypeAlias = Mapping[str, Any]
|
|
341
|
+
|
|
23
342
|
@pulumi.input_type
|
|
24
343
|
class WorkloadEntitySearchQueryArgs:
|
|
25
344
|
def __init__(__self__, *,
|
|
26
|
-
query: pulumi.Input[str]):
|
|
345
|
+
query: pulumi.Input[_builtins.str]):
|
|
27
346
|
"""
|
|
28
|
-
:param pulumi.Input[str] query: A valid entity search query; empty, and null values are considered invalid.
|
|
347
|
+
:param pulumi.Input[_builtins.str] query: A valid entity search query; empty, and null values are considered invalid.
|
|
29
348
|
"""
|
|
30
349
|
pulumi.set(__self__, "query", query)
|
|
31
350
|
|
|
32
|
-
@property
|
|
351
|
+
@_builtins.property
|
|
33
352
|
@pulumi.getter
|
|
34
|
-
def query(self) -> pulumi.Input[str]:
|
|
353
|
+
def query(self) -> pulumi.Input[_builtins.str]:
|
|
35
354
|
"""
|
|
36
355
|
A valid entity search query; empty, and null values are considered invalid.
|
|
37
356
|
"""
|
|
38
357
|
return pulumi.get(self, "query")
|
|
39
358
|
|
|
40
359
|
@query.setter
|
|
41
|
-
def query(self, value: pulumi.Input[str]):
|
|
360
|
+
def query(self, value: pulumi.Input[_builtins.str]):
|
|
42
361
|
pulumi.set(self, "query", value)
|
|
43
362
|
|
|
44
363
|
|
|
364
|
+
if not MYPY:
|
|
365
|
+
class WorkloadStatusConfigAutomaticArgsDict(TypedDict):
|
|
366
|
+
enabled: pulumi.Input[_builtins.bool]
|
|
367
|
+
"""
|
|
368
|
+
Whether the automatic status configuration is enabled or not.
|
|
369
|
+
"""
|
|
370
|
+
remaining_entities_rule: NotRequired[pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgsDict']]
|
|
371
|
+
"""
|
|
372
|
+
An additional meta-rule that can consider all entities that haven't been evaluated by any other rule.
|
|
373
|
+
"""
|
|
374
|
+
rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleArgsDict']]]]
|
|
375
|
+
"""
|
|
376
|
+
A list of rules.
|
|
377
|
+
"""
|
|
378
|
+
elif False:
|
|
379
|
+
WorkloadStatusConfigAutomaticArgsDict: TypeAlias = Mapping[str, Any]
|
|
380
|
+
|
|
45
381
|
@pulumi.input_type
|
|
46
382
|
class WorkloadStatusConfigAutomaticArgs:
|
|
47
383
|
def __init__(__self__, *,
|
|
48
|
-
enabled: pulumi.Input[bool],
|
|
384
|
+
enabled: pulumi.Input[_builtins.bool],
|
|
49
385
|
remaining_entities_rule: Optional[pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs']] = None,
|
|
50
386
|
rules: Optional[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleArgs']]]] = None):
|
|
51
387
|
"""
|
|
52
|
-
:param pulumi.Input[bool] enabled: Whether the
|
|
53
|
-
:param pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs'] remaining_entities_rule: An additional meta-rule that can consider all entities that haven't been evaluated by any other rule.
|
|
54
|
-
:param pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleArgs']]] rules:
|
|
388
|
+
:param pulumi.Input[_builtins.bool] enabled: Whether the automatic status configuration is enabled or not.
|
|
389
|
+
:param pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs'] remaining_entities_rule: An additional meta-rule that can consider all entities that haven't been evaluated by any other rule.
|
|
390
|
+
:param pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleArgs']]] rules: A list of rules.
|
|
55
391
|
"""
|
|
56
392
|
pulumi.set(__self__, "enabled", enabled)
|
|
57
393
|
if remaining_entities_rule is not None:
|
|
@@ -59,23 +395,23 @@ class WorkloadStatusConfigAutomaticArgs:
|
|
|
59
395
|
if rules is not None:
|
|
60
396
|
pulumi.set(__self__, "rules", rules)
|
|
61
397
|
|
|
62
|
-
@property
|
|
398
|
+
@_builtins.property
|
|
63
399
|
@pulumi.getter
|
|
64
|
-
def enabled(self) -> pulumi.Input[bool]:
|
|
400
|
+
def enabled(self) -> pulumi.Input[_builtins.bool]:
|
|
65
401
|
"""
|
|
66
|
-
Whether the
|
|
402
|
+
Whether the automatic status configuration is enabled or not.
|
|
67
403
|
"""
|
|
68
404
|
return pulumi.get(self, "enabled")
|
|
69
405
|
|
|
70
406
|
@enabled.setter
|
|
71
|
-
def enabled(self, value: pulumi.Input[bool]):
|
|
407
|
+
def enabled(self, value: pulumi.Input[_builtins.bool]):
|
|
72
408
|
pulumi.set(self, "enabled", value)
|
|
73
409
|
|
|
74
|
-
@property
|
|
410
|
+
@_builtins.property
|
|
75
411
|
@pulumi.getter(name="remainingEntitiesRule")
|
|
76
412
|
def remaining_entities_rule(self) -> Optional[pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs']]:
|
|
77
413
|
"""
|
|
78
|
-
An additional meta-rule that can consider all entities that haven't been evaluated by any other rule.
|
|
414
|
+
An additional meta-rule that can consider all entities that haven't been evaluated by any other rule.
|
|
79
415
|
"""
|
|
80
416
|
return pulumi.get(self, "remaining_entities_rule")
|
|
81
417
|
|
|
@@ -83,11 +419,11 @@ class WorkloadStatusConfigAutomaticArgs:
|
|
|
83
419
|
def remaining_entities_rule(self, value: Optional[pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs']]):
|
|
84
420
|
pulumi.set(self, "remaining_entities_rule", value)
|
|
85
421
|
|
|
86
|
-
@property
|
|
422
|
+
@_builtins.property
|
|
87
423
|
@pulumi.getter
|
|
88
424
|
def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleArgs']]]]:
|
|
89
425
|
"""
|
|
90
|
-
|
|
426
|
+
A list of rules.
|
|
91
427
|
"""
|
|
92
428
|
return pulumi.get(self, "rules")
|
|
93
429
|
|
|
@@ -96,20 +432,29 @@ class WorkloadStatusConfigAutomaticArgs:
|
|
|
96
432
|
pulumi.set(self, "rules", value)
|
|
97
433
|
|
|
98
434
|
|
|
435
|
+
if not MYPY:
|
|
436
|
+
class WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgsDict(TypedDict):
|
|
437
|
+
remaining_entities_rule_rollup: pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgsDict']
|
|
438
|
+
"""
|
|
439
|
+
The input object used to represent a rollup strategy.
|
|
440
|
+
"""
|
|
441
|
+
elif False:
|
|
442
|
+
WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
443
|
+
|
|
99
444
|
@pulumi.input_type
|
|
100
445
|
class WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs:
|
|
101
446
|
def __init__(__self__, *,
|
|
102
447
|
remaining_entities_rule_rollup: pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs']):
|
|
103
448
|
"""
|
|
104
|
-
:param pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs'] remaining_entities_rule_rollup: The input object used to represent a rollup strategy.
|
|
449
|
+
:param pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs'] remaining_entities_rule_rollup: The input object used to represent a rollup strategy.
|
|
105
450
|
"""
|
|
106
451
|
pulumi.set(__self__, "remaining_entities_rule_rollup", remaining_entities_rule_rollup)
|
|
107
452
|
|
|
108
|
-
@property
|
|
453
|
+
@_builtins.property
|
|
109
454
|
@pulumi.getter(name="remainingEntitiesRuleRollup")
|
|
110
455
|
def remaining_entities_rule_rollup(self) -> pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs']:
|
|
111
456
|
"""
|
|
112
|
-
The input object used to represent a rollup strategy.
|
|
457
|
+
The input object used to represent a rollup strategy.
|
|
113
458
|
"""
|
|
114
459
|
return pulumi.get(self, "remaining_entities_rule_rollup")
|
|
115
460
|
|
|
@@ -118,18 +463,39 @@ class WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs:
|
|
|
118
463
|
pulumi.set(self, "remaining_entities_rule_rollup", value)
|
|
119
464
|
|
|
120
465
|
|
|
466
|
+
if not MYPY:
|
|
467
|
+
class WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgsDict(TypedDict):
|
|
468
|
+
group_by: pulumi.Input[_builtins.str]
|
|
469
|
+
"""
|
|
470
|
+
The grouping to be applied to the remaining entities.
|
|
471
|
+
"""
|
|
472
|
+
strategy: pulumi.Input[_builtins.str]
|
|
473
|
+
"""
|
|
474
|
+
The rollup strategy that is applied to a group of entities.
|
|
475
|
+
"""
|
|
476
|
+
threshold_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
477
|
+
"""
|
|
478
|
+
Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
|
|
479
|
+
"""
|
|
480
|
+
threshold_value: NotRequired[pulumi.Input[_builtins.int]]
|
|
481
|
+
"""
|
|
482
|
+
Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
|
|
483
|
+
"""
|
|
484
|
+
elif False:
|
|
485
|
+
WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgsDict: TypeAlias = Mapping[str, Any]
|
|
486
|
+
|
|
121
487
|
@pulumi.input_type
|
|
122
488
|
class WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs:
|
|
123
489
|
def __init__(__self__, *,
|
|
124
|
-
group_by: pulumi.Input[str],
|
|
125
|
-
strategy: pulumi.Input[str],
|
|
126
|
-
threshold_type: Optional[pulumi.Input[str]] = None,
|
|
127
|
-
threshold_value: Optional[pulumi.Input[int]] = None):
|
|
490
|
+
group_by: pulumi.Input[_builtins.str],
|
|
491
|
+
strategy: pulumi.Input[_builtins.str],
|
|
492
|
+
threshold_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
493
|
+
threshold_value: Optional[pulumi.Input[_builtins.int]] = None):
|
|
128
494
|
"""
|
|
129
|
-
:param pulumi.Input[str] group_by: The grouping to be applied to the remaining entities.
|
|
130
|
-
:param pulumi.Input[str] strategy: The rollup strategy that is applied to a group of entities.
|
|
131
|
-
:param pulumi.Input[str] threshold_type: Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
|
|
132
|
-
:param pulumi.Input[int] threshold_value: Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
|
|
495
|
+
:param pulumi.Input[_builtins.str] group_by: The grouping to be applied to the remaining entities.
|
|
496
|
+
:param pulumi.Input[_builtins.str] strategy: The rollup strategy that is applied to a group of entities.
|
|
497
|
+
:param pulumi.Input[_builtins.str] threshold_type: Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
|
|
498
|
+
:param pulumi.Input[_builtins.int] threshold_value: Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
|
|
133
499
|
"""
|
|
134
500
|
pulumi.set(__self__, "group_by", group_by)
|
|
135
501
|
pulumi.set(__self__, "strategy", strategy)
|
|
@@ -138,64 +504,81 @@ class WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRol
|
|
|
138
504
|
if threshold_value is not None:
|
|
139
505
|
pulumi.set(__self__, "threshold_value", threshold_value)
|
|
140
506
|
|
|
141
|
-
@property
|
|
507
|
+
@_builtins.property
|
|
142
508
|
@pulumi.getter(name="groupBy")
|
|
143
|
-
def group_by(self) -> pulumi.Input[str]:
|
|
509
|
+
def group_by(self) -> pulumi.Input[_builtins.str]:
|
|
144
510
|
"""
|
|
145
511
|
The grouping to be applied to the remaining entities.
|
|
146
512
|
"""
|
|
147
513
|
return pulumi.get(self, "group_by")
|
|
148
514
|
|
|
149
515
|
@group_by.setter
|
|
150
|
-
def group_by(self, value: pulumi.Input[str]):
|
|
516
|
+
def group_by(self, value: pulumi.Input[_builtins.str]):
|
|
151
517
|
pulumi.set(self, "group_by", value)
|
|
152
518
|
|
|
153
|
-
@property
|
|
519
|
+
@_builtins.property
|
|
154
520
|
@pulumi.getter
|
|
155
|
-
def strategy(self) -> pulumi.Input[str]:
|
|
521
|
+
def strategy(self) -> pulumi.Input[_builtins.str]:
|
|
156
522
|
"""
|
|
157
523
|
The rollup strategy that is applied to a group of entities.
|
|
158
524
|
"""
|
|
159
525
|
return pulumi.get(self, "strategy")
|
|
160
526
|
|
|
161
527
|
@strategy.setter
|
|
162
|
-
def strategy(self, value: pulumi.Input[str]):
|
|
528
|
+
def strategy(self, value: pulumi.Input[_builtins.str]):
|
|
163
529
|
pulumi.set(self, "strategy", value)
|
|
164
530
|
|
|
165
|
-
@property
|
|
531
|
+
@_builtins.property
|
|
166
532
|
@pulumi.getter(name="thresholdType")
|
|
167
|
-
def threshold_type(self) -> Optional[pulumi.Input[str]]:
|
|
533
|
+
def threshold_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
168
534
|
"""
|
|
169
535
|
Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
|
|
170
536
|
"""
|
|
171
537
|
return pulumi.get(self, "threshold_type")
|
|
172
538
|
|
|
173
539
|
@threshold_type.setter
|
|
174
|
-
def threshold_type(self, value: Optional[pulumi.Input[str]]):
|
|
540
|
+
def threshold_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
175
541
|
pulumi.set(self, "threshold_type", value)
|
|
176
542
|
|
|
177
|
-
@property
|
|
543
|
+
@_builtins.property
|
|
178
544
|
@pulumi.getter(name="thresholdValue")
|
|
179
|
-
def threshold_value(self) -> Optional[pulumi.Input[int]]:
|
|
545
|
+
def threshold_value(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
180
546
|
"""
|
|
181
547
|
Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
|
|
182
548
|
"""
|
|
183
549
|
return pulumi.get(self, "threshold_value")
|
|
184
550
|
|
|
185
551
|
@threshold_value.setter
|
|
186
|
-
def threshold_value(self, value: Optional[pulumi.Input[int]]):
|
|
552
|
+
def threshold_value(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
187
553
|
pulumi.set(self, "threshold_value", value)
|
|
188
554
|
|
|
189
555
|
|
|
556
|
+
if not MYPY:
|
|
557
|
+
class WorkloadStatusConfigAutomaticRuleArgsDict(TypedDict):
|
|
558
|
+
rollup: pulumi.Input['WorkloadStatusConfigAutomaticRuleRollupArgsDict']
|
|
559
|
+
"""
|
|
560
|
+
The input object used to represent a rollup strategy. See Nested rollup blocks below for details.
|
|
561
|
+
"""
|
|
562
|
+
entity_guids: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
563
|
+
"""
|
|
564
|
+
A list of entity GUIDs composing the rule. At least one of `entity_guids` or `nrql_query` must be defined.
|
|
565
|
+
"""
|
|
566
|
+
nrql_queries: NotRequired[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleNrqlQueryArgsDict']]]]
|
|
567
|
+
"""
|
|
568
|
+
A list of entity search queries used to retrieve the entities that compose the rule. See Nested nrql_query blocks below for details. At least one of `entity_guids` or `nrql_query` must be defined.
|
|
569
|
+
"""
|
|
570
|
+
elif False:
|
|
571
|
+
WorkloadStatusConfigAutomaticRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
572
|
+
|
|
190
573
|
@pulumi.input_type
|
|
191
574
|
class WorkloadStatusConfigAutomaticRuleArgs:
|
|
192
575
|
def __init__(__self__, *,
|
|
193
576
|
rollup: pulumi.Input['WorkloadStatusConfigAutomaticRuleRollupArgs'],
|
|
194
|
-
entity_guids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
577
|
+
entity_guids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
195
578
|
nrql_queries: Optional[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleNrqlQueryArgs']]]] = None):
|
|
196
579
|
"""
|
|
197
580
|
:param pulumi.Input['WorkloadStatusConfigAutomaticRuleRollupArgs'] rollup: The input object used to represent a rollup strategy. See Nested rollup blocks below for details.
|
|
198
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] entity_guids: A list of entity GUIDs composing the rule. At least one of `entity_guids` or `nrql_query` must be defined.
|
|
581
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] entity_guids: A list of entity GUIDs composing the rule. At least one of `entity_guids` or `nrql_query` must be defined.
|
|
199
582
|
:param pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleNrqlQueryArgs']]] nrql_queries: A list of entity search queries used to retrieve the entities that compose the rule. See Nested nrql_query blocks below for details. At least one of `entity_guids` or `nrql_query` must be defined.
|
|
200
583
|
"""
|
|
201
584
|
pulumi.set(__self__, "rollup", rollup)
|
|
@@ -204,7 +587,7 @@ class WorkloadStatusConfigAutomaticRuleArgs:
|
|
|
204
587
|
if nrql_queries is not None:
|
|
205
588
|
pulumi.set(__self__, "nrql_queries", nrql_queries)
|
|
206
589
|
|
|
207
|
-
@property
|
|
590
|
+
@_builtins.property
|
|
208
591
|
@pulumi.getter
|
|
209
592
|
def rollup(self) -> pulumi.Input['WorkloadStatusConfigAutomaticRuleRollupArgs']:
|
|
210
593
|
"""
|
|
@@ -216,19 +599,19 @@ class WorkloadStatusConfigAutomaticRuleArgs:
|
|
|
216
599
|
def rollup(self, value: pulumi.Input['WorkloadStatusConfigAutomaticRuleRollupArgs']):
|
|
217
600
|
pulumi.set(self, "rollup", value)
|
|
218
601
|
|
|
219
|
-
@property
|
|
602
|
+
@_builtins.property
|
|
220
603
|
@pulumi.getter(name="entityGuids")
|
|
221
|
-
def entity_guids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
604
|
+
def entity_guids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
222
605
|
"""
|
|
223
606
|
A list of entity GUIDs composing the rule. At least one of `entity_guids` or `nrql_query` must be defined.
|
|
224
607
|
"""
|
|
225
608
|
return pulumi.get(self, "entity_guids")
|
|
226
609
|
|
|
227
610
|
@entity_guids.setter
|
|
228
|
-
def entity_guids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
611
|
+
def entity_guids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
229
612
|
pulumi.set(self, "entity_guids", value)
|
|
230
613
|
|
|
231
|
-
@property
|
|
614
|
+
@_builtins.property
|
|
232
615
|
@pulumi.getter(name="nrqlQueries")
|
|
233
616
|
def nrql_queries(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleNrqlQueryArgs']]]]:
|
|
234
617
|
"""
|
|
@@ -241,38 +624,64 @@ class WorkloadStatusConfigAutomaticRuleArgs:
|
|
|
241
624
|
pulumi.set(self, "nrql_queries", value)
|
|
242
625
|
|
|
243
626
|
|
|
627
|
+
if not MYPY:
|
|
628
|
+
class WorkloadStatusConfigAutomaticRuleNrqlQueryArgsDict(TypedDict):
|
|
629
|
+
query: pulumi.Input[_builtins.str]
|
|
630
|
+
"""
|
|
631
|
+
The entity search query that is used to perform the search of a group of entities.
|
|
632
|
+
"""
|
|
633
|
+
elif False:
|
|
634
|
+
WorkloadStatusConfigAutomaticRuleNrqlQueryArgsDict: TypeAlias = Mapping[str, Any]
|
|
635
|
+
|
|
244
636
|
@pulumi.input_type
|
|
245
637
|
class WorkloadStatusConfigAutomaticRuleNrqlQueryArgs:
|
|
246
638
|
def __init__(__self__, *,
|
|
247
|
-
query: pulumi.Input[str]):
|
|
639
|
+
query: pulumi.Input[_builtins.str]):
|
|
248
640
|
"""
|
|
249
|
-
:param pulumi.Input[str] query: The entity search query that is used to perform the search of a group of entities.
|
|
641
|
+
:param pulumi.Input[_builtins.str] query: The entity search query that is used to perform the search of a group of entities.
|
|
250
642
|
"""
|
|
251
643
|
pulumi.set(__self__, "query", query)
|
|
252
644
|
|
|
253
|
-
@property
|
|
645
|
+
@_builtins.property
|
|
254
646
|
@pulumi.getter
|
|
255
|
-
def query(self) -> pulumi.Input[str]:
|
|
647
|
+
def query(self) -> pulumi.Input[_builtins.str]:
|
|
256
648
|
"""
|
|
257
649
|
The entity search query that is used to perform the search of a group of entities.
|
|
258
650
|
"""
|
|
259
651
|
return pulumi.get(self, "query")
|
|
260
652
|
|
|
261
653
|
@query.setter
|
|
262
|
-
def query(self, value: pulumi.Input[str]):
|
|
654
|
+
def query(self, value: pulumi.Input[_builtins.str]):
|
|
263
655
|
pulumi.set(self, "query", value)
|
|
264
656
|
|
|
265
657
|
|
|
658
|
+
if not MYPY:
|
|
659
|
+
class WorkloadStatusConfigAutomaticRuleRollupArgsDict(TypedDict):
|
|
660
|
+
strategy: pulumi.Input[_builtins.str]
|
|
661
|
+
"""
|
|
662
|
+
The rollup strategy that is applied to a group of entities.
|
|
663
|
+
"""
|
|
664
|
+
threshold_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
665
|
+
"""
|
|
666
|
+
Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
|
|
667
|
+
"""
|
|
668
|
+
threshold_value: NotRequired[pulumi.Input[_builtins.int]]
|
|
669
|
+
"""
|
|
670
|
+
Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
|
|
671
|
+
"""
|
|
672
|
+
elif False:
|
|
673
|
+
WorkloadStatusConfigAutomaticRuleRollupArgsDict: TypeAlias = Mapping[str, Any]
|
|
674
|
+
|
|
266
675
|
@pulumi.input_type
|
|
267
676
|
class WorkloadStatusConfigAutomaticRuleRollupArgs:
|
|
268
677
|
def __init__(__self__, *,
|
|
269
|
-
strategy: pulumi.Input[str],
|
|
270
|
-
threshold_type: Optional[pulumi.Input[str]] = None,
|
|
271
|
-
threshold_value: Optional[pulumi.Input[int]] = None):
|
|
678
|
+
strategy: pulumi.Input[_builtins.str],
|
|
679
|
+
threshold_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
680
|
+
threshold_value: Optional[pulumi.Input[_builtins.int]] = None):
|
|
272
681
|
"""
|
|
273
|
-
:param pulumi.Input[str] strategy: The rollup strategy that is applied to a group of entities.
|
|
274
|
-
:param pulumi.Input[str] threshold_type: Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
|
|
275
|
-
:param pulumi.Input[int] threshold_value: Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
|
|
682
|
+
:param pulumi.Input[_builtins.str] strategy: The rollup strategy that is applied to a group of entities.
|
|
683
|
+
:param pulumi.Input[_builtins.str] threshold_type: Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
|
|
684
|
+
:param pulumi.Input[_builtins.int] threshold_value: Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
|
|
276
685
|
"""
|
|
277
686
|
pulumi.set(__self__, "strategy", strategy)
|
|
278
687
|
if threshold_type is not None:
|
|
@@ -280,55 +689,76 @@ class WorkloadStatusConfigAutomaticRuleRollupArgs:
|
|
|
280
689
|
if threshold_value is not None:
|
|
281
690
|
pulumi.set(__self__, "threshold_value", threshold_value)
|
|
282
691
|
|
|
283
|
-
@property
|
|
692
|
+
@_builtins.property
|
|
284
693
|
@pulumi.getter
|
|
285
|
-
def strategy(self) -> pulumi.Input[str]:
|
|
694
|
+
def strategy(self) -> pulumi.Input[_builtins.str]:
|
|
286
695
|
"""
|
|
287
696
|
The rollup strategy that is applied to a group of entities.
|
|
288
697
|
"""
|
|
289
698
|
return pulumi.get(self, "strategy")
|
|
290
699
|
|
|
291
700
|
@strategy.setter
|
|
292
|
-
def strategy(self, value: pulumi.Input[str]):
|
|
701
|
+
def strategy(self, value: pulumi.Input[_builtins.str]):
|
|
293
702
|
pulumi.set(self, "strategy", value)
|
|
294
703
|
|
|
295
|
-
@property
|
|
704
|
+
@_builtins.property
|
|
296
705
|
@pulumi.getter(name="thresholdType")
|
|
297
|
-
def threshold_type(self) -> Optional[pulumi.Input[str]]:
|
|
706
|
+
def threshold_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
298
707
|
"""
|
|
299
708
|
Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
|
|
300
709
|
"""
|
|
301
710
|
return pulumi.get(self, "threshold_type")
|
|
302
711
|
|
|
303
712
|
@threshold_type.setter
|
|
304
|
-
def threshold_type(self, value: Optional[pulumi.Input[str]]):
|
|
713
|
+
def threshold_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
305
714
|
pulumi.set(self, "threshold_type", value)
|
|
306
715
|
|
|
307
|
-
@property
|
|
716
|
+
@_builtins.property
|
|
308
717
|
@pulumi.getter(name="thresholdValue")
|
|
309
|
-
def threshold_value(self) -> Optional[pulumi.Input[int]]:
|
|
718
|
+
def threshold_value(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
310
719
|
"""
|
|
311
720
|
Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
|
|
312
721
|
"""
|
|
313
722
|
return pulumi.get(self, "threshold_value")
|
|
314
723
|
|
|
315
724
|
@threshold_value.setter
|
|
316
|
-
def threshold_value(self, value: Optional[pulumi.Input[int]]):
|
|
725
|
+
def threshold_value(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
317
726
|
pulumi.set(self, "threshold_value", value)
|
|
318
727
|
|
|
319
728
|
|
|
729
|
+
if not MYPY:
|
|
730
|
+
class WorkloadStatusConfigStaticArgsDict(TypedDict):
|
|
731
|
+
enabled: pulumi.Input[_builtins.bool]
|
|
732
|
+
"""
|
|
733
|
+
Whether the static status configuration is enabled or not.
|
|
734
|
+
"""
|
|
735
|
+
status: pulumi.Input[_builtins.str]
|
|
736
|
+
"""
|
|
737
|
+
The status of the workload.
|
|
738
|
+
"""
|
|
739
|
+
description: NotRequired[pulumi.Input[_builtins.str]]
|
|
740
|
+
"""
|
|
741
|
+
Relevant information about the workload.
|
|
742
|
+
"""
|
|
743
|
+
summary: NotRequired[pulumi.Input[_builtins.str]]
|
|
744
|
+
"""
|
|
745
|
+
A short description of the status of the workload.
|
|
746
|
+
"""
|
|
747
|
+
elif False:
|
|
748
|
+
WorkloadStatusConfigStaticArgsDict: TypeAlias = Mapping[str, Any]
|
|
749
|
+
|
|
320
750
|
@pulumi.input_type
|
|
321
751
|
class WorkloadStatusConfigStaticArgs:
|
|
322
752
|
def __init__(__self__, *,
|
|
323
|
-
enabled: pulumi.Input[bool],
|
|
324
|
-
status: pulumi.Input[str],
|
|
325
|
-
description: Optional[pulumi.Input[str]] = None,
|
|
326
|
-
summary: Optional[pulumi.Input[str]] = None):
|
|
753
|
+
enabled: pulumi.Input[_builtins.bool],
|
|
754
|
+
status: pulumi.Input[_builtins.str],
|
|
755
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
756
|
+
summary: Optional[pulumi.Input[_builtins.str]] = None):
|
|
327
757
|
"""
|
|
328
|
-
:param pulumi.Input[bool] enabled: Whether the static status configuration is enabled or not.
|
|
329
|
-
:param pulumi.Input[str] status: The status of the workload.
|
|
330
|
-
:param pulumi.Input[str] description: Relevant information about the workload.
|
|
331
|
-
:param pulumi.Input[str] summary: A short description of the status of the workload.
|
|
758
|
+
:param pulumi.Input[_builtins.bool] enabled: Whether the static status configuration is enabled or not.
|
|
759
|
+
:param pulumi.Input[_builtins.str] status: The status of the workload.
|
|
760
|
+
:param pulumi.Input[_builtins.str] description: Relevant information about the workload.
|
|
761
|
+
:param pulumi.Input[_builtins.str] summary: A short description of the status of the workload.
|
|
332
762
|
"""
|
|
333
763
|
pulumi.set(__self__, "enabled", enabled)
|
|
334
764
|
pulumi.set(__self__, "status", status)
|
|
@@ -337,52 +767,52 @@ class WorkloadStatusConfigStaticArgs:
|
|
|
337
767
|
if summary is not None:
|
|
338
768
|
pulumi.set(__self__, "summary", summary)
|
|
339
769
|
|
|
340
|
-
@property
|
|
770
|
+
@_builtins.property
|
|
341
771
|
@pulumi.getter
|
|
342
|
-
def enabled(self) -> pulumi.Input[bool]:
|
|
772
|
+
def enabled(self) -> pulumi.Input[_builtins.bool]:
|
|
343
773
|
"""
|
|
344
774
|
Whether the static status configuration is enabled or not.
|
|
345
775
|
"""
|
|
346
776
|
return pulumi.get(self, "enabled")
|
|
347
777
|
|
|
348
778
|
@enabled.setter
|
|
349
|
-
def enabled(self, value: pulumi.Input[bool]):
|
|
779
|
+
def enabled(self, value: pulumi.Input[_builtins.bool]):
|
|
350
780
|
pulumi.set(self, "enabled", value)
|
|
351
781
|
|
|
352
|
-
@property
|
|
782
|
+
@_builtins.property
|
|
353
783
|
@pulumi.getter
|
|
354
|
-
def status(self) -> pulumi.Input[str]:
|
|
784
|
+
def status(self) -> pulumi.Input[_builtins.str]:
|
|
355
785
|
"""
|
|
356
786
|
The status of the workload.
|
|
357
787
|
"""
|
|
358
788
|
return pulumi.get(self, "status")
|
|
359
789
|
|
|
360
790
|
@status.setter
|
|
361
|
-
def status(self, value: pulumi.Input[str]):
|
|
791
|
+
def status(self, value: pulumi.Input[_builtins.str]):
|
|
362
792
|
pulumi.set(self, "status", value)
|
|
363
793
|
|
|
364
|
-
@property
|
|
794
|
+
@_builtins.property
|
|
365
795
|
@pulumi.getter
|
|
366
|
-
def description(self) -> Optional[pulumi.Input[str]]:
|
|
796
|
+
def description(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
367
797
|
"""
|
|
368
798
|
Relevant information about the workload.
|
|
369
799
|
"""
|
|
370
800
|
return pulumi.get(self, "description")
|
|
371
801
|
|
|
372
802
|
@description.setter
|
|
373
|
-
def description(self, value: Optional[pulumi.Input[str]]):
|
|
803
|
+
def description(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
374
804
|
pulumi.set(self, "description", value)
|
|
375
805
|
|
|
376
|
-
@property
|
|
806
|
+
@_builtins.property
|
|
377
807
|
@pulumi.getter
|
|
378
|
-
def summary(self) -> Optional[pulumi.Input[str]]:
|
|
808
|
+
def summary(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
379
809
|
"""
|
|
380
810
|
A short description of the status of the workload.
|
|
381
811
|
"""
|
|
382
812
|
return pulumi.get(self, "summary")
|
|
383
813
|
|
|
384
814
|
@summary.setter
|
|
385
|
-
def summary(self, value: Optional[pulumi.Input[str]]):
|
|
815
|
+
def summary(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
386
816
|
pulumi.set(self, "summary", value)
|
|
387
817
|
|
|
388
818
|
|