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