pulumi-newrelic 5.49.0a1753337775__py3-none-any.whl → 5.49.0a1753398082__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 +1 -1
- pulumi_newrelic/_inputs.py +3759 -3760
- pulumi_newrelic/account_management.py +35 -36
- pulumi_newrelic/alert_channel.py +55 -56
- pulumi_newrelic/alert_condition.py +217 -218
- pulumi_newrelic/alert_muting_rule.py +92 -93
- pulumi_newrelic/alert_policy.py +69 -70
- pulumi_newrelic/alert_policy_channel.py +52 -53
- pulumi_newrelic/api_access_key.py +112 -113
- pulumi_newrelic/browser_application.py +113 -114
- pulumi_newrelic/cloud/__init__.py +1 -1
- pulumi_newrelic/cloud/_inputs.py +2129 -2130
- pulumi_newrelic/cloud/aws_govcloud_integrations.py +95 -96
- pulumi_newrelic/cloud/aws_govcloud_link_account.py +69 -70
- pulumi_newrelic/cloud/aws_integrations.py +194 -195
- pulumi_newrelic/cloud/aws_link_account.py +69 -70
- pulumi_newrelic/cloud/azure_integrations.py +131 -132
- pulumi_newrelic/cloud/azure_link_account.py +103 -104
- pulumi_newrelic/cloud/gcp_integrations.py +113 -114
- pulumi_newrelic/cloud/gcp_link_account.py +52 -53
- pulumi_newrelic/cloud/outputs.py +1417 -1418
- pulumi_newrelic/config/__init__.py +1 -1
- pulumi_newrelic/config/__init__.pyi +1 -2
- pulumi_newrelic/config/vars.py +14 -15
- pulumi_newrelic/data_partition_rule.py +112 -113
- pulumi_newrelic/entity_tags.py +21 -22
- pulumi_newrelic/events_to_metrics_rule.py +95 -96
- pulumi_newrelic/get_account.py +21 -22
- pulumi_newrelic/get_alert_channel.py +20 -21
- pulumi_newrelic/get_alert_policy.py +25 -26
- pulumi_newrelic/get_application.py +13 -14
- pulumi_newrelic/get_authentication_domain.py +9 -10
- pulumi_newrelic/get_cloud_account.py +21 -22
- pulumi_newrelic/get_entity.py +52 -53
- pulumi_newrelic/get_group.py +17 -18
- pulumi_newrelic/get_key_transaction.py +25 -26
- pulumi_newrelic/get_notification_destination.py +29 -30
- pulumi_newrelic/get_obfuscation_expression.py +15 -16
- pulumi_newrelic/get_service_level_alert_helper.py +53 -54
- pulumi_newrelic/get_test_grok_pattern.py +22 -23
- pulumi_newrelic/get_user.py +21 -22
- pulumi_newrelic/group.py +52 -53
- pulumi_newrelic/infra_alert_condition.py +255 -256
- pulumi_newrelic/insights/__init__.py +1 -1
- pulumi_newrelic/insights/_inputs.py +32 -33
- pulumi_newrelic/insights/event.py +4 -5
- pulumi_newrelic/insights/outputs.py +22 -23
- pulumi_newrelic/key_transaction.py +104 -105
- pulumi_newrelic/log_parsing_rule.py +146 -147
- pulumi_newrelic/monitor_downtime.py +143 -144
- pulumi_newrelic/notification_channel.py +115 -116
- pulumi_newrelic/notification_destination.py +111 -112
- pulumi_newrelic/nrql_alert_condition.py +430 -431
- pulumi_newrelic/nrql_drop_rule.py +78 -79
- pulumi_newrelic/obfuscation_expression.py +69 -70
- pulumi_newrelic/obfuscation_rule.py +89 -90
- pulumi_newrelic/one_dashboard.py +93 -94
- pulumi_newrelic/one_dashboard_json.py +62 -63
- pulumi_newrelic/one_dashboard_raw.py +90 -91
- pulumi_newrelic/outputs.py +2646 -2647
- pulumi_newrelic/plugins/__init__.py +1 -1
- pulumi_newrelic/plugins/_inputs.py +158 -159
- pulumi_newrelic/plugins/application_settings.py +167 -168
- pulumi_newrelic/plugins/outputs.py +108 -109
- pulumi_newrelic/plugins/workload.py +131 -132
- pulumi_newrelic/provider.py +106 -107
- pulumi_newrelic/pulumi-plugin.json +1 -1
- pulumi_newrelic/service_level.py +76 -77
- pulumi_newrelic/synthetics/__init__.py +1 -1
- pulumi_newrelic/synthetics/_inputs.py +127 -128
- pulumi_newrelic/synthetics/alert_condition.py +95 -96
- pulumi_newrelic/synthetics/broken_links_monitor.py +197 -198
- pulumi_newrelic/synthetics/cert_check_monitor.py +205 -206
- pulumi_newrelic/synthetics/get_private_location.py +21 -22
- pulumi_newrelic/synthetics/get_secure_credential.py +19 -20
- pulumi_newrelic/synthetics/monitor.py +378 -379
- pulumi_newrelic/synthetics/multi_location_alert_condition.py +118 -119
- pulumi_newrelic/synthetics/outputs.py +85 -86
- pulumi_newrelic/synthetics/private_location.py +105 -106
- pulumi_newrelic/synthetics/script_monitor.py +302 -303
- pulumi_newrelic/synthetics/secure_credential.py +86 -87
- pulumi_newrelic/synthetics/step_monitor.py +220 -221
- pulumi_newrelic/user.py +69 -70
- pulumi_newrelic/workflow.py +139 -140
- {pulumi_newrelic-5.49.0a1753337775.dist-info → pulumi_newrelic-5.49.0a1753398082.dist-info}/METADATA +1 -1
- pulumi_newrelic-5.49.0a1753398082.dist-info/RECORD +90 -0
- pulumi_newrelic-5.49.0a1753337775.dist-info/RECORD +0 -90
- {pulumi_newrelic-5.49.0a1753337775.dist-info → pulumi_newrelic-5.49.0a1753398082.dist-info}/WHEEL +0 -0
- {pulumi_newrelic-5.49.0a1753337775.dist-info → pulumi_newrelic-5.49.0a1753398082.dist-info}/top_level.txt +0 -0
|
@@ -2,8 +2,7 @@
|
|
|
2
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 builtins
|
|
6
|
-
import copy
|
|
5
|
+
import builtins as _builtins
|
|
7
6
|
import warnings
|
|
8
7
|
import sys
|
|
9
8
|
import pulumi
|
|
@@ -46,19 +45,19 @@ MYPY = False
|
|
|
46
45
|
|
|
47
46
|
if not MYPY:
|
|
48
47
|
class ApplicationSettingsErrorCollectorArgsDict(TypedDict):
|
|
49
|
-
expected_error_classes: NotRequired[pulumi.Input[Sequence[pulumi.Input[
|
|
48
|
+
expected_error_classes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
50
49
|
"""
|
|
51
50
|
A list of expected error classes.
|
|
52
51
|
"""
|
|
53
|
-
expected_error_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[
|
|
52
|
+
expected_error_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
54
53
|
"""
|
|
55
54
|
A list of expected error codes(any status code between 100-900).
|
|
56
55
|
"""
|
|
57
|
-
ignored_error_classes: NotRequired[pulumi.Input[Sequence[pulumi.Input[
|
|
56
|
+
ignored_error_classes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
58
57
|
"""
|
|
59
58
|
A list of ignored error classes.
|
|
60
59
|
"""
|
|
61
|
-
ignored_error_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[
|
|
60
|
+
ignored_error_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
62
61
|
"""
|
|
63
62
|
A list of ignored error codes(any status code between 100-900).
|
|
64
63
|
"""
|
|
@@ -68,15 +67,15 @@ elif False:
|
|
|
68
67
|
@pulumi.input_type
|
|
69
68
|
class ApplicationSettingsErrorCollectorArgs:
|
|
70
69
|
def __init__(__self__, *,
|
|
71
|
-
expected_error_classes: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
72
|
-
expected_error_codes: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
73
|
-
ignored_error_classes: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
74
|
-
ignored_error_codes: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
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):
|
|
75
74
|
"""
|
|
76
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
77
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
78
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
79
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
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).
|
|
80
79
|
"""
|
|
81
80
|
if expected_error_classes is not None:
|
|
82
81
|
pulumi.set(__self__, "expected_error_classes", expected_error_classes)
|
|
@@ -87,52 +86,52 @@ class ApplicationSettingsErrorCollectorArgs:
|
|
|
87
86
|
if ignored_error_codes is not None:
|
|
88
87
|
pulumi.set(__self__, "ignored_error_codes", ignored_error_codes)
|
|
89
88
|
|
|
90
|
-
@property
|
|
89
|
+
@_builtins.property
|
|
91
90
|
@pulumi.getter(name="expectedErrorClasses")
|
|
92
|
-
def expected_error_classes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
91
|
+
def expected_error_classes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
93
92
|
"""
|
|
94
93
|
A list of expected error classes.
|
|
95
94
|
"""
|
|
96
95
|
return pulumi.get(self, "expected_error_classes")
|
|
97
96
|
|
|
98
97
|
@expected_error_classes.setter
|
|
99
|
-
def expected_error_classes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
98
|
+
def expected_error_classes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
100
99
|
pulumi.set(self, "expected_error_classes", value)
|
|
101
100
|
|
|
102
|
-
@property
|
|
101
|
+
@_builtins.property
|
|
103
102
|
@pulumi.getter(name="expectedErrorCodes")
|
|
104
|
-
def expected_error_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
103
|
+
def expected_error_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
105
104
|
"""
|
|
106
105
|
A list of expected error codes(any status code between 100-900).
|
|
107
106
|
"""
|
|
108
107
|
return pulumi.get(self, "expected_error_codes")
|
|
109
108
|
|
|
110
109
|
@expected_error_codes.setter
|
|
111
|
-
def expected_error_codes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
110
|
+
def expected_error_codes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
112
111
|
pulumi.set(self, "expected_error_codes", value)
|
|
113
112
|
|
|
114
|
-
@property
|
|
113
|
+
@_builtins.property
|
|
115
114
|
@pulumi.getter(name="ignoredErrorClasses")
|
|
116
|
-
def ignored_error_classes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
115
|
+
def ignored_error_classes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
117
116
|
"""
|
|
118
117
|
A list of ignored error classes.
|
|
119
118
|
"""
|
|
120
119
|
return pulumi.get(self, "ignored_error_classes")
|
|
121
120
|
|
|
122
121
|
@ignored_error_classes.setter
|
|
123
|
-
def ignored_error_classes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
122
|
+
def ignored_error_classes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
124
123
|
pulumi.set(self, "ignored_error_classes", value)
|
|
125
124
|
|
|
126
|
-
@property
|
|
125
|
+
@_builtins.property
|
|
127
126
|
@pulumi.getter(name="ignoredErrorCodes")
|
|
128
|
-
def ignored_error_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
127
|
+
def ignored_error_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
129
128
|
"""
|
|
130
129
|
A list of ignored error codes(any status code between 100-900).
|
|
131
130
|
"""
|
|
132
131
|
return pulumi.get(self, "ignored_error_codes")
|
|
133
132
|
|
|
134
133
|
@ignored_error_codes.setter
|
|
135
|
-
def ignored_error_codes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
134
|
+
def ignored_error_codes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
136
135
|
pulumi.set(self, "ignored_error_codes", value)
|
|
137
136
|
|
|
138
137
|
|
|
@@ -146,15 +145,15 @@ if not MYPY:
|
|
|
146
145
|
"""
|
|
147
146
|
Configuration block for SQL logging. Including this block enables SQL logging. The following arguments are supported:
|
|
148
147
|
"""
|
|
149
|
-
stack_trace_threshold_value: NotRequired[pulumi.Input[
|
|
148
|
+
stack_trace_threshold_value: NotRequired[pulumi.Input[_builtins.float]]
|
|
150
149
|
"""
|
|
151
150
|
The response time threshold for collecting stack traces.
|
|
152
151
|
"""
|
|
153
|
-
transaction_threshold_type: NotRequired[pulumi.Input[
|
|
152
|
+
transaction_threshold_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
154
153
|
"""
|
|
155
154
|
The type of threshold for transactions. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
|
|
156
155
|
"""
|
|
157
|
-
transaction_threshold_value: NotRequired[pulumi.Input[
|
|
156
|
+
transaction_threshold_value: NotRequired[pulumi.Input[_builtins.float]]
|
|
158
157
|
"""
|
|
159
158
|
The threshold value for transactions(in seconds).
|
|
160
159
|
"""
|
|
@@ -166,15 +165,15 @@ class ApplicationSettingsTransactionTracerArgs:
|
|
|
166
165
|
def __init__(__self__, *,
|
|
167
166
|
explain_query_plans: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSettingsTransactionTracerExplainQueryPlanArgs']]]] = None,
|
|
168
167
|
sql: Optional[pulumi.Input['ApplicationSettingsTransactionTracerSqlArgs']] = None,
|
|
169
|
-
stack_trace_threshold_value: Optional[pulumi.Input[
|
|
170
|
-
transaction_threshold_type: Optional[pulumi.Input[
|
|
171
|
-
transaction_threshold_value: Optional[pulumi.Input[
|
|
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):
|
|
172
171
|
"""
|
|
173
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:
|
|
174
173
|
:param pulumi.Input['ApplicationSettingsTransactionTracerSqlArgs'] sql: Configuration block for SQL logging. Including this block enables SQL logging. The following arguments are supported:
|
|
175
|
-
:param pulumi.Input[
|
|
176
|
-
:param pulumi.Input[
|
|
177
|
-
:param pulumi.Input[
|
|
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).
|
|
178
177
|
"""
|
|
179
178
|
if explain_query_plans is not None:
|
|
180
179
|
pulumi.set(__self__, "explain_query_plans", explain_query_plans)
|
|
@@ -187,7 +186,7 @@ class ApplicationSettingsTransactionTracerArgs:
|
|
|
187
186
|
if transaction_threshold_value is not None:
|
|
188
187
|
pulumi.set(__self__, "transaction_threshold_value", transaction_threshold_value)
|
|
189
188
|
|
|
190
|
-
@property
|
|
189
|
+
@_builtins.property
|
|
191
190
|
@pulumi.getter(name="explainQueryPlans")
|
|
192
191
|
def explain_query_plans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSettingsTransactionTracerExplainQueryPlanArgs']]]]:
|
|
193
192
|
"""
|
|
@@ -199,7 +198,7 @@ class ApplicationSettingsTransactionTracerArgs:
|
|
|
199
198
|
def explain_query_plans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSettingsTransactionTracerExplainQueryPlanArgs']]]]):
|
|
200
199
|
pulumi.set(self, "explain_query_plans", value)
|
|
201
200
|
|
|
202
|
-
@property
|
|
201
|
+
@_builtins.property
|
|
203
202
|
@pulumi.getter
|
|
204
203
|
def sql(self) -> Optional[pulumi.Input['ApplicationSettingsTransactionTracerSqlArgs']]:
|
|
205
204
|
"""
|
|
@@ -211,50 +210,50 @@ class ApplicationSettingsTransactionTracerArgs:
|
|
|
211
210
|
def sql(self, value: Optional[pulumi.Input['ApplicationSettingsTransactionTracerSqlArgs']]):
|
|
212
211
|
pulumi.set(self, "sql", value)
|
|
213
212
|
|
|
214
|
-
@property
|
|
213
|
+
@_builtins.property
|
|
215
214
|
@pulumi.getter(name="stackTraceThresholdValue")
|
|
216
|
-
def stack_trace_threshold_value(self) -> Optional[pulumi.Input[
|
|
215
|
+
def stack_trace_threshold_value(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
217
216
|
"""
|
|
218
217
|
The response time threshold for collecting stack traces.
|
|
219
218
|
"""
|
|
220
219
|
return pulumi.get(self, "stack_trace_threshold_value")
|
|
221
220
|
|
|
222
221
|
@stack_trace_threshold_value.setter
|
|
223
|
-
def stack_trace_threshold_value(self, value: Optional[pulumi.Input[
|
|
222
|
+
def stack_trace_threshold_value(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
224
223
|
pulumi.set(self, "stack_trace_threshold_value", value)
|
|
225
224
|
|
|
226
|
-
@property
|
|
225
|
+
@_builtins.property
|
|
227
226
|
@pulumi.getter(name="transactionThresholdType")
|
|
228
|
-
def transaction_threshold_type(self) -> Optional[pulumi.Input[
|
|
227
|
+
def transaction_threshold_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
229
228
|
"""
|
|
230
229
|
The type of threshold for transactions. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
|
|
231
230
|
"""
|
|
232
231
|
return pulumi.get(self, "transaction_threshold_type")
|
|
233
232
|
|
|
234
233
|
@transaction_threshold_type.setter
|
|
235
|
-
def transaction_threshold_type(self, value: Optional[pulumi.Input[
|
|
234
|
+
def transaction_threshold_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
236
235
|
pulumi.set(self, "transaction_threshold_type", value)
|
|
237
236
|
|
|
238
|
-
@property
|
|
237
|
+
@_builtins.property
|
|
239
238
|
@pulumi.getter(name="transactionThresholdValue")
|
|
240
|
-
def transaction_threshold_value(self) -> Optional[pulumi.Input[
|
|
239
|
+
def transaction_threshold_value(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
241
240
|
"""
|
|
242
241
|
The threshold value for transactions(in seconds).
|
|
243
242
|
"""
|
|
244
243
|
return pulumi.get(self, "transaction_threshold_value")
|
|
245
244
|
|
|
246
245
|
@transaction_threshold_value.setter
|
|
247
|
-
def transaction_threshold_value(self, value: Optional[pulumi.Input[
|
|
246
|
+
def transaction_threshold_value(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
248
247
|
pulumi.set(self, "transaction_threshold_value", value)
|
|
249
248
|
|
|
250
249
|
|
|
251
250
|
if not MYPY:
|
|
252
251
|
class ApplicationSettingsTransactionTracerExplainQueryPlanArgsDict(TypedDict):
|
|
253
|
-
query_plan_threshold_type: NotRequired[pulumi.Input[
|
|
252
|
+
query_plan_threshold_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
254
253
|
"""
|
|
255
254
|
The type of threshold for query plans. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
|
|
256
255
|
"""
|
|
257
|
-
query_plan_threshold_value: NotRequired[pulumi.Input[
|
|
256
|
+
query_plan_threshold_value: NotRequired[pulumi.Input[_builtins.float]]
|
|
258
257
|
"""
|
|
259
258
|
The response time threshold for capturing query plans(in seconds).
|
|
260
259
|
"""
|
|
@@ -264,45 +263,45 @@ elif False:
|
|
|
264
263
|
@pulumi.input_type
|
|
265
264
|
class ApplicationSettingsTransactionTracerExplainQueryPlanArgs:
|
|
266
265
|
def __init__(__self__, *,
|
|
267
|
-
query_plan_threshold_type: Optional[pulumi.Input[
|
|
268
|
-
query_plan_threshold_value: Optional[pulumi.Input[
|
|
266
|
+
query_plan_threshold_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
267
|
+
query_plan_threshold_value: Optional[pulumi.Input[_builtins.float]] = None):
|
|
269
268
|
"""
|
|
270
|
-
:param pulumi.Input[
|
|
271
|
-
:param pulumi.Input[
|
|
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).
|
|
272
271
|
"""
|
|
273
272
|
if query_plan_threshold_type is not None:
|
|
274
273
|
pulumi.set(__self__, "query_plan_threshold_type", query_plan_threshold_type)
|
|
275
274
|
if query_plan_threshold_value is not None:
|
|
276
275
|
pulumi.set(__self__, "query_plan_threshold_value", query_plan_threshold_value)
|
|
277
276
|
|
|
278
|
-
@property
|
|
277
|
+
@_builtins.property
|
|
279
278
|
@pulumi.getter(name="queryPlanThresholdType")
|
|
280
|
-
def query_plan_threshold_type(self) -> Optional[pulumi.Input[
|
|
279
|
+
def query_plan_threshold_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
281
280
|
"""
|
|
282
281
|
The type of threshold for query plans. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
|
|
283
282
|
"""
|
|
284
283
|
return pulumi.get(self, "query_plan_threshold_type")
|
|
285
284
|
|
|
286
285
|
@query_plan_threshold_type.setter
|
|
287
|
-
def query_plan_threshold_type(self, value: Optional[pulumi.Input[
|
|
286
|
+
def query_plan_threshold_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
288
287
|
pulumi.set(self, "query_plan_threshold_type", value)
|
|
289
288
|
|
|
290
|
-
@property
|
|
289
|
+
@_builtins.property
|
|
291
290
|
@pulumi.getter(name="queryPlanThresholdValue")
|
|
292
|
-
def query_plan_threshold_value(self) -> Optional[pulumi.Input[
|
|
291
|
+
def query_plan_threshold_value(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
293
292
|
"""
|
|
294
293
|
The response time threshold for capturing query plans(in seconds).
|
|
295
294
|
"""
|
|
296
295
|
return pulumi.get(self, "query_plan_threshold_value")
|
|
297
296
|
|
|
298
297
|
@query_plan_threshold_value.setter
|
|
299
|
-
def query_plan_threshold_value(self, value: Optional[pulumi.Input[
|
|
298
|
+
def query_plan_threshold_value(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
300
299
|
pulumi.set(self, "query_plan_threshold_value", value)
|
|
301
300
|
|
|
302
301
|
|
|
303
302
|
if not MYPY:
|
|
304
303
|
class ApplicationSettingsTransactionTracerSqlArgsDict(TypedDict):
|
|
305
|
-
record_sql: pulumi.Input[
|
|
304
|
+
record_sql: pulumi.Input[_builtins.str]
|
|
306
305
|
"""
|
|
307
306
|
The level of SQL recording. Valid values ar `OBFUSCATED`,`OFF`,`RAW` (Mandatory attribute when `sql` block is provided).
|
|
308
307
|
"""
|
|
@@ -312,28 +311,28 @@ elif False:
|
|
|
312
311
|
@pulumi.input_type
|
|
313
312
|
class ApplicationSettingsTransactionTracerSqlArgs:
|
|
314
313
|
def __init__(__self__, *,
|
|
315
|
-
record_sql: pulumi.Input[
|
|
314
|
+
record_sql: pulumi.Input[_builtins.str]):
|
|
316
315
|
"""
|
|
317
|
-
:param pulumi.Input[
|
|
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).
|
|
318
317
|
"""
|
|
319
318
|
pulumi.set(__self__, "record_sql", record_sql)
|
|
320
319
|
|
|
321
|
-
@property
|
|
320
|
+
@_builtins.property
|
|
322
321
|
@pulumi.getter(name="recordSql")
|
|
323
|
-
def record_sql(self) -> pulumi.Input[
|
|
322
|
+
def record_sql(self) -> pulumi.Input[_builtins.str]:
|
|
324
323
|
"""
|
|
325
324
|
The level of SQL recording. Valid values ar `OBFUSCATED`,`OFF`,`RAW` (Mandatory attribute when `sql` block is provided).
|
|
326
325
|
"""
|
|
327
326
|
return pulumi.get(self, "record_sql")
|
|
328
327
|
|
|
329
328
|
@record_sql.setter
|
|
330
|
-
def record_sql(self, value: pulumi.Input[
|
|
329
|
+
def record_sql(self, value: pulumi.Input[_builtins.str]):
|
|
331
330
|
pulumi.set(self, "record_sql", value)
|
|
332
331
|
|
|
333
332
|
|
|
334
333
|
if not MYPY:
|
|
335
334
|
class WorkloadEntitySearchQueryArgsDict(TypedDict):
|
|
336
|
-
query: pulumi.Input[
|
|
335
|
+
query: pulumi.Input[_builtins.str]
|
|
337
336
|
"""
|
|
338
337
|
A valid entity search query; empty, and null values are considered invalid.
|
|
339
338
|
"""
|
|
@@ -343,28 +342,28 @@ elif False:
|
|
|
343
342
|
@pulumi.input_type
|
|
344
343
|
class WorkloadEntitySearchQueryArgs:
|
|
345
344
|
def __init__(__self__, *,
|
|
346
|
-
query: pulumi.Input[
|
|
345
|
+
query: pulumi.Input[_builtins.str]):
|
|
347
346
|
"""
|
|
348
|
-
:param pulumi.Input[
|
|
347
|
+
:param pulumi.Input[_builtins.str] query: A valid entity search query; empty, and null values are considered invalid.
|
|
349
348
|
"""
|
|
350
349
|
pulumi.set(__self__, "query", query)
|
|
351
350
|
|
|
352
|
-
@property
|
|
351
|
+
@_builtins.property
|
|
353
352
|
@pulumi.getter
|
|
354
|
-
def query(self) -> pulumi.Input[
|
|
353
|
+
def query(self) -> pulumi.Input[_builtins.str]:
|
|
355
354
|
"""
|
|
356
355
|
A valid entity search query; empty, and null values are considered invalid.
|
|
357
356
|
"""
|
|
358
357
|
return pulumi.get(self, "query")
|
|
359
358
|
|
|
360
359
|
@query.setter
|
|
361
|
-
def query(self, value: pulumi.Input[
|
|
360
|
+
def query(self, value: pulumi.Input[_builtins.str]):
|
|
362
361
|
pulumi.set(self, "query", value)
|
|
363
362
|
|
|
364
363
|
|
|
365
364
|
if not MYPY:
|
|
366
365
|
class WorkloadStatusConfigAutomaticArgsDict(TypedDict):
|
|
367
|
-
enabled: pulumi.Input[
|
|
366
|
+
enabled: pulumi.Input[_builtins.bool]
|
|
368
367
|
"""
|
|
369
368
|
Whether the automatic status configuration is enabled or not.
|
|
370
369
|
"""
|
|
@@ -382,11 +381,11 @@ elif False:
|
|
|
382
381
|
@pulumi.input_type
|
|
383
382
|
class WorkloadStatusConfigAutomaticArgs:
|
|
384
383
|
def __init__(__self__, *,
|
|
385
|
-
enabled: pulumi.Input[
|
|
384
|
+
enabled: pulumi.Input[_builtins.bool],
|
|
386
385
|
remaining_entities_rule: Optional[pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs']] = None,
|
|
387
386
|
rules: Optional[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleArgs']]]] = None):
|
|
388
387
|
"""
|
|
389
|
-
:param pulumi.Input[
|
|
388
|
+
:param pulumi.Input[_builtins.bool] enabled: Whether the automatic status configuration is enabled or not.
|
|
390
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.
|
|
391
390
|
:param pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleArgs']]] rules: A list of rules.
|
|
392
391
|
"""
|
|
@@ -396,19 +395,19 @@ class WorkloadStatusConfigAutomaticArgs:
|
|
|
396
395
|
if rules is not None:
|
|
397
396
|
pulumi.set(__self__, "rules", rules)
|
|
398
397
|
|
|
399
|
-
@property
|
|
398
|
+
@_builtins.property
|
|
400
399
|
@pulumi.getter
|
|
401
|
-
def enabled(self) -> pulumi.Input[
|
|
400
|
+
def enabled(self) -> pulumi.Input[_builtins.bool]:
|
|
402
401
|
"""
|
|
403
402
|
Whether the automatic status configuration is enabled or not.
|
|
404
403
|
"""
|
|
405
404
|
return pulumi.get(self, "enabled")
|
|
406
405
|
|
|
407
406
|
@enabled.setter
|
|
408
|
-
def enabled(self, value: pulumi.Input[
|
|
407
|
+
def enabled(self, value: pulumi.Input[_builtins.bool]):
|
|
409
408
|
pulumi.set(self, "enabled", value)
|
|
410
409
|
|
|
411
|
-
@property
|
|
410
|
+
@_builtins.property
|
|
412
411
|
@pulumi.getter(name="remainingEntitiesRule")
|
|
413
412
|
def remaining_entities_rule(self) -> Optional[pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs']]:
|
|
414
413
|
"""
|
|
@@ -420,7 +419,7 @@ class WorkloadStatusConfigAutomaticArgs:
|
|
|
420
419
|
def remaining_entities_rule(self, value: Optional[pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs']]):
|
|
421
420
|
pulumi.set(self, "remaining_entities_rule", value)
|
|
422
421
|
|
|
423
|
-
@property
|
|
422
|
+
@_builtins.property
|
|
424
423
|
@pulumi.getter
|
|
425
424
|
def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleArgs']]]]:
|
|
426
425
|
"""
|
|
@@ -451,7 +450,7 @@ class WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs:
|
|
|
451
450
|
"""
|
|
452
451
|
pulumi.set(__self__, "remaining_entities_rule_rollup", remaining_entities_rule_rollup)
|
|
453
452
|
|
|
454
|
-
@property
|
|
453
|
+
@_builtins.property
|
|
455
454
|
@pulumi.getter(name="remainingEntitiesRuleRollup")
|
|
456
455
|
def remaining_entities_rule_rollup(self) -> pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs']:
|
|
457
456
|
"""
|
|
@@ -466,19 +465,19 @@ class WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs:
|
|
|
466
465
|
|
|
467
466
|
if not MYPY:
|
|
468
467
|
class WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgsDict(TypedDict):
|
|
469
|
-
group_by: pulumi.Input[
|
|
468
|
+
group_by: pulumi.Input[_builtins.str]
|
|
470
469
|
"""
|
|
471
470
|
The grouping to be applied to the remaining entities.
|
|
472
471
|
"""
|
|
473
|
-
strategy: pulumi.Input[
|
|
472
|
+
strategy: pulumi.Input[_builtins.str]
|
|
474
473
|
"""
|
|
475
474
|
The rollup strategy that is applied to a group of entities.
|
|
476
475
|
"""
|
|
477
|
-
threshold_type: NotRequired[pulumi.Input[
|
|
476
|
+
threshold_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
478
477
|
"""
|
|
479
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.
|
|
480
479
|
"""
|
|
481
|
-
threshold_value: NotRequired[pulumi.Input[
|
|
480
|
+
threshold_value: NotRequired[pulumi.Input[_builtins.int]]
|
|
482
481
|
"""
|
|
483
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.
|
|
484
483
|
"""
|
|
@@ -488,15 +487,15 @@ elif False:
|
|
|
488
487
|
@pulumi.input_type
|
|
489
488
|
class WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs:
|
|
490
489
|
def __init__(__self__, *,
|
|
491
|
-
group_by: pulumi.Input[
|
|
492
|
-
strategy: pulumi.Input[
|
|
493
|
-
threshold_type: Optional[pulumi.Input[
|
|
494
|
-
threshold_value: Optional[pulumi.Input[
|
|
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):
|
|
495
494
|
"""
|
|
496
|
-
:param pulumi.Input[
|
|
497
|
-
:param pulumi.Input[
|
|
498
|
-
:param pulumi.Input[
|
|
499
|
-
:param pulumi.Input[
|
|
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.
|
|
500
499
|
"""
|
|
501
500
|
pulumi.set(__self__, "group_by", group_by)
|
|
502
501
|
pulumi.set(__self__, "strategy", strategy)
|
|
@@ -505,52 +504,52 @@ class WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRol
|
|
|
505
504
|
if threshold_value is not None:
|
|
506
505
|
pulumi.set(__self__, "threshold_value", threshold_value)
|
|
507
506
|
|
|
508
|
-
@property
|
|
507
|
+
@_builtins.property
|
|
509
508
|
@pulumi.getter(name="groupBy")
|
|
510
|
-
def group_by(self) -> pulumi.Input[
|
|
509
|
+
def group_by(self) -> pulumi.Input[_builtins.str]:
|
|
511
510
|
"""
|
|
512
511
|
The grouping to be applied to the remaining entities.
|
|
513
512
|
"""
|
|
514
513
|
return pulumi.get(self, "group_by")
|
|
515
514
|
|
|
516
515
|
@group_by.setter
|
|
517
|
-
def group_by(self, value: pulumi.Input[
|
|
516
|
+
def group_by(self, value: pulumi.Input[_builtins.str]):
|
|
518
517
|
pulumi.set(self, "group_by", value)
|
|
519
518
|
|
|
520
|
-
@property
|
|
519
|
+
@_builtins.property
|
|
521
520
|
@pulumi.getter
|
|
522
|
-
def strategy(self) -> pulumi.Input[
|
|
521
|
+
def strategy(self) -> pulumi.Input[_builtins.str]:
|
|
523
522
|
"""
|
|
524
523
|
The rollup strategy that is applied to a group of entities.
|
|
525
524
|
"""
|
|
526
525
|
return pulumi.get(self, "strategy")
|
|
527
526
|
|
|
528
527
|
@strategy.setter
|
|
529
|
-
def strategy(self, value: pulumi.Input[
|
|
528
|
+
def strategy(self, value: pulumi.Input[_builtins.str]):
|
|
530
529
|
pulumi.set(self, "strategy", value)
|
|
531
530
|
|
|
532
|
-
@property
|
|
531
|
+
@_builtins.property
|
|
533
532
|
@pulumi.getter(name="thresholdType")
|
|
534
|
-
def threshold_type(self) -> Optional[pulumi.Input[
|
|
533
|
+
def threshold_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
535
534
|
"""
|
|
536
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.
|
|
537
536
|
"""
|
|
538
537
|
return pulumi.get(self, "threshold_type")
|
|
539
538
|
|
|
540
539
|
@threshold_type.setter
|
|
541
|
-
def threshold_type(self, value: Optional[pulumi.Input[
|
|
540
|
+
def threshold_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
542
541
|
pulumi.set(self, "threshold_type", value)
|
|
543
542
|
|
|
544
|
-
@property
|
|
543
|
+
@_builtins.property
|
|
545
544
|
@pulumi.getter(name="thresholdValue")
|
|
546
|
-
def threshold_value(self) -> Optional[pulumi.Input[
|
|
545
|
+
def threshold_value(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
547
546
|
"""
|
|
548
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.
|
|
549
548
|
"""
|
|
550
549
|
return pulumi.get(self, "threshold_value")
|
|
551
550
|
|
|
552
551
|
@threshold_value.setter
|
|
553
|
-
def threshold_value(self, value: Optional[pulumi.Input[
|
|
552
|
+
def threshold_value(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
554
553
|
pulumi.set(self, "threshold_value", value)
|
|
555
554
|
|
|
556
555
|
|
|
@@ -560,7 +559,7 @@ if not MYPY:
|
|
|
560
559
|
"""
|
|
561
560
|
The input object used to represent a rollup strategy. See Nested rollup blocks below for details.
|
|
562
561
|
"""
|
|
563
|
-
entity_guids: NotRequired[pulumi.Input[Sequence[pulumi.Input[
|
|
562
|
+
entity_guids: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
564
563
|
"""
|
|
565
564
|
A list of entity GUIDs composing the rule. At least one of `entity_guids` or `nrql_query` must be defined.
|
|
566
565
|
"""
|
|
@@ -575,11 +574,11 @@ elif False:
|
|
|
575
574
|
class WorkloadStatusConfigAutomaticRuleArgs:
|
|
576
575
|
def __init__(__self__, *,
|
|
577
576
|
rollup: pulumi.Input['WorkloadStatusConfigAutomaticRuleRollupArgs'],
|
|
578
|
-
entity_guids: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
577
|
+
entity_guids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
579
578
|
nrql_queries: Optional[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleNrqlQueryArgs']]]] = None):
|
|
580
579
|
"""
|
|
581
580
|
:param pulumi.Input['WorkloadStatusConfigAutomaticRuleRollupArgs'] rollup: The input object used to represent a rollup strategy. See Nested rollup blocks below for details.
|
|
582
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
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.
|
|
583
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.
|
|
584
583
|
"""
|
|
585
584
|
pulumi.set(__self__, "rollup", rollup)
|
|
@@ -588,7 +587,7 @@ class WorkloadStatusConfigAutomaticRuleArgs:
|
|
|
588
587
|
if nrql_queries is not None:
|
|
589
588
|
pulumi.set(__self__, "nrql_queries", nrql_queries)
|
|
590
589
|
|
|
591
|
-
@property
|
|
590
|
+
@_builtins.property
|
|
592
591
|
@pulumi.getter
|
|
593
592
|
def rollup(self) -> pulumi.Input['WorkloadStatusConfigAutomaticRuleRollupArgs']:
|
|
594
593
|
"""
|
|
@@ -600,19 +599,19 @@ class WorkloadStatusConfigAutomaticRuleArgs:
|
|
|
600
599
|
def rollup(self, value: pulumi.Input['WorkloadStatusConfigAutomaticRuleRollupArgs']):
|
|
601
600
|
pulumi.set(self, "rollup", value)
|
|
602
601
|
|
|
603
|
-
@property
|
|
602
|
+
@_builtins.property
|
|
604
603
|
@pulumi.getter(name="entityGuids")
|
|
605
|
-
def entity_guids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
604
|
+
def entity_guids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
606
605
|
"""
|
|
607
606
|
A list of entity GUIDs composing the rule. At least one of `entity_guids` or `nrql_query` must be defined.
|
|
608
607
|
"""
|
|
609
608
|
return pulumi.get(self, "entity_guids")
|
|
610
609
|
|
|
611
610
|
@entity_guids.setter
|
|
612
|
-
def entity_guids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
611
|
+
def entity_guids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
613
612
|
pulumi.set(self, "entity_guids", value)
|
|
614
613
|
|
|
615
|
-
@property
|
|
614
|
+
@_builtins.property
|
|
616
615
|
@pulumi.getter(name="nrqlQueries")
|
|
617
616
|
def nrql_queries(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleNrqlQueryArgs']]]]:
|
|
618
617
|
"""
|
|
@@ -627,7 +626,7 @@ class WorkloadStatusConfigAutomaticRuleArgs:
|
|
|
627
626
|
|
|
628
627
|
if not MYPY:
|
|
629
628
|
class WorkloadStatusConfigAutomaticRuleNrqlQueryArgsDict(TypedDict):
|
|
630
|
-
query: pulumi.Input[
|
|
629
|
+
query: pulumi.Input[_builtins.str]
|
|
631
630
|
"""
|
|
632
631
|
The entity search query that is used to perform the search of a group of entities.
|
|
633
632
|
"""
|
|
@@ -637,36 +636,36 @@ elif False:
|
|
|
637
636
|
@pulumi.input_type
|
|
638
637
|
class WorkloadStatusConfigAutomaticRuleNrqlQueryArgs:
|
|
639
638
|
def __init__(__self__, *,
|
|
640
|
-
query: pulumi.Input[
|
|
639
|
+
query: pulumi.Input[_builtins.str]):
|
|
641
640
|
"""
|
|
642
|
-
:param pulumi.Input[
|
|
641
|
+
:param pulumi.Input[_builtins.str] query: The entity search query that is used to perform the search of a group of entities.
|
|
643
642
|
"""
|
|
644
643
|
pulumi.set(__self__, "query", query)
|
|
645
644
|
|
|
646
|
-
@property
|
|
645
|
+
@_builtins.property
|
|
647
646
|
@pulumi.getter
|
|
648
|
-
def query(self) -> pulumi.Input[
|
|
647
|
+
def query(self) -> pulumi.Input[_builtins.str]:
|
|
649
648
|
"""
|
|
650
649
|
The entity search query that is used to perform the search of a group of entities.
|
|
651
650
|
"""
|
|
652
651
|
return pulumi.get(self, "query")
|
|
653
652
|
|
|
654
653
|
@query.setter
|
|
655
|
-
def query(self, value: pulumi.Input[
|
|
654
|
+
def query(self, value: pulumi.Input[_builtins.str]):
|
|
656
655
|
pulumi.set(self, "query", value)
|
|
657
656
|
|
|
658
657
|
|
|
659
658
|
if not MYPY:
|
|
660
659
|
class WorkloadStatusConfigAutomaticRuleRollupArgsDict(TypedDict):
|
|
661
|
-
strategy: pulumi.Input[
|
|
660
|
+
strategy: pulumi.Input[_builtins.str]
|
|
662
661
|
"""
|
|
663
662
|
The rollup strategy that is applied to a group of entities.
|
|
664
663
|
"""
|
|
665
|
-
threshold_type: NotRequired[pulumi.Input[
|
|
664
|
+
threshold_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
666
665
|
"""
|
|
667
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.
|
|
668
667
|
"""
|
|
669
|
-
threshold_value: NotRequired[pulumi.Input[
|
|
668
|
+
threshold_value: NotRequired[pulumi.Input[_builtins.int]]
|
|
670
669
|
"""
|
|
671
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.
|
|
672
671
|
"""
|
|
@@ -676,13 +675,13 @@ elif False:
|
|
|
676
675
|
@pulumi.input_type
|
|
677
676
|
class WorkloadStatusConfigAutomaticRuleRollupArgs:
|
|
678
677
|
def __init__(__self__, *,
|
|
679
|
-
strategy: pulumi.Input[
|
|
680
|
-
threshold_type: Optional[pulumi.Input[
|
|
681
|
-
threshold_value: Optional[pulumi.Input[
|
|
678
|
+
strategy: pulumi.Input[_builtins.str],
|
|
679
|
+
threshold_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
680
|
+
threshold_value: Optional[pulumi.Input[_builtins.int]] = None):
|
|
682
681
|
"""
|
|
683
|
-
:param pulumi.Input[
|
|
684
|
-
:param pulumi.Input[
|
|
685
|
-
:param pulumi.Input[
|
|
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.
|
|
686
685
|
"""
|
|
687
686
|
pulumi.set(__self__, "strategy", strategy)
|
|
688
687
|
if threshold_type is not None:
|
|
@@ -690,58 +689,58 @@ class WorkloadStatusConfigAutomaticRuleRollupArgs:
|
|
|
690
689
|
if threshold_value is not None:
|
|
691
690
|
pulumi.set(__self__, "threshold_value", threshold_value)
|
|
692
691
|
|
|
693
|
-
@property
|
|
692
|
+
@_builtins.property
|
|
694
693
|
@pulumi.getter
|
|
695
|
-
def strategy(self) -> pulumi.Input[
|
|
694
|
+
def strategy(self) -> pulumi.Input[_builtins.str]:
|
|
696
695
|
"""
|
|
697
696
|
The rollup strategy that is applied to a group of entities.
|
|
698
697
|
"""
|
|
699
698
|
return pulumi.get(self, "strategy")
|
|
700
699
|
|
|
701
700
|
@strategy.setter
|
|
702
|
-
def strategy(self, value: pulumi.Input[
|
|
701
|
+
def strategy(self, value: pulumi.Input[_builtins.str]):
|
|
703
702
|
pulumi.set(self, "strategy", value)
|
|
704
703
|
|
|
705
|
-
@property
|
|
704
|
+
@_builtins.property
|
|
706
705
|
@pulumi.getter(name="thresholdType")
|
|
707
|
-
def threshold_type(self) -> Optional[pulumi.Input[
|
|
706
|
+
def threshold_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
708
707
|
"""
|
|
709
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.
|
|
710
709
|
"""
|
|
711
710
|
return pulumi.get(self, "threshold_type")
|
|
712
711
|
|
|
713
712
|
@threshold_type.setter
|
|
714
|
-
def threshold_type(self, value: Optional[pulumi.Input[
|
|
713
|
+
def threshold_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
715
714
|
pulumi.set(self, "threshold_type", value)
|
|
716
715
|
|
|
717
|
-
@property
|
|
716
|
+
@_builtins.property
|
|
718
717
|
@pulumi.getter(name="thresholdValue")
|
|
719
|
-
def threshold_value(self) -> Optional[pulumi.Input[
|
|
718
|
+
def threshold_value(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
720
719
|
"""
|
|
721
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.
|
|
722
721
|
"""
|
|
723
722
|
return pulumi.get(self, "threshold_value")
|
|
724
723
|
|
|
725
724
|
@threshold_value.setter
|
|
726
|
-
def threshold_value(self, value: Optional[pulumi.Input[
|
|
725
|
+
def threshold_value(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
727
726
|
pulumi.set(self, "threshold_value", value)
|
|
728
727
|
|
|
729
728
|
|
|
730
729
|
if not MYPY:
|
|
731
730
|
class WorkloadStatusConfigStaticArgsDict(TypedDict):
|
|
732
|
-
enabled: pulumi.Input[
|
|
731
|
+
enabled: pulumi.Input[_builtins.bool]
|
|
733
732
|
"""
|
|
734
733
|
Whether the static status configuration is enabled or not.
|
|
735
734
|
"""
|
|
736
|
-
status: pulumi.Input[
|
|
735
|
+
status: pulumi.Input[_builtins.str]
|
|
737
736
|
"""
|
|
738
737
|
The status of the workload.
|
|
739
738
|
"""
|
|
740
|
-
description: NotRequired[pulumi.Input[
|
|
739
|
+
description: NotRequired[pulumi.Input[_builtins.str]]
|
|
741
740
|
"""
|
|
742
741
|
Relevant information about the workload.
|
|
743
742
|
"""
|
|
744
|
-
summary: NotRequired[pulumi.Input[
|
|
743
|
+
summary: NotRequired[pulumi.Input[_builtins.str]]
|
|
745
744
|
"""
|
|
746
745
|
A short description of the status of the workload.
|
|
747
746
|
"""
|
|
@@ -751,15 +750,15 @@ elif False:
|
|
|
751
750
|
@pulumi.input_type
|
|
752
751
|
class WorkloadStatusConfigStaticArgs:
|
|
753
752
|
def __init__(__self__, *,
|
|
754
|
-
enabled: pulumi.Input[
|
|
755
|
-
status: pulumi.Input[
|
|
756
|
-
description: Optional[pulumi.Input[
|
|
757
|
-
summary: Optional[pulumi.Input[
|
|
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):
|
|
758
757
|
"""
|
|
759
|
-
:param pulumi.Input[
|
|
760
|
-
:param pulumi.Input[
|
|
761
|
-
:param pulumi.Input[
|
|
762
|
-
:param pulumi.Input[
|
|
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.
|
|
763
762
|
"""
|
|
764
763
|
pulumi.set(__self__, "enabled", enabled)
|
|
765
764
|
pulumi.set(__self__, "status", status)
|
|
@@ -768,52 +767,52 @@ class WorkloadStatusConfigStaticArgs:
|
|
|
768
767
|
if summary is not None:
|
|
769
768
|
pulumi.set(__self__, "summary", summary)
|
|
770
769
|
|
|
771
|
-
@property
|
|
770
|
+
@_builtins.property
|
|
772
771
|
@pulumi.getter
|
|
773
|
-
def enabled(self) -> pulumi.Input[
|
|
772
|
+
def enabled(self) -> pulumi.Input[_builtins.bool]:
|
|
774
773
|
"""
|
|
775
774
|
Whether the static status configuration is enabled or not.
|
|
776
775
|
"""
|
|
777
776
|
return pulumi.get(self, "enabled")
|
|
778
777
|
|
|
779
778
|
@enabled.setter
|
|
780
|
-
def enabled(self, value: pulumi.Input[
|
|
779
|
+
def enabled(self, value: pulumi.Input[_builtins.bool]):
|
|
781
780
|
pulumi.set(self, "enabled", value)
|
|
782
781
|
|
|
783
|
-
@property
|
|
782
|
+
@_builtins.property
|
|
784
783
|
@pulumi.getter
|
|
785
|
-
def status(self) -> pulumi.Input[
|
|
784
|
+
def status(self) -> pulumi.Input[_builtins.str]:
|
|
786
785
|
"""
|
|
787
786
|
The status of the workload.
|
|
788
787
|
"""
|
|
789
788
|
return pulumi.get(self, "status")
|
|
790
789
|
|
|
791
790
|
@status.setter
|
|
792
|
-
def status(self, value: pulumi.Input[
|
|
791
|
+
def status(self, value: pulumi.Input[_builtins.str]):
|
|
793
792
|
pulumi.set(self, "status", value)
|
|
794
793
|
|
|
795
|
-
@property
|
|
794
|
+
@_builtins.property
|
|
796
795
|
@pulumi.getter
|
|
797
|
-
def description(self) -> Optional[pulumi.Input[
|
|
796
|
+
def description(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
798
797
|
"""
|
|
799
798
|
Relevant information about the workload.
|
|
800
799
|
"""
|
|
801
800
|
return pulumi.get(self, "description")
|
|
802
801
|
|
|
803
802
|
@description.setter
|
|
804
|
-
def description(self, value: Optional[pulumi.Input[
|
|
803
|
+
def description(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
805
804
|
pulumi.set(self, "description", value)
|
|
806
805
|
|
|
807
|
-
@property
|
|
806
|
+
@_builtins.property
|
|
808
807
|
@pulumi.getter
|
|
809
|
-
def summary(self) -> Optional[pulumi.Input[
|
|
808
|
+
def summary(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
810
809
|
"""
|
|
811
810
|
A short description of the status of the workload.
|
|
812
811
|
"""
|
|
813
812
|
return pulumi.get(self, "summary")
|
|
814
813
|
|
|
815
814
|
@summary.setter
|
|
816
|
-
def summary(self, value: Optional[pulumi.Input[
|
|
815
|
+
def summary(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
817
816
|
pulumi.set(self, "summary", value)
|
|
818
817
|
|
|
819
818
|
|