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
|
|
@@ -22,59 +21,59 @@ __all__ = ['MonitorArgs', 'Monitor']
|
|
|
22
21
|
@pulumi.input_type
|
|
23
22
|
class MonitorArgs:
|
|
24
23
|
def __init__(__self__, *,
|
|
25
|
-
status: pulumi.Input[
|
|
26
|
-
type: pulumi.Input[
|
|
27
|
-
account_id: Optional[pulumi.Input[
|
|
28
|
-
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
29
|
-
bypass_head_request: Optional[pulumi.Input[
|
|
24
|
+
status: pulumi.Input[_builtins.str],
|
|
25
|
+
type: pulumi.Input[_builtins.str],
|
|
26
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
27
|
+
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
28
|
+
bypass_head_request: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
30
29
|
custom_headers: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]]] = None,
|
|
31
|
-
device_orientation: Optional[pulumi.Input[
|
|
32
|
-
device_type: Optional[pulumi.Input[
|
|
33
|
-
devices: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
34
|
-
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[
|
|
35
|
-
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
36
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
37
|
-
name: Optional[pulumi.Input[
|
|
38
|
-
period: Optional[pulumi.Input[
|
|
39
|
-
runtime_type: Optional[pulumi.Input[
|
|
40
|
-
runtime_type_version: Optional[pulumi.Input[
|
|
41
|
-
script_language: Optional[pulumi.Input[
|
|
30
|
+
device_orientation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
31
|
+
device_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
32
|
+
devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
33
|
+
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
34
|
+
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
35
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
36
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
37
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
38
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
39
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
40
|
+
script_language: Optional[pulumi.Input[_builtins.str]] = None,
|
|
42
41
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]]] = None,
|
|
43
|
-
treat_redirect_as_failure: Optional[pulumi.Input[
|
|
44
|
-
uri: Optional[pulumi.Input[
|
|
45
|
-
use_unsupported_legacy_runtime: Optional[pulumi.Input[
|
|
46
|
-
validation_string: Optional[pulumi.Input[
|
|
47
|
-
verify_ssl: Optional[pulumi.Input[
|
|
42
|
+
treat_redirect_as_failure: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
43
|
+
uri: Optional[pulumi.Input[_builtins.str]] = None,
|
|
44
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
45
|
+
validation_string: Optional[pulumi.Input[_builtins.str]] = None,
|
|
46
|
+
verify_ssl: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
48
47
|
"""
|
|
49
48
|
The set of arguments for constructing a Monitor resource.
|
|
50
|
-
:param pulumi.Input[
|
|
51
|
-
:param pulumi.Input[
|
|
52
|
-
:param pulumi.Input[
|
|
53
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
54
|
-
:param pulumi.Input[
|
|
49
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
50
|
+
:param pulumi.Input[_builtins.str] type: The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
51
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
52
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
53
|
+
:param pulumi.Input[_builtins.bool] bypass_head_request: Monitor should skip default HEAD request and instead use GET verb in check.
|
|
55
54
|
|
|
56
55
|
The `BROWSER` monitor type supports the following additional arguments:
|
|
57
56
|
:param pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]] custom_headers: Custom headers to use in monitor job. See Nested custom_header blocks below for details.
|
|
58
|
-
:param pulumi.Input[
|
|
57
|
+
:param pulumi.Input[_builtins.str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
59
58
|
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
60
|
-
:param pulumi.Input[
|
|
59
|
+
:param pulumi.Input[_builtins.str] device_type: Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
61
60
|
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
62
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
63
|
-
:param pulumi.Input[
|
|
64
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
65
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
66
|
-
:param pulumi.Input[
|
|
67
|
-
:param pulumi.Input[
|
|
68
|
-
:param pulumi.Input[
|
|
69
|
-
:param pulumi.Input[
|
|
70
|
-
:param pulumi.Input[
|
|
61
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] devices: The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
62
|
+
:param pulumi.Input[_builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
63
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
64
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
65
|
+
:param pulumi.Input[_builtins.str] name: The human-readable identifier for the monitor.
|
|
66
|
+
:param pulumi.Input[_builtins.str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
67
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
68
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific version of the runtime type selected (`100`).
|
|
69
|
+
:param pulumi.Input[_builtins.str] script_language: The programing language that should execute the script.
|
|
71
70
|
:param pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
72
71
|
|
|
73
72
|
The `SIMPLE` monitor type supports the following additional arguments:
|
|
74
|
-
:param pulumi.Input[
|
|
75
|
-
:param pulumi.Input[
|
|
76
|
-
:param pulumi.Input[
|
|
77
|
-
:param pulumi.Input[
|
|
73
|
+
:param pulumi.Input[_builtins.bool] treat_redirect_as_failure: Categorize redirects during a monitor job as a failure.
|
|
74
|
+
:param pulumi.Input[_builtins.str] uri: The URI the monitor runs against.
|
|
75
|
+
:param pulumi.Input[_builtins.str] validation_string: Validation text for monitor to search for at given URI.
|
|
76
|
+
:param pulumi.Input[_builtins.bool] verify_ssl: Monitor should validate SSL certificate chain.
|
|
78
77
|
"""
|
|
79
78
|
pulumi.set(__self__, "status", status)
|
|
80
79
|
pulumi.set(__self__, "type", type)
|
|
@@ -121,57 +120,57 @@ class MonitorArgs:
|
|
|
121
120
|
if verify_ssl is not None:
|
|
122
121
|
pulumi.set(__self__, "verify_ssl", verify_ssl)
|
|
123
122
|
|
|
124
|
-
@property
|
|
123
|
+
@_builtins.property
|
|
125
124
|
@pulumi.getter
|
|
126
|
-
def status(self) -> pulumi.Input[
|
|
125
|
+
def status(self) -> pulumi.Input[_builtins.str]:
|
|
127
126
|
"""
|
|
128
127
|
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
129
128
|
"""
|
|
130
129
|
return pulumi.get(self, "status")
|
|
131
130
|
|
|
132
131
|
@status.setter
|
|
133
|
-
def status(self, value: pulumi.Input[
|
|
132
|
+
def status(self, value: pulumi.Input[_builtins.str]):
|
|
134
133
|
pulumi.set(self, "status", value)
|
|
135
134
|
|
|
136
|
-
@property
|
|
135
|
+
@_builtins.property
|
|
137
136
|
@pulumi.getter
|
|
138
|
-
def type(self) -> pulumi.Input[
|
|
137
|
+
def type(self) -> pulumi.Input[_builtins.str]:
|
|
139
138
|
"""
|
|
140
139
|
The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
141
140
|
"""
|
|
142
141
|
return pulumi.get(self, "type")
|
|
143
142
|
|
|
144
143
|
@type.setter
|
|
145
|
-
def type(self, value: pulumi.Input[
|
|
144
|
+
def type(self, value: pulumi.Input[_builtins.str]):
|
|
146
145
|
pulumi.set(self, "type", value)
|
|
147
146
|
|
|
148
|
-
@property
|
|
147
|
+
@_builtins.property
|
|
149
148
|
@pulumi.getter(name="accountId")
|
|
150
|
-
def account_id(self) -> Optional[pulumi.Input[
|
|
149
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
151
150
|
"""
|
|
152
151
|
The account in which the Synthetics monitor will be created.
|
|
153
152
|
"""
|
|
154
153
|
return pulumi.get(self, "account_id")
|
|
155
154
|
|
|
156
155
|
@account_id.setter
|
|
157
|
-
def account_id(self, value: Optional[pulumi.Input[
|
|
156
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
158
157
|
pulumi.set(self, "account_id", value)
|
|
159
158
|
|
|
160
|
-
@property
|
|
159
|
+
@_builtins.property
|
|
161
160
|
@pulumi.getter
|
|
162
|
-
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
161
|
+
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
163
162
|
"""
|
|
164
163
|
The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
165
164
|
"""
|
|
166
165
|
return pulumi.get(self, "browsers")
|
|
167
166
|
|
|
168
167
|
@browsers.setter
|
|
169
|
-
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
168
|
+
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
170
169
|
pulumi.set(self, "browsers", value)
|
|
171
170
|
|
|
172
|
-
@property
|
|
171
|
+
@_builtins.property
|
|
173
172
|
@pulumi.getter(name="bypassHeadRequest")
|
|
174
|
-
def bypass_head_request(self) -> Optional[pulumi.Input[
|
|
173
|
+
def bypass_head_request(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
175
174
|
"""
|
|
176
175
|
Monitor should skip default HEAD request and instead use GET verb in check.
|
|
177
176
|
|
|
@@ -180,10 +179,10 @@ class MonitorArgs:
|
|
|
180
179
|
return pulumi.get(self, "bypass_head_request")
|
|
181
180
|
|
|
182
181
|
@bypass_head_request.setter
|
|
183
|
-
def bypass_head_request(self, value: Optional[pulumi.Input[
|
|
182
|
+
def bypass_head_request(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
184
183
|
pulumi.set(self, "bypass_head_request", value)
|
|
185
184
|
|
|
186
|
-
@property
|
|
185
|
+
@_builtins.property
|
|
187
186
|
@pulumi.getter(name="customHeaders")
|
|
188
187
|
def custom_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]]]:
|
|
189
188
|
"""
|
|
@@ -195,9 +194,9 @@ class MonitorArgs:
|
|
|
195
194
|
def custom_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]]]):
|
|
196
195
|
pulumi.set(self, "custom_headers", value)
|
|
197
196
|
|
|
198
|
-
@property
|
|
197
|
+
@_builtins.property
|
|
199
198
|
@pulumi.getter(name="deviceOrientation")
|
|
200
|
-
def device_orientation(self) -> Optional[pulumi.Input[
|
|
199
|
+
def device_orientation(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
201
200
|
"""
|
|
202
201
|
Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
203
202
|
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
@@ -205,12 +204,12 @@ class MonitorArgs:
|
|
|
205
204
|
return pulumi.get(self, "device_orientation")
|
|
206
205
|
|
|
207
206
|
@device_orientation.setter
|
|
208
|
-
def device_orientation(self, value: Optional[pulumi.Input[
|
|
207
|
+
def device_orientation(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
209
208
|
pulumi.set(self, "device_orientation", value)
|
|
210
209
|
|
|
211
|
-
@property
|
|
210
|
+
@_builtins.property
|
|
212
211
|
@pulumi.getter(name="deviceType")
|
|
213
|
-
def device_type(self) -> Optional[pulumi.Input[
|
|
212
|
+
def device_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
214
213
|
"""
|
|
215
214
|
Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
216
215
|
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
@@ -218,118 +217,118 @@ class MonitorArgs:
|
|
|
218
217
|
return pulumi.get(self, "device_type")
|
|
219
218
|
|
|
220
219
|
@device_type.setter
|
|
221
|
-
def device_type(self, value: Optional[pulumi.Input[
|
|
220
|
+
def device_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
222
221
|
pulumi.set(self, "device_type", value)
|
|
223
222
|
|
|
224
|
-
@property
|
|
223
|
+
@_builtins.property
|
|
225
224
|
@pulumi.getter
|
|
226
|
-
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
225
|
+
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
227
226
|
"""
|
|
228
227
|
The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
229
228
|
"""
|
|
230
229
|
return pulumi.get(self, "devices")
|
|
231
230
|
|
|
232
231
|
@devices.setter
|
|
233
|
-
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
232
|
+
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
234
233
|
pulumi.set(self, "devices", value)
|
|
235
234
|
|
|
236
|
-
@property
|
|
235
|
+
@_builtins.property
|
|
237
236
|
@pulumi.getter(name="enableScreenshotOnFailureAndScript")
|
|
238
|
-
def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[
|
|
237
|
+
def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
239
238
|
"""
|
|
240
239
|
Capture a screenshot during job execution.
|
|
241
240
|
"""
|
|
242
241
|
return pulumi.get(self, "enable_screenshot_on_failure_and_script")
|
|
243
242
|
|
|
244
243
|
@enable_screenshot_on_failure_and_script.setter
|
|
245
|
-
def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[
|
|
244
|
+
def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
246
245
|
pulumi.set(self, "enable_screenshot_on_failure_and_script", value)
|
|
247
246
|
|
|
248
|
-
@property
|
|
247
|
+
@_builtins.property
|
|
249
248
|
@pulumi.getter(name="locationsPrivates")
|
|
250
|
-
def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
249
|
+
def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
251
250
|
"""
|
|
252
251
|
The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
253
252
|
"""
|
|
254
253
|
return pulumi.get(self, "locations_privates")
|
|
255
254
|
|
|
256
255
|
@locations_privates.setter
|
|
257
|
-
def locations_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
256
|
+
def locations_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
258
257
|
pulumi.set(self, "locations_privates", value)
|
|
259
258
|
|
|
260
|
-
@property
|
|
259
|
+
@_builtins.property
|
|
261
260
|
@pulumi.getter(name="locationsPublics")
|
|
262
|
-
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
261
|
+
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
263
262
|
"""
|
|
264
263
|
The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
265
264
|
"""
|
|
266
265
|
return pulumi.get(self, "locations_publics")
|
|
267
266
|
|
|
268
267
|
@locations_publics.setter
|
|
269
|
-
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
268
|
+
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
270
269
|
pulumi.set(self, "locations_publics", value)
|
|
271
270
|
|
|
272
|
-
@property
|
|
271
|
+
@_builtins.property
|
|
273
272
|
@pulumi.getter
|
|
274
|
-
def name(self) -> Optional[pulumi.Input[
|
|
273
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
275
274
|
"""
|
|
276
275
|
The human-readable identifier for the monitor.
|
|
277
276
|
"""
|
|
278
277
|
return pulumi.get(self, "name")
|
|
279
278
|
|
|
280
279
|
@name.setter
|
|
281
|
-
def name(self, value: Optional[pulumi.Input[
|
|
280
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
282
281
|
pulumi.set(self, "name", value)
|
|
283
282
|
|
|
284
|
-
@property
|
|
283
|
+
@_builtins.property
|
|
285
284
|
@pulumi.getter
|
|
286
|
-
def period(self) -> Optional[pulumi.Input[
|
|
285
|
+
def period(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
287
286
|
"""
|
|
288
287
|
The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
289
288
|
"""
|
|
290
289
|
return pulumi.get(self, "period")
|
|
291
290
|
|
|
292
291
|
@period.setter
|
|
293
|
-
def period(self, value: Optional[pulumi.Input[
|
|
292
|
+
def period(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
294
293
|
pulumi.set(self, "period", value)
|
|
295
294
|
|
|
296
|
-
@property
|
|
295
|
+
@_builtins.property
|
|
297
296
|
@pulumi.getter(name="runtimeType")
|
|
298
|
-
def runtime_type(self) -> Optional[pulumi.Input[
|
|
297
|
+
def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
299
298
|
"""
|
|
300
299
|
The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
301
300
|
"""
|
|
302
301
|
return pulumi.get(self, "runtime_type")
|
|
303
302
|
|
|
304
303
|
@runtime_type.setter
|
|
305
|
-
def runtime_type(self, value: Optional[pulumi.Input[
|
|
304
|
+
def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
306
305
|
pulumi.set(self, "runtime_type", value)
|
|
307
306
|
|
|
308
|
-
@property
|
|
307
|
+
@_builtins.property
|
|
309
308
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
310
|
-
def runtime_type_version(self) -> Optional[pulumi.Input[
|
|
309
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
311
310
|
"""
|
|
312
311
|
The specific version of the runtime type selected (`100`).
|
|
313
312
|
"""
|
|
314
313
|
return pulumi.get(self, "runtime_type_version")
|
|
315
314
|
|
|
316
315
|
@runtime_type_version.setter
|
|
317
|
-
def runtime_type_version(self, value: Optional[pulumi.Input[
|
|
316
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
318
317
|
pulumi.set(self, "runtime_type_version", value)
|
|
319
318
|
|
|
320
|
-
@property
|
|
319
|
+
@_builtins.property
|
|
321
320
|
@pulumi.getter(name="scriptLanguage")
|
|
322
|
-
def script_language(self) -> Optional[pulumi.Input[
|
|
321
|
+
def script_language(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
323
322
|
"""
|
|
324
323
|
The programing language that should execute the script.
|
|
325
324
|
"""
|
|
326
325
|
return pulumi.get(self, "script_language")
|
|
327
326
|
|
|
328
327
|
@script_language.setter
|
|
329
|
-
def script_language(self, value: Optional[pulumi.Input[
|
|
328
|
+
def script_language(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
330
329
|
pulumi.set(self, "script_language", value)
|
|
331
330
|
|
|
332
|
-
@property
|
|
331
|
+
@_builtins.property
|
|
333
332
|
@pulumi.getter
|
|
334
333
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]]]:
|
|
335
334
|
"""
|
|
@@ -343,124 +342,124 @@ class MonitorArgs:
|
|
|
343
342
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]]]):
|
|
344
343
|
pulumi.set(self, "tags", value)
|
|
345
344
|
|
|
346
|
-
@property
|
|
345
|
+
@_builtins.property
|
|
347
346
|
@pulumi.getter(name="treatRedirectAsFailure")
|
|
348
|
-
def treat_redirect_as_failure(self) -> Optional[pulumi.Input[
|
|
347
|
+
def treat_redirect_as_failure(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
349
348
|
"""
|
|
350
349
|
Categorize redirects during a monitor job as a failure.
|
|
351
350
|
"""
|
|
352
351
|
return pulumi.get(self, "treat_redirect_as_failure")
|
|
353
352
|
|
|
354
353
|
@treat_redirect_as_failure.setter
|
|
355
|
-
def treat_redirect_as_failure(self, value: Optional[pulumi.Input[
|
|
354
|
+
def treat_redirect_as_failure(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
356
355
|
pulumi.set(self, "treat_redirect_as_failure", value)
|
|
357
356
|
|
|
358
|
-
@property
|
|
357
|
+
@_builtins.property
|
|
359
358
|
@pulumi.getter
|
|
360
|
-
def uri(self) -> Optional[pulumi.Input[
|
|
359
|
+
def uri(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
361
360
|
"""
|
|
362
361
|
The URI the monitor runs against.
|
|
363
362
|
"""
|
|
364
363
|
return pulumi.get(self, "uri")
|
|
365
364
|
|
|
366
365
|
@uri.setter
|
|
367
|
-
def uri(self, value: Optional[pulumi.Input[
|
|
366
|
+
def uri(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
368
367
|
pulumi.set(self, "uri", value)
|
|
369
368
|
|
|
370
|
-
@property
|
|
369
|
+
@_builtins.property
|
|
371
370
|
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
372
|
-
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[
|
|
371
|
+
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
373
372
|
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
374
373
|
|
|
375
374
|
@use_unsupported_legacy_runtime.setter
|
|
376
|
-
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[
|
|
375
|
+
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
377
376
|
pulumi.set(self, "use_unsupported_legacy_runtime", value)
|
|
378
377
|
|
|
379
|
-
@property
|
|
378
|
+
@_builtins.property
|
|
380
379
|
@pulumi.getter(name="validationString")
|
|
381
|
-
def validation_string(self) -> Optional[pulumi.Input[
|
|
380
|
+
def validation_string(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
382
381
|
"""
|
|
383
382
|
Validation text for monitor to search for at given URI.
|
|
384
383
|
"""
|
|
385
384
|
return pulumi.get(self, "validation_string")
|
|
386
385
|
|
|
387
386
|
@validation_string.setter
|
|
388
|
-
def validation_string(self, value: Optional[pulumi.Input[
|
|
387
|
+
def validation_string(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
389
388
|
pulumi.set(self, "validation_string", value)
|
|
390
389
|
|
|
391
|
-
@property
|
|
390
|
+
@_builtins.property
|
|
392
391
|
@pulumi.getter(name="verifySsl")
|
|
393
|
-
def verify_ssl(self) -> Optional[pulumi.Input[
|
|
392
|
+
def verify_ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
394
393
|
"""
|
|
395
394
|
Monitor should validate SSL certificate chain.
|
|
396
395
|
"""
|
|
397
396
|
return pulumi.get(self, "verify_ssl")
|
|
398
397
|
|
|
399
398
|
@verify_ssl.setter
|
|
400
|
-
def verify_ssl(self, value: Optional[pulumi.Input[
|
|
399
|
+
def verify_ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
401
400
|
pulumi.set(self, "verify_ssl", value)
|
|
402
401
|
|
|
403
402
|
|
|
404
403
|
@pulumi.input_type
|
|
405
404
|
class _MonitorState:
|
|
406
405
|
def __init__(__self__, *,
|
|
407
|
-
account_id: Optional[pulumi.Input[
|
|
408
|
-
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
409
|
-
bypass_head_request: Optional[pulumi.Input[
|
|
406
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
407
|
+
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
408
|
+
bypass_head_request: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
410
409
|
custom_headers: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]]] = None,
|
|
411
|
-
device_orientation: Optional[pulumi.Input[
|
|
412
|
-
device_type: Optional[pulumi.Input[
|
|
413
|
-
devices: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
414
|
-
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[
|
|
415
|
-
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
416
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
417
|
-
monitor_id: Optional[pulumi.Input[
|
|
418
|
-
name: Optional[pulumi.Input[
|
|
419
|
-
period: Optional[pulumi.Input[
|
|
420
|
-
period_in_minutes: Optional[pulumi.Input[
|
|
421
|
-
runtime_type: Optional[pulumi.Input[
|
|
422
|
-
runtime_type_version: Optional[pulumi.Input[
|
|
423
|
-
script_language: Optional[pulumi.Input[
|
|
424
|
-
status: Optional[pulumi.Input[
|
|
410
|
+
device_orientation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
411
|
+
device_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
412
|
+
devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
413
|
+
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
414
|
+
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
415
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
416
|
+
monitor_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
417
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
418
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
419
|
+
period_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
420
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
421
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
422
|
+
script_language: Optional[pulumi.Input[_builtins.str]] = None,
|
|
423
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
425
424
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]]] = None,
|
|
426
|
-
treat_redirect_as_failure: Optional[pulumi.Input[
|
|
427
|
-
type: Optional[pulumi.Input[
|
|
428
|
-
uri: Optional[pulumi.Input[
|
|
429
|
-
use_unsupported_legacy_runtime: Optional[pulumi.Input[
|
|
430
|
-
validation_string: Optional[pulumi.Input[
|
|
431
|
-
verify_ssl: Optional[pulumi.Input[
|
|
425
|
+
treat_redirect_as_failure: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
426
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
427
|
+
uri: Optional[pulumi.Input[_builtins.str]] = None,
|
|
428
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
429
|
+
validation_string: Optional[pulumi.Input[_builtins.str]] = None,
|
|
430
|
+
verify_ssl: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
432
431
|
"""
|
|
433
432
|
Input properties used for looking up and filtering Monitor resources.
|
|
434
|
-
:param pulumi.Input[
|
|
435
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
436
|
-
:param pulumi.Input[
|
|
433
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
434
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
435
|
+
:param pulumi.Input[_builtins.bool] bypass_head_request: Monitor should skip default HEAD request and instead use GET verb in check.
|
|
437
436
|
|
|
438
437
|
The `BROWSER` monitor type supports the following additional arguments:
|
|
439
438
|
:param pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]] custom_headers: Custom headers to use in monitor job. See Nested custom_header blocks below for details.
|
|
440
|
-
:param pulumi.Input[
|
|
439
|
+
:param pulumi.Input[_builtins.str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
441
440
|
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
442
|
-
:param pulumi.Input[
|
|
441
|
+
:param pulumi.Input[_builtins.str] device_type: Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
443
442
|
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
444
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
445
|
-
:param pulumi.Input[
|
|
446
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
447
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
448
|
-
:param pulumi.Input[
|
|
449
|
-
:param pulumi.Input[
|
|
450
|
-
:param pulumi.Input[
|
|
451
|
-
:param pulumi.Input[
|
|
452
|
-
:param pulumi.Input[
|
|
453
|
-
:param pulumi.Input[
|
|
454
|
-
:param pulumi.Input[
|
|
455
|
-
:param pulumi.Input[
|
|
443
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] devices: The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
444
|
+
:param pulumi.Input[_builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
445
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
446
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
447
|
+
:param pulumi.Input[_builtins.str] monitor_id: The monitor id of the Synthetics monitor (not to be confused with the GUID of the monitor).
|
|
448
|
+
:param pulumi.Input[_builtins.str] name: The human-readable identifier for the monitor.
|
|
449
|
+
:param pulumi.Input[_builtins.str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
450
|
+
:param pulumi.Input[_builtins.int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
|
|
451
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
452
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific version of the runtime type selected (`100`).
|
|
453
|
+
:param pulumi.Input[_builtins.str] script_language: The programing language that should execute the script.
|
|
454
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
456
455
|
:param pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
457
456
|
|
|
458
457
|
The `SIMPLE` monitor type supports the following additional arguments:
|
|
459
|
-
:param pulumi.Input[
|
|
460
|
-
:param pulumi.Input[
|
|
461
|
-
:param pulumi.Input[
|
|
462
|
-
:param pulumi.Input[
|
|
463
|
-
:param pulumi.Input[
|
|
458
|
+
:param pulumi.Input[_builtins.bool] treat_redirect_as_failure: Categorize redirects during a monitor job as a failure.
|
|
459
|
+
:param pulumi.Input[_builtins.str] type: The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
460
|
+
:param pulumi.Input[_builtins.str] uri: The URI the monitor runs against.
|
|
461
|
+
:param pulumi.Input[_builtins.str] validation_string: Validation text for monitor to search for at given URI.
|
|
462
|
+
:param pulumi.Input[_builtins.bool] verify_ssl: Monitor should validate SSL certificate chain.
|
|
464
463
|
"""
|
|
465
464
|
if account_id is not None:
|
|
466
465
|
pulumi.set(__self__, "account_id", account_id)
|
|
@@ -513,33 +512,33 @@ class _MonitorState:
|
|
|
513
512
|
if verify_ssl is not None:
|
|
514
513
|
pulumi.set(__self__, "verify_ssl", verify_ssl)
|
|
515
514
|
|
|
516
|
-
@property
|
|
515
|
+
@_builtins.property
|
|
517
516
|
@pulumi.getter(name="accountId")
|
|
518
|
-
def account_id(self) -> Optional[pulumi.Input[
|
|
517
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
519
518
|
"""
|
|
520
519
|
The account in which the Synthetics monitor will be created.
|
|
521
520
|
"""
|
|
522
521
|
return pulumi.get(self, "account_id")
|
|
523
522
|
|
|
524
523
|
@account_id.setter
|
|
525
|
-
def account_id(self, value: Optional[pulumi.Input[
|
|
524
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
526
525
|
pulumi.set(self, "account_id", value)
|
|
527
526
|
|
|
528
|
-
@property
|
|
527
|
+
@_builtins.property
|
|
529
528
|
@pulumi.getter
|
|
530
|
-
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
529
|
+
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
531
530
|
"""
|
|
532
531
|
The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
533
532
|
"""
|
|
534
533
|
return pulumi.get(self, "browsers")
|
|
535
534
|
|
|
536
535
|
@browsers.setter
|
|
537
|
-
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
536
|
+
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
538
537
|
pulumi.set(self, "browsers", value)
|
|
539
538
|
|
|
540
|
-
@property
|
|
539
|
+
@_builtins.property
|
|
541
540
|
@pulumi.getter(name="bypassHeadRequest")
|
|
542
|
-
def bypass_head_request(self) -> Optional[pulumi.Input[
|
|
541
|
+
def bypass_head_request(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
543
542
|
"""
|
|
544
543
|
Monitor should skip default HEAD request and instead use GET verb in check.
|
|
545
544
|
|
|
@@ -548,10 +547,10 @@ class _MonitorState:
|
|
|
548
547
|
return pulumi.get(self, "bypass_head_request")
|
|
549
548
|
|
|
550
549
|
@bypass_head_request.setter
|
|
551
|
-
def bypass_head_request(self, value: Optional[pulumi.Input[
|
|
550
|
+
def bypass_head_request(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
552
551
|
pulumi.set(self, "bypass_head_request", value)
|
|
553
552
|
|
|
554
|
-
@property
|
|
553
|
+
@_builtins.property
|
|
555
554
|
@pulumi.getter(name="customHeaders")
|
|
556
555
|
def custom_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]]]:
|
|
557
556
|
"""
|
|
@@ -563,9 +562,9 @@ class _MonitorState:
|
|
|
563
562
|
def custom_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]]]):
|
|
564
563
|
pulumi.set(self, "custom_headers", value)
|
|
565
564
|
|
|
566
|
-
@property
|
|
565
|
+
@_builtins.property
|
|
567
566
|
@pulumi.getter(name="deviceOrientation")
|
|
568
|
-
def device_orientation(self) -> Optional[pulumi.Input[
|
|
567
|
+
def device_orientation(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
569
568
|
"""
|
|
570
569
|
Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
571
570
|
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
@@ -573,12 +572,12 @@ class _MonitorState:
|
|
|
573
572
|
return pulumi.get(self, "device_orientation")
|
|
574
573
|
|
|
575
574
|
@device_orientation.setter
|
|
576
|
-
def device_orientation(self, value: Optional[pulumi.Input[
|
|
575
|
+
def device_orientation(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
577
576
|
pulumi.set(self, "device_orientation", value)
|
|
578
577
|
|
|
579
|
-
@property
|
|
578
|
+
@_builtins.property
|
|
580
579
|
@pulumi.getter(name="deviceType")
|
|
581
|
-
def device_type(self) -> Optional[pulumi.Input[
|
|
580
|
+
def device_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
582
581
|
"""
|
|
583
582
|
Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
584
583
|
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
@@ -586,154 +585,154 @@ class _MonitorState:
|
|
|
586
585
|
return pulumi.get(self, "device_type")
|
|
587
586
|
|
|
588
587
|
@device_type.setter
|
|
589
|
-
def device_type(self, value: Optional[pulumi.Input[
|
|
588
|
+
def device_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
590
589
|
pulumi.set(self, "device_type", value)
|
|
591
590
|
|
|
592
|
-
@property
|
|
591
|
+
@_builtins.property
|
|
593
592
|
@pulumi.getter
|
|
594
|
-
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
593
|
+
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
595
594
|
"""
|
|
596
595
|
The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
597
596
|
"""
|
|
598
597
|
return pulumi.get(self, "devices")
|
|
599
598
|
|
|
600
599
|
@devices.setter
|
|
601
|
-
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
600
|
+
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
602
601
|
pulumi.set(self, "devices", value)
|
|
603
602
|
|
|
604
|
-
@property
|
|
603
|
+
@_builtins.property
|
|
605
604
|
@pulumi.getter(name="enableScreenshotOnFailureAndScript")
|
|
606
|
-
def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[
|
|
605
|
+
def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
607
606
|
"""
|
|
608
607
|
Capture a screenshot during job execution.
|
|
609
608
|
"""
|
|
610
609
|
return pulumi.get(self, "enable_screenshot_on_failure_and_script")
|
|
611
610
|
|
|
612
611
|
@enable_screenshot_on_failure_and_script.setter
|
|
613
|
-
def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[
|
|
612
|
+
def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
614
613
|
pulumi.set(self, "enable_screenshot_on_failure_and_script", value)
|
|
615
614
|
|
|
616
|
-
@property
|
|
615
|
+
@_builtins.property
|
|
617
616
|
@pulumi.getter(name="locationsPrivates")
|
|
618
|
-
def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
617
|
+
def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
619
618
|
"""
|
|
620
619
|
The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
621
620
|
"""
|
|
622
621
|
return pulumi.get(self, "locations_privates")
|
|
623
622
|
|
|
624
623
|
@locations_privates.setter
|
|
625
|
-
def locations_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
624
|
+
def locations_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
626
625
|
pulumi.set(self, "locations_privates", value)
|
|
627
626
|
|
|
628
|
-
@property
|
|
627
|
+
@_builtins.property
|
|
629
628
|
@pulumi.getter(name="locationsPublics")
|
|
630
|
-
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
629
|
+
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
631
630
|
"""
|
|
632
631
|
The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
633
632
|
"""
|
|
634
633
|
return pulumi.get(self, "locations_publics")
|
|
635
634
|
|
|
636
635
|
@locations_publics.setter
|
|
637
|
-
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
636
|
+
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
638
637
|
pulumi.set(self, "locations_publics", value)
|
|
639
638
|
|
|
640
|
-
@property
|
|
639
|
+
@_builtins.property
|
|
641
640
|
@pulumi.getter(name="monitorId")
|
|
642
|
-
def monitor_id(self) -> Optional[pulumi.Input[
|
|
641
|
+
def monitor_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
643
642
|
"""
|
|
644
643
|
The monitor id of the Synthetics monitor (not to be confused with the GUID of the monitor).
|
|
645
644
|
"""
|
|
646
645
|
return pulumi.get(self, "monitor_id")
|
|
647
646
|
|
|
648
647
|
@monitor_id.setter
|
|
649
|
-
def monitor_id(self, value: Optional[pulumi.Input[
|
|
648
|
+
def monitor_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
650
649
|
pulumi.set(self, "monitor_id", value)
|
|
651
650
|
|
|
652
|
-
@property
|
|
651
|
+
@_builtins.property
|
|
653
652
|
@pulumi.getter
|
|
654
|
-
def name(self) -> Optional[pulumi.Input[
|
|
653
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
655
654
|
"""
|
|
656
655
|
The human-readable identifier for the monitor.
|
|
657
656
|
"""
|
|
658
657
|
return pulumi.get(self, "name")
|
|
659
658
|
|
|
660
659
|
@name.setter
|
|
661
|
-
def name(self, value: Optional[pulumi.Input[
|
|
660
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
662
661
|
pulumi.set(self, "name", value)
|
|
663
662
|
|
|
664
|
-
@property
|
|
663
|
+
@_builtins.property
|
|
665
664
|
@pulumi.getter
|
|
666
|
-
def period(self) -> Optional[pulumi.Input[
|
|
665
|
+
def period(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
667
666
|
"""
|
|
668
667
|
The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
669
668
|
"""
|
|
670
669
|
return pulumi.get(self, "period")
|
|
671
670
|
|
|
672
671
|
@period.setter
|
|
673
|
-
def period(self, value: Optional[pulumi.Input[
|
|
672
|
+
def period(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
674
673
|
pulumi.set(self, "period", value)
|
|
675
674
|
|
|
676
|
-
@property
|
|
675
|
+
@_builtins.property
|
|
677
676
|
@pulumi.getter(name="periodInMinutes")
|
|
678
|
-
def period_in_minutes(self) -> Optional[pulumi.Input[
|
|
677
|
+
def period_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
679
678
|
"""
|
|
680
679
|
The interval in minutes at which Synthetic monitor should run.
|
|
681
680
|
"""
|
|
682
681
|
return pulumi.get(self, "period_in_minutes")
|
|
683
682
|
|
|
684
683
|
@period_in_minutes.setter
|
|
685
|
-
def period_in_minutes(self, value: Optional[pulumi.Input[
|
|
684
|
+
def period_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
686
685
|
pulumi.set(self, "period_in_minutes", value)
|
|
687
686
|
|
|
688
|
-
@property
|
|
687
|
+
@_builtins.property
|
|
689
688
|
@pulumi.getter(name="runtimeType")
|
|
690
|
-
def runtime_type(self) -> Optional[pulumi.Input[
|
|
689
|
+
def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
691
690
|
"""
|
|
692
691
|
The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
693
692
|
"""
|
|
694
693
|
return pulumi.get(self, "runtime_type")
|
|
695
694
|
|
|
696
695
|
@runtime_type.setter
|
|
697
|
-
def runtime_type(self, value: Optional[pulumi.Input[
|
|
696
|
+
def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
698
697
|
pulumi.set(self, "runtime_type", value)
|
|
699
698
|
|
|
700
|
-
@property
|
|
699
|
+
@_builtins.property
|
|
701
700
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
702
|
-
def runtime_type_version(self) -> Optional[pulumi.Input[
|
|
701
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
703
702
|
"""
|
|
704
703
|
The specific version of the runtime type selected (`100`).
|
|
705
704
|
"""
|
|
706
705
|
return pulumi.get(self, "runtime_type_version")
|
|
707
706
|
|
|
708
707
|
@runtime_type_version.setter
|
|
709
|
-
def runtime_type_version(self, value: Optional[pulumi.Input[
|
|
708
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
710
709
|
pulumi.set(self, "runtime_type_version", value)
|
|
711
710
|
|
|
712
|
-
@property
|
|
711
|
+
@_builtins.property
|
|
713
712
|
@pulumi.getter(name="scriptLanguage")
|
|
714
|
-
def script_language(self) -> Optional[pulumi.Input[
|
|
713
|
+
def script_language(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
715
714
|
"""
|
|
716
715
|
The programing language that should execute the script.
|
|
717
716
|
"""
|
|
718
717
|
return pulumi.get(self, "script_language")
|
|
719
718
|
|
|
720
719
|
@script_language.setter
|
|
721
|
-
def script_language(self, value: Optional[pulumi.Input[
|
|
720
|
+
def script_language(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
722
721
|
pulumi.set(self, "script_language", value)
|
|
723
722
|
|
|
724
|
-
@property
|
|
723
|
+
@_builtins.property
|
|
725
724
|
@pulumi.getter
|
|
726
|
-
def status(self) -> Optional[pulumi.Input[
|
|
725
|
+
def status(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
727
726
|
"""
|
|
728
727
|
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
729
728
|
"""
|
|
730
729
|
return pulumi.get(self, "status")
|
|
731
730
|
|
|
732
731
|
@status.setter
|
|
733
|
-
def status(self, value: Optional[pulumi.Input[
|
|
732
|
+
def status(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
734
733
|
pulumi.set(self, "status", value)
|
|
735
734
|
|
|
736
|
-
@property
|
|
735
|
+
@_builtins.property
|
|
737
736
|
@pulumi.getter
|
|
738
737
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]]]:
|
|
739
738
|
"""
|
|
@@ -747,73 +746,73 @@ class _MonitorState:
|
|
|
747
746
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]]]):
|
|
748
747
|
pulumi.set(self, "tags", value)
|
|
749
748
|
|
|
750
|
-
@property
|
|
749
|
+
@_builtins.property
|
|
751
750
|
@pulumi.getter(name="treatRedirectAsFailure")
|
|
752
|
-
def treat_redirect_as_failure(self) -> Optional[pulumi.Input[
|
|
751
|
+
def treat_redirect_as_failure(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
753
752
|
"""
|
|
754
753
|
Categorize redirects during a monitor job as a failure.
|
|
755
754
|
"""
|
|
756
755
|
return pulumi.get(self, "treat_redirect_as_failure")
|
|
757
756
|
|
|
758
757
|
@treat_redirect_as_failure.setter
|
|
759
|
-
def treat_redirect_as_failure(self, value: Optional[pulumi.Input[
|
|
758
|
+
def treat_redirect_as_failure(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
760
759
|
pulumi.set(self, "treat_redirect_as_failure", value)
|
|
761
760
|
|
|
762
|
-
@property
|
|
761
|
+
@_builtins.property
|
|
763
762
|
@pulumi.getter
|
|
764
|
-
def type(self) -> Optional[pulumi.Input[
|
|
763
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
765
764
|
"""
|
|
766
765
|
The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
767
766
|
"""
|
|
768
767
|
return pulumi.get(self, "type")
|
|
769
768
|
|
|
770
769
|
@type.setter
|
|
771
|
-
def type(self, value: Optional[pulumi.Input[
|
|
770
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
772
771
|
pulumi.set(self, "type", value)
|
|
773
772
|
|
|
774
|
-
@property
|
|
773
|
+
@_builtins.property
|
|
775
774
|
@pulumi.getter
|
|
776
|
-
def uri(self) -> Optional[pulumi.Input[
|
|
775
|
+
def uri(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
777
776
|
"""
|
|
778
777
|
The URI the monitor runs against.
|
|
779
778
|
"""
|
|
780
779
|
return pulumi.get(self, "uri")
|
|
781
780
|
|
|
782
781
|
@uri.setter
|
|
783
|
-
def uri(self, value: Optional[pulumi.Input[
|
|
782
|
+
def uri(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
784
783
|
pulumi.set(self, "uri", value)
|
|
785
784
|
|
|
786
|
-
@property
|
|
785
|
+
@_builtins.property
|
|
787
786
|
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
788
|
-
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[
|
|
787
|
+
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
789
788
|
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
790
789
|
|
|
791
790
|
@use_unsupported_legacy_runtime.setter
|
|
792
|
-
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[
|
|
791
|
+
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
793
792
|
pulumi.set(self, "use_unsupported_legacy_runtime", value)
|
|
794
793
|
|
|
795
|
-
@property
|
|
794
|
+
@_builtins.property
|
|
796
795
|
@pulumi.getter(name="validationString")
|
|
797
|
-
def validation_string(self) -> Optional[pulumi.Input[
|
|
796
|
+
def validation_string(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
798
797
|
"""
|
|
799
798
|
Validation text for monitor to search for at given URI.
|
|
800
799
|
"""
|
|
801
800
|
return pulumi.get(self, "validation_string")
|
|
802
801
|
|
|
803
802
|
@validation_string.setter
|
|
804
|
-
def validation_string(self, value: Optional[pulumi.Input[
|
|
803
|
+
def validation_string(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
805
804
|
pulumi.set(self, "validation_string", value)
|
|
806
805
|
|
|
807
|
-
@property
|
|
806
|
+
@_builtins.property
|
|
808
807
|
@pulumi.getter(name="verifySsl")
|
|
809
|
-
def verify_ssl(self) -> Optional[pulumi.Input[
|
|
808
|
+
def verify_ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
810
809
|
"""
|
|
811
810
|
Monitor should validate SSL certificate chain.
|
|
812
811
|
"""
|
|
813
812
|
return pulumi.get(self, "verify_ssl")
|
|
814
813
|
|
|
815
814
|
@verify_ssl.setter
|
|
816
|
-
def verify_ssl(self, value: Optional[pulumi.Input[
|
|
815
|
+
def verify_ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
817
816
|
pulumi.set(self, "verify_ssl", value)
|
|
818
817
|
|
|
819
818
|
|
|
@@ -823,29 +822,29 @@ class Monitor(pulumi.CustomResource):
|
|
|
823
822
|
def __init__(__self__,
|
|
824
823
|
resource_name: str,
|
|
825
824
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
826
|
-
account_id: Optional[pulumi.Input[
|
|
827
|
-
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
828
|
-
bypass_head_request: Optional[pulumi.Input[
|
|
825
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
826
|
+
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
827
|
+
bypass_head_request: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
829
828
|
custom_headers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MonitorCustomHeaderArgs', 'MonitorCustomHeaderArgsDict']]]]] = None,
|
|
830
|
-
device_orientation: Optional[pulumi.Input[
|
|
831
|
-
device_type: Optional[pulumi.Input[
|
|
832
|
-
devices: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
833
|
-
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[
|
|
834
|
-
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
835
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
836
|
-
name: Optional[pulumi.Input[
|
|
837
|
-
period: Optional[pulumi.Input[
|
|
838
|
-
runtime_type: Optional[pulumi.Input[
|
|
839
|
-
runtime_type_version: Optional[pulumi.Input[
|
|
840
|
-
script_language: Optional[pulumi.Input[
|
|
841
|
-
status: Optional[pulumi.Input[
|
|
829
|
+
device_orientation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
830
|
+
device_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
831
|
+
devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
832
|
+
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
833
|
+
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
834
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
835
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
836
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
837
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
838
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
839
|
+
script_language: Optional[pulumi.Input[_builtins.str]] = None,
|
|
840
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
842
841
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MonitorTagArgs', 'MonitorTagArgsDict']]]]] = None,
|
|
843
|
-
treat_redirect_as_failure: Optional[pulumi.Input[
|
|
844
|
-
type: Optional[pulumi.Input[
|
|
845
|
-
uri: Optional[pulumi.Input[
|
|
846
|
-
use_unsupported_legacy_runtime: Optional[pulumi.Input[
|
|
847
|
-
validation_string: Optional[pulumi.Input[
|
|
848
|
-
verify_ssl: Optional[pulumi.Input[
|
|
842
|
+
treat_redirect_as_failure: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
843
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
844
|
+
uri: Optional[pulumi.Input[_builtins.str]] = None,
|
|
845
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
846
|
+
validation_string: Optional[pulumi.Input[_builtins.str]] = None,
|
|
847
|
+
verify_ssl: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
849
848
|
__props__=None):
|
|
850
849
|
"""
|
|
851
850
|
## Example Usage
|
|
@@ -999,34 +998,34 @@ class Monitor(pulumi.CustomResource):
|
|
|
999
998
|
|
|
1000
999
|
:param str resource_name: The name of the resource.
|
|
1001
1000
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1002
|
-
:param pulumi.Input[
|
|
1003
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1004
|
-
:param pulumi.Input[
|
|
1001
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
1002
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
1003
|
+
:param pulumi.Input[_builtins.bool] bypass_head_request: Monitor should skip default HEAD request and instead use GET verb in check.
|
|
1005
1004
|
|
|
1006
1005
|
The `BROWSER` monitor type supports the following additional arguments:
|
|
1007
1006
|
:param pulumi.Input[Sequence[pulumi.Input[Union['MonitorCustomHeaderArgs', 'MonitorCustomHeaderArgsDict']]]] custom_headers: Custom headers to use in monitor job. See Nested custom_header blocks below for details.
|
|
1008
|
-
:param pulumi.Input[
|
|
1007
|
+
:param pulumi.Input[_builtins.str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
1009
1008
|
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
1010
|
-
:param pulumi.Input[
|
|
1009
|
+
:param pulumi.Input[_builtins.str] device_type: Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
1011
1010
|
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
1012
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1013
|
-
:param pulumi.Input[
|
|
1014
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1015
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1016
|
-
:param pulumi.Input[
|
|
1017
|
-
:param pulumi.Input[
|
|
1018
|
-
:param pulumi.Input[
|
|
1019
|
-
:param pulumi.Input[
|
|
1020
|
-
:param pulumi.Input[
|
|
1021
|
-
:param pulumi.Input[
|
|
1011
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] devices: The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
1012
|
+
:param pulumi.Input[_builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
1013
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
1014
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
1015
|
+
:param pulumi.Input[_builtins.str] name: The human-readable identifier for the monitor.
|
|
1016
|
+
:param pulumi.Input[_builtins.str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
1017
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
1018
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific version of the runtime type selected (`100`).
|
|
1019
|
+
:param pulumi.Input[_builtins.str] script_language: The programing language that should execute the script.
|
|
1020
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
1022
1021
|
:param pulumi.Input[Sequence[pulumi.Input[Union['MonitorTagArgs', 'MonitorTagArgsDict']]]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
1023
1022
|
|
|
1024
1023
|
The `SIMPLE` monitor type supports the following additional arguments:
|
|
1025
|
-
:param pulumi.Input[
|
|
1026
|
-
:param pulumi.Input[
|
|
1027
|
-
:param pulumi.Input[
|
|
1028
|
-
:param pulumi.Input[
|
|
1029
|
-
:param pulumi.Input[
|
|
1024
|
+
:param pulumi.Input[_builtins.bool] treat_redirect_as_failure: Categorize redirects during a monitor job as a failure.
|
|
1025
|
+
:param pulumi.Input[_builtins.str] type: The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
1026
|
+
:param pulumi.Input[_builtins.str] uri: The URI the monitor runs against.
|
|
1027
|
+
:param pulumi.Input[_builtins.str] validation_string: Validation text for monitor to search for at given URI.
|
|
1028
|
+
:param pulumi.Input[_builtins.bool] verify_ssl: Monitor should validate SSL certificate chain.
|
|
1030
1029
|
"""
|
|
1031
1030
|
...
|
|
1032
1031
|
@overload
|
|
@@ -1199,29 +1198,29 @@ class Monitor(pulumi.CustomResource):
|
|
|
1199
1198
|
def _internal_init(__self__,
|
|
1200
1199
|
resource_name: str,
|
|
1201
1200
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1202
|
-
account_id: Optional[pulumi.Input[
|
|
1203
|
-
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1204
|
-
bypass_head_request: Optional[pulumi.Input[
|
|
1201
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1202
|
+
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1203
|
+
bypass_head_request: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1205
1204
|
custom_headers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MonitorCustomHeaderArgs', 'MonitorCustomHeaderArgsDict']]]]] = None,
|
|
1206
|
-
device_orientation: Optional[pulumi.Input[
|
|
1207
|
-
device_type: Optional[pulumi.Input[
|
|
1208
|
-
devices: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1209
|
-
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[
|
|
1210
|
-
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1211
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1212
|
-
name: Optional[pulumi.Input[
|
|
1213
|
-
period: Optional[pulumi.Input[
|
|
1214
|
-
runtime_type: Optional[pulumi.Input[
|
|
1215
|
-
runtime_type_version: Optional[pulumi.Input[
|
|
1216
|
-
script_language: Optional[pulumi.Input[
|
|
1217
|
-
status: Optional[pulumi.Input[
|
|
1205
|
+
device_orientation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1206
|
+
device_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1207
|
+
devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1208
|
+
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1209
|
+
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1210
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1211
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1212
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1213
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1214
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1215
|
+
script_language: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1216
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1218
1217
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MonitorTagArgs', 'MonitorTagArgsDict']]]]] = None,
|
|
1219
|
-
treat_redirect_as_failure: Optional[pulumi.Input[
|
|
1220
|
-
type: Optional[pulumi.Input[
|
|
1221
|
-
uri: Optional[pulumi.Input[
|
|
1222
|
-
use_unsupported_legacy_runtime: Optional[pulumi.Input[
|
|
1223
|
-
validation_string: Optional[pulumi.Input[
|
|
1224
|
-
verify_ssl: Optional[pulumi.Input[
|
|
1218
|
+
treat_redirect_as_failure: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1219
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1220
|
+
uri: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1221
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1222
|
+
validation_string: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1223
|
+
verify_ssl: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1225
1224
|
__props__=None):
|
|
1226
1225
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1227
1226
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -1270,31 +1269,31 @@ class Monitor(pulumi.CustomResource):
|
|
|
1270
1269
|
def get(resource_name: str,
|
|
1271
1270
|
id: pulumi.Input[str],
|
|
1272
1271
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1273
|
-
account_id: Optional[pulumi.Input[
|
|
1274
|
-
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1275
|
-
bypass_head_request: Optional[pulumi.Input[
|
|
1272
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1273
|
+
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1274
|
+
bypass_head_request: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1276
1275
|
custom_headers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MonitorCustomHeaderArgs', 'MonitorCustomHeaderArgsDict']]]]] = None,
|
|
1277
|
-
device_orientation: Optional[pulumi.Input[
|
|
1278
|
-
device_type: Optional[pulumi.Input[
|
|
1279
|
-
devices: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1280
|
-
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[
|
|
1281
|
-
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1282
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1283
|
-
monitor_id: Optional[pulumi.Input[
|
|
1284
|
-
name: Optional[pulumi.Input[
|
|
1285
|
-
period: Optional[pulumi.Input[
|
|
1286
|
-
period_in_minutes: Optional[pulumi.Input[
|
|
1287
|
-
runtime_type: Optional[pulumi.Input[
|
|
1288
|
-
runtime_type_version: Optional[pulumi.Input[
|
|
1289
|
-
script_language: Optional[pulumi.Input[
|
|
1290
|
-
status: Optional[pulumi.Input[
|
|
1276
|
+
device_orientation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1277
|
+
device_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1278
|
+
devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1279
|
+
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1280
|
+
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1281
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1282
|
+
monitor_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1283
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1284
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1285
|
+
period_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1286
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1287
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1288
|
+
script_language: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1289
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1291
1290
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MonitorTagArgs', 'MonitorTagArgsDict']]]]] = None,
|
|
1292
|
-
treat_redirect_as_failure: Optional[pulumi.Input[
|
|
1293
|
-
type: Optional[pulumi.Input[
|
|
1294
|
-
uri: Optional[pulumi.Input[
|
|
1295
|
-
use_unsupported_legacy_runtime: Optional[pulumi.Input[
|
|
1296
|
-
validation_string: Optional[pulumi.Input[
|
|
1297
|
-
verify_ssl: Optional[pulumi.Input[
|
|
1291
|
+
treat_redirect_as_failure: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1292
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1293
|
+
uri: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1294
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1295
|
+
validation_string: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1296
|
+
verify_ssl: Optional[pulumi.Input[_builtins.bool]] = None) -> 'Monitor':
|
|
1298
1297
|
"""
|
|
1299
1298
|
Get an existing Monitor resource's state with the given name, id, and optional extra
|
|
1300
1299
|
properties used to qualify the lookup.
|
|
@@ -1302,36 +1301,36 @@ class Monitor(pulumi.CustomResource):
|
|
|
1302
1301
|
:param str resource_name: The unique name of the resulting resource.
|
|
1303
1302
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1304
1303
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1305
|
-
:param pulumi.Input[
|
|
1306
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1307
|
-
:param pulumi.Input[
|
|
1304
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
1305
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
1306
|
+
:param pulumi.Input[_builtins.bool] bypass_head_request: Monitor should skip default HEAD request and instead use GET verb in check.
|
|
1308
1307
|
|
|
1309
1308
|
The `BROWSER` monitor type supports the following additional arguments:
|
|
1310
1309
|
:param pulumi.Input[Sequence[pulumi.Input[Union['MonitorCustomHeaderArgs', 'MonitorCustomHeaderArgsDict']]]] custom_headers: Custom headers to use in monitor job. See Nested custom_header blocks below for details.
|
|
1311
|
-
:param pulumi.Input[
|
|
1310
|
+
:param pulumi.Input[_builtins.str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
1312
1311
|
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
1313
|
-
:param pulumi.Input[
|
|
1312
|
+
:param pulumi.Input[_builtins.str] device_type: Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
1314
1313
|
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
1315
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1316
|
-
:param pulumi.Input[
|
|
1317
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1318
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1319
|
-
:param pulumi.Input[
|
|
1320
|
-
:param pulumi.Input[
|
|
1321
|
-
:param pulumi.Input[
|
|
1322
|
-
:param pulumi.Input[
|
|
1323
|
-
:param pulumi.Input[
|
|
1324
|
-
:param pulumi.Input[
|
|
1325
|
-
:param pulumi.Input[
|
|
1326
|
-
:param pulumi.Input[
|
|
1314
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] devices: The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
1315
|
+
:param pulumi.Input[_builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
1316
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
1317
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
1318
|
+
:param pulumi.Input[_builtins.str] monitor_id: The monitor id of the Synthetics monitor (not to be confused with the GUID of the monitor).
|
|
1319
|
+
:param pulumi.Input[_builtins.str] name: The human-readable identifier for the monitor.
|
|
1320
|
+
:param pulumi.Input[_builtins.str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
1321
|
+
:param pulumi.Input[_builtins.int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
|
|
1322
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
1323
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific version of the runtime type selected (`100`).
|
|
1324
|
+
:param pulumi.Input[_builtins.str] script_language: The programing language that should execute the script.
|
|
1325
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
1327
1326
|
:param pulumi.Input[Sequence[pulumi.Input[Union['MonitorTagArgs', 'MonitorTagArgsDict']]]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
1328
1327
|
|
|
1329
1328
|
The `SIMPLE` monitor type supports the following additional arguments:
|
|
1330
|
-
:param pulumi.Input[
|
|
1331
|
-
:param pulumi.Input[
|
|
1332
|
-
:param pulumi.Input[
|
|
1333
|
-
:param pulumi.Input[
|
|
1334
|
-
:param pulumi.Input[
|
|
1329
|
+
:param pulumi.Input[_builtins.bool] treat_redirect_as_failure: Categorize redirects during a monitor job as a failure.
|
|
1330
|
+
:param pulumi.Input[_builtins.str] type: The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
1331
|
+
:param pulumi.Input[_builtins.str] uri: The URI the monitor runs against.
|
|
1332
|
+
:param pulumi.Input[_builtins.str] validation_string: Validation text for monitor to search for at given URI.
|
|
1333
|
+
:param pulumi.Input[_builtins.bool] verify_ssl: Monitor should validate SSL certificate chain.
|
|
1335
1334
|
"""
|
|
1336
1335
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
1337
1336
|
|
|
@@ -1364,25 +1363,25 @@ class Monitor(pulumi.CustomResource):
|
|
|
1364
1363
|
__props__.__dict__["verify_ssl"] = verify_ssl
|
|
1365
1364
|
return Monitor(resource_name, opts=opts, __props__=__props__)
|
|
1366
1365
|
|
|
1367
|
-
@property
|
|
1366
|
+
@_builtins.property
|
|
1368
1367
|
@pulumi.getter(name="accountId")
|
|
1369
|
-
def account_id(self) -> pulumi.Output[
|
|
1368
|
+
def account_id(self) -> pulumi.Output[_builtins.str]:
|
|
1370
1369
|
"""
|
|
1371
1370
|
The account in which the Synthetics monitor will be created.
|
|
1372
1371
|
"""
|
|
1373
1372
|
return pulumi.get(self, "account_id")
|
|
1374
1373
|
|
|
1375
|
-
@property
|
|
1374
|
+
@_builtins.property
|
|
1376
1375
|
@pulumi.getter
|
|
1377
|
-
def browsers(self) -> pulumi.Output[Optional[Sequence[
|
|
1376
|
+
def browsers(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1378
1377
|
"""
|
|
1379
1378
|
The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
1380
1379
|
"""
|
|
1381
1380
|
return pulumi.get(self, "browsers")
|
|
1382
1381
|
|
|
1383
|
-
@property
|
|
1382
|
+
@_builtins.property
|
|
1384
1383
|
@pulumi.getter(name="bypassHeadRequest")
|
|
1385
|
-
def bypass_head_request(self) -> pulumi.Output[Optional[
|
|
1384
|
+
def bypass_head_request(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1386
1385
|
"""
|
|
1387
1386
|
Monitor should skip default HEAD request and instead use GET verb in check.
|
|
1388
1387
|
|
|
@@ -1390,7 +1389,7 @@ class Monitor(pulumi.CustomResource):
|
|
|
1390
1389
|
"""
|
|
1391
1390
|
return pulumi.get(self, "bypass_head_request")
|
|
1392
1391
|
|
|
1393
|
-
@property
|
|
1392
|
+
@_builtins.property
|
|
1394
1393
|
@pulumi.getter(name="customHeaders")
|
|
1395
1394
|
def custom_headers(self) -> pulumi.Output[Optional[Sequence['outputs.MonitorCustomHeader']]]:
|
|
1396
1395
|
"""
|
|
@@ -1398,121 +1397,121 @@ class Monitor(pulumi.CustomResource):
|
|
|
1398
1397
|
"""
|
|
1399
1398
|
return pulumi.get(self, "custom_headers")
|
|
1400
1399
|
|
|
1401
|
-
@property
|
|
1400
|
+
@_builtins.property
|
|
1402
1401
|
@pulumi.getter(name="deviceOrientation")
|
|
1403
|
-
def device_orientation(self) -> pulumi.Output[Optional[
|
|
1402
|
+
def device_orientation(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1404
1403
|
"""
|
|
1405
1404
|
Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
1406
1405
|
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
1407
1406
|
"""
|
|
1408
1407
|
return pulumi.get(self, "device_orientation")
|
|
1409
1408
|
|
|
1410
|
-
@property
|
|
1409
|
+
@_builtins.property
|
|
1411
1410
|
@pulumi.getter(name="deviceType")
|
|
1412
|
-
def device_type(self) -> pulumi.Output[Optional[
|
|
1411
|
+
def device_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1413
1412
|
"""
|
|
1414
1413
|
Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
1415
1414
|
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
1416
1415
|
"""
|
|
1417
1416
|
return pulumi.get(self, "device_type")
|
|
1418
1417
|
|
|
1419
|
-
@property
|
|
1418
|
+
@_builtins.property
|
|
1420
1419
|
@pulumi.getter
|
|
1421
|
-
def devices(self) -> pulumi.Output[Optional[Sequence[
|
|
1420
|
+
def devices(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1422
1421
|
"""
|
|
1423
1422
|
The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
1424
1423
|
"""
|
|
1425
1424
|
return pulumi.get(self, "devices")
|
|
1426
1425
|
|
|
1427
|
-
@property
|
|
1426
|
+
@_builtins.property
|
|
1428
1427
|
@pulumi.getter(name="enableScreenshotOnFailureAndScript")
|
|
1429
|
-
def enable_screenshot_on_failure_and_script(self) -> pulumi.Output[Optional[
|
|
1428
|
+
def enable_screenshot_on_failure_and_script(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1430
1429
|
"""
|
|
1431
1430
|
Capture a screenshot during job execution.
|
|
1432
1431
|
"""
|
|
1433
1432
|
return pulumi.get(self, "enable_screenshot_on_failure_and_script")
|
|
1434
1433
|
|
|
1435
|
-
@property
|
|
1434
|
+
@_builtins.property
|
|
1436
1435
|
@pulumi.getter(name="locationsPrivates")
|
|
1437
|
-
def locations_privates(self) -> pulumi.Output[Optional[Sequence[
|
|
1436
|
+
def locations_privates(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1438
1437
|
"""
|
|
1439
1438
|
The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
1440
1439
|
"""
|
|
1441
1440
|
return pulumi.get(self, "locations_privates")
|
|
1442
1441
|
|
|
1443
|
-
@property
|
|
1442
|
+
@_builtins.property
|
|
1444
1443
|
@pulumi.getter(name="locationsPublics")
|
|
1445
|
-
def locations_publics(self) -> pulumi.Output[Optional[Sequence[
|
|
1444
|
+
def locations_publics(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1446
1445
|
"""
|
|
1447
1446
|
The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
1448
1447
|
"""
|
|
1449
1448
|
return pulumi.get(self, "locations_publics")
|
|
1450
1449
|
|
|
1451
|
-
@property
|
|
1450
|
+
@_builtins.property
|
|
1452
1451
|
@pulumi.getter(name="monitorId")
|
|
1453
|
-
def monitor_id(self) -> pulumi.Output[
|
|
1452
|
+
def monitor_id(self) -> pulumi.Output[_builtins.str]:
|
|
1454
1453
|
"""
|
|
1455
1454
|
The monitor id of the Synthetics monitor (not to be confused with the GUID of the monitor).
|
|
1456
1455
|
"""
|
|
1457
1456
|
return pulumi.get(self, "monitor_id")
|
|
1458
1457
|
|
|
1459
|
-
@property
|
|
1458
|
+
@_builtins.property
|
|
1460
1459
|
@pulumi.getter
|
|
1461
|
-
def name(self) -> pulumi.Output[
|
|
1460
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
1462
1461
|
"""
|
|
1463
1462
|
The human-readable identifier for the monitor.
|
|
1464
1463
|
"""
|
|
1465
1464
|
return pulumi.get(self, "name")
|
|
1466
1465
|
|
|
1467
|
-
@property
|
|
1466
|
+
@_builtins.property
|
|
1468
1467
|
@pulumi.getter
|
|
1469
|
-
def period(self) -> pulumi.Output[
|
|
1468
|
+
def period(self) -> pulumi.Output[_builtins.str]:
|
|
1470
1469
|
"""
|
|
1471
1470
|
The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
1472
1471
|
"""
|
|
1473
1472
|
return pulumi.get(self, "period")
|
|
1474
1473
|
|
|
1475
|
-
@property
|
|
1474
|
+
@_builtins.property
|
|
1476
1475
|
@pulumi.getter(name="periodInMinutes")
|
|
1477
|
-
def period_in_minutes(self) -> pulumi.Output[
|
|
1476
|
+
def period_in_minutes(self) -> pulumi.Output[_builtins.int]:
|
|
1478
1477
|
"""
|
|
1479
1478
|
The interval in minutes at which Synthetic monitor should run.
|
|
1480
1479
|
"""
|
|
1481
1480
|
return pulumi.get(self, "period_in_minutes")
|
|
1482
1481
|
|
|
1483
|
-
@property
|
|
1482
|
+
@_builtins.property
|
|
1484
1483
|
@pulumi.getter(name="runtimeType")
|
|
1485
|
-
def runtime_type(self) -> pulumi.Output[Optional[
|
|
1484
|
+
def runtime_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1486
1485
|
"""
|
|
1487
1486
|
The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
1488
1487
|
"""
|
|
1489
1488
|
return pulumi.get(self, "runtime_type")
|
|
1490
1489
|
|
|
1491
|
-
@property
|
|
1490
|
+
@_builtins.property
|
|
1492
1491
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
1493
|
-
def runtime_type_version(self) -> pulumi.Output[Optional[
|
|
1492
|
+
def runtime_type_version(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1494
1493
|
"""
|
|
1495
1494
|
The specific version of the runtime type selected (`100`).
|
|
1496
1495
|
"""
|
|
1497
1496
|
return pulumi.get(self, "runtime_type_version")
|
|
1498
1497
|
|
|
1499
|
-
@property
|
|
1498
|
+
@_builtins.property
|
|
1500
1499
|
@pulumi.getter(name="scriptLanguage")
|
|
1501
|
-
def script_language(self) -> pulumi.Output[Optional[
|
|
1500
|
+
def script_language(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1502
1501
|
"""
|
|
1503
1502
|
The programing language that should execute the script.
|
|
1504
1503
|
"""
|
|
1505
1504
|
return pulumi.get(self, "script_language")
|
|
1506
1505
|
|
|
1507
|
-
@property
|
|
1506
|
+
@_builtins.property
|
|
1508
1507
|
@pulumi.getter
|
|
1509
|
-
def status(self) -> pulumi.Output[
|
|
1508
|
+
def status(self) -> pulumi.Output[_builtins.str]:
|
|
1510
1509
|
"""
|
|
1511
1510
|
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
1512
1511
|
"""
|
|
1513
1512
|
return pulumi.get(self, "status")
|
|
1514
1513
|
|
|
1515
|
-
@property
|
|
1514
|
+
@_builtins.property
|
|
1516
1515
|
@pulumi.getter
|
|
1517
1516
|
def tags(self) -> pulumi.Output[Optional[Sequence['outputs.MonitorTag']]]:
|
|
1518
1517
|
"""
|
|
@@ -1522,46 +1521,46 @@ class Monitor(pulumi.CustomResource):
|
|
|
1522
1521
|
"""
|
|
1523
1522
|
return pulumi.get(self, "tags")
|
|
1524
1523
|
|
|
1525
|
-
@property
|
|
1524
|
+
@_builtins.property
|
|
1526
1525
|
@pulumi.getter(name="treatRedirectAsFailure")
|
|
1527
|
-
def treat_redirect_as_failure(self) -> pulumi.Output[Optional[
|
|
1526
|
+
def treat_redirect_as_failure(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1528
1527
|
"""
|
|
1529
1528
|
Categorize redirects during a monitor job as a failure.
|
|
1530
1529
|
"""
|
|
1531
1530
|
return pulumi.get(self, "treat_redirect_as_failure")
|
|
1532
1531
|
|
|
1533
|
-
@property
|
|
1532
|
+
@_builtins.property
|
|
1534
1533
|
@pulumi.getter
|
|
1535
|
-
def type(self) -> pulumi.Output[
|
|
1534
|
+
def type(self) -> pulumi.Output[_builtins.str]:
|
|
1536
1535
|
"""
|
|
1537
1536
|
The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
1538
1537
|
"""
|
|
1539
1538
|
return pulumi.get(self, "type")
|
|
1540
1539
|
|
|
1541
|
-
@property
|
|
1540
|
+
@_builtins.property
|
|
1542
1541
|
@pulumi.getter
|
|
1543
|
-
def uri(self) -> pulumi.Output[Optional[
|
|
1542
|
+
def uri(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1544
1543
|
"""
|
|
1545
1544
|
The URI the monitor runs against.
|
|
1546
1545
|
"""
|
|
1547
1546
|
return pulumi.get(self, "uri")
|
|
1548
1547
|
|
|
1549
|
-
@property
|
|
1548
|
+
@_builtins.property
|
|
1550
1549
|
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
1551
|
-
def use_unsupported_legacy_runtime(self) -> pulumi.Output[Optional[
|
|
1550
|
+
def use_unsupported_legacy_runtime(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1552
1551
|
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
1553
1552
|
|
|
1554
|
-
@property
|
|
1553
|
+
@_builtins.property
|
|
1555
1554
|
@pulumi.getter(name="validationString")
|
|
1556
|
-
def validation_string(self) -> pulumi.Output[Optional[
|
|
1555
|
+
def validation_string(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1557
1556
|
"""
|
|
1558
1557
|
Validation text for monitor to search for at given URI.
|
|
1559
1558
|
"""
|
|
1560
1559
|
return pulumi.get(self, "validation_string")
|
|
1561
1560
|
|
|
1562
|
-
@property
|
|
1561
|
+
@_builtins.property
|
|
1563
1562
|
@pulumi.getter(name="verifySsl")
|
|
1564
|
-
def verify_ssl(self) -> pulumi.Output[Optional[
|
|
1563
|
+
def verify_ssl(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1565
1564
|
"""
|
|
1566
1565
|
Monitor should validate SSL certificate chain.
|
|
1567
1566
|
"""
|