pulumi-newrelic 5.47.0a1750228491__py3-none-any.whl → 5.57.2a1762486520__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 +18 -1
- pulumi_newrelic/_inputs.py +4271 -3797
- pulumi_newrelic/account_management.py +35 -36
- pulumi_newrelic/alert_channel.py +61 -62
- 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 +190 -159
- pulumi_newrelic/browser_application.py +113 -114
- pulumi_newrelic/cloud/__init__.py +2 -1
- pulumi_newrelic/cloud/_inputs.py +2225 -2118
- pulumi_newrelic/cloud/aws_govcloud_integrations.py +99 -96
- pulumi_newrelic/cloud/aws_govcloud_link_account.py +69 -70
- pulumi_newrelic/cloud/aws_integrations.py +238 -192
- pulumi_newrelic/cloud/aws_link_account.py +69 -70
- pulumi_newrelic/cloud/azure_integrations.py +178 -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/oci_link_account.py +926 -0
- pulumi_newrelic/cloud/outputs.py +1511 -1410
- 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 +77 -22
- pulumi_newrelic/events_to_metrics_rule.py +95 -96
- pulumi_newrelic/get_account.py +21 -22
- pulumi_newrelic/get_alert_channel.py +24 -21
- pulumi_newrelic/get_alert_policy.py +29 -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 +30 -31
- 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 +146 -154
- pulumi_newrelic/notification_channel.py +164 -165
- pulumi_newrelic/notification_destination.py +121 -136
- pulumi_newrelic/nrql_alert_condition.py +479 -431
- pulumi_newrelic/nrql_drop_rule.py +106 -147
- 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 +114 -115
- pulumi_newrelic/outputs.py +2992 -2674
- pulumi_newrelic/pipeline_cloud_rule.py +335 -0
- 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 +364 -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.47.0a1750228491.dist-info → pulumi_newrelic-5.57.2a1762486520.dist-info}/METADATA +1 -1
- pulumi_newrelic-5.57.2a1762486520.dist-info/RECORD +92 -0
- pulumi_newrelic-5.47.0a1750228491.dist-info/RECORD +0 -90
- {pulumi_newrelic-5.47.0a1750228491.dist-info → pulumi_newrelic-5.57.2a1762486520.dist-info}/WHEEL +0 -0
- {pulumi_newrelic-5.47.0a1750228491.dist-info → pulumi_newrelic-5.57.2a1762486520.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,42 +21,42 @@ __all__ = ['ScriptMonitorArgs', 'ScriptMonitor']
|
|
|
22
21
|
@pulumi.input_type
|
|
23
22
|
class ScriptMonitorArgs:
|
|
24
23
|
def __init__(__self__, *,
|
|
25
|
-
period: pulumi.Input[
|
|
26
|
-
status: pulumi.Input[
|
|
27
|
-
type: pulumi.Input[
|
|
28
|
-
account_id: Optional[pulumi.Input[
|
|
29
|
-
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
30
|
-
device_orientation: Optional[pulumi.Input[
|
|
31
|
-
device_type: Optional[pulumi.Input[
|
|
32
|
-
devices: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
33
|
-
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[
|
|
24
|
+
period: pulumi.Input[_builtins.str],
|
|
25
|
+
status: pulumi.Input[_builtins.str],
|
|
26
|
+
type: pulumi.Input[_builtins.str],
|
|
27
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
28
|
+
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
29
|
+
device_orientation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
30
|
+
device_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
31
|
+
devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
32
|
+
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
34
33
|
location_privates: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorLocationPrivateArgs']]]] = None,
|
|
35
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
36
|
-
name: Optional[pulumi.Input[
|
|
37
|
-
runtime_type: Optional[pulumi.Input[
|
|
38
|
-
runtime_type_version: Optional[pulumi.Input[
|
|
39
|
-
script: Optional[pulumi.Input[
|
|
40
|
-
script_language: Optional[pulumi.Input[
|
|
34
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
35
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
36
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
37
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
38
|
+
script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
39
|
+
script_language: Optional[pulumi.Input[_builtins.str]] = None,
|
|
41
40
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorTagArgs']]]] = None,
|
|
42
|
-
use_unsupported_legacy_runtime: Optional[pulumi.Input[
|
|
41
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
43
42
|
"""
|
|
44
43
|
The set of arguments for constructing a ScriptMonitor resource.
|
|
45
|
-
:param pulumi.Input[
|
|
46
|
-
:param pulumi.Input[
|
|
47
|
-
:param pulumi.Input[
|
|
48
|
-
:param pulumi.Input[
|
|
49
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
50
|
-
:param pulumi.Input[
|
|
51
|
-
:param pulumi.Input[
|
|
52
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
53
|
-
:param pulumi.Input[
|
|
44
|
+
: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`.
|
|
45
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
46
|
+
:param pulumi.Input[_builtins.str] type: The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
47
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
48
|
+
: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`.
|
|
49
|
+
:param pulumi.Input[_builtins.str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`. 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.
|
|
50
|
+
:param pulumi.Input[_builtins.str] device_type: Device emulation type field. Valid values are `MOBILE` and `TABLET`. 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.
|
|
51
|
+
: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`.
|
|
52
|
+
:param pulumi.Input[_builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
54
53
|
:param pulumi.Input[Sequence[pulumi.Input['ScriptMonitorLocationPrivateArgs']]] location_privates: The location the monitor will run from. See Nested location_private blocks below for details. **At least one of either** `locations_public` **or** `location_private` **is required**.
|
|
55
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
56
|
-
:param pulumi.Input[
|
|
57
|
-
:param pulumi.Input[
|
|
58
|
-
:param pulumi.Input[
|
|
59
|
-
:param pulumi.Input[
|
|
60
|
-
:param pulumi.Input[
|
|
54
|
+
: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. The `AWS_` prefix is not needed, as the provider uses NerdGraph. **At least one of either** `locations_public` **or** `location_private` **is required**.
|
|
55
|
+
:param pulumi.Input[_builtins.str] name: The name for the monitor.
|
|
56
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs. For the `SCRIPT_API` monitor type, a valid value is `NODE_API`. For the `SCRIPT_BROWSER` monitor type, a valid value is `CHROME_BROWSER`.
|
|
57
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific version of the runtime type selected. For the `SCRIPT_API` monitor type, a valid value is `16.10`, which corresponds to the version of Node.js. For the `SCRIPT_BROWSER` monitor type, a valid value is `100`, which corresponds to the version of the Chrome browser.
|
|
58
|
+
:param pulumi.Input[_builtins.str] script: The script that the monitor runs.
|
|
59
|
+
:param pulumi.Input[_builtins.str] script_language: The programing language that should execute the script.
|
|
61
60
|
:param pulumi.Input[Sequence[pulumi.Input['ScriptMonitorTagArgs']]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
62
61
|
|
|
63
62
|
The `SCRIPTED_BROWSER` monitor type supports the following additional arguments:
|
|
@@ -96,115 +95,115 @@ class ScriptMonitorArgs:
|
|
|
96
95
|
if use_unsupported_legacy_runtime is not None:
|
|
97
96
|
pulumi.set(__self__, "use_unsupported_legacy_runtime", use_unsupported_legacy_runtime)
|
|
98
97
|
|
|
99
|
-
@property
|
|
98
|
+
@_builtins.property
|
|
100
99
|
@pulumi.getter
|
|
101
|
-
def period(self) -> pulumi.Input[
|
|
100
|
+
def period(self) -> pulumi.Input[_builtins.str]:
|
|
102
101
|
"""
|
|
103
102
|
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`.
|
|
104
103
|
"""
|
|
105
104
|
return pulumi.get(self, "period")
|
|
106
105
|
|
|
107
106
|
@period.setter
|
|
108
|
-
def period(self, value: pulumi.Input[
|
|
107
|
+
def period(self, value: pulumi.Input[_builtins.str]):
|
|
109
108
|
pulumi.set(self, "period", value)
|
|
110
109
|
|
|
111
|
-
@property
|
|
110
|
+
@_builtins.property
|
|
112
111
|
@pulumi.getter
|
|
113
|
-
def status(self) -> pulumi.Input[
|
|
112
|
+
def status(self) -> pulumi.Input[_builtins.str]:
|
|
114
113
|
"""
|
|
115
114
|
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
116
115
|
"""
|
|
117
116
|
return pulumi.get(self, "status")
|
|
118
117
|
|
|
119
118
|
@status.setter
|
|
120
|
-
def status(self, value: pulumi.Input[
|
|
119
|
+
def status(self, value: pulumi.Input[_builtins.str]):
|
|
121
120
|
pulumi.set(self, "status", value)
|
|
122
121
|
|
|
123
|
-
@property
|
|
122
|
+
@_builtins.property
|
|
124
123
|
@pulumi.getter
|
|
125
|
-
def type(self) -> pulumi.Input[
|
|
124
|
+
def type(self) -> pulumi.Input[_builtins.str]:
|
|
126
125
|
"""
|
|
127
126
|
The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
128
127
|
"""
|
|
129
128
|
return pulumi.get(self, "type")
|
|
130
129
|
|
|
131
130
|
@type.setter
|
|
132
|
-
def type(self, value: pulumi.Input[
|
|
131
|
+
def type(self, value: pulumi.Input[_builtins.str]):
|
|
133
132
|
pulumi.set(self, "type", value)
|
|
134
133
|
|
|
135
|
-
@property
|
|
134
|
+
@_builtins.property
|
|
136
135
|
@pulumi.getter(name="accountId")
|
|
137
|
-
def account_id(self) -> Optional[pulumi.Input[
|
|
136
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
138
137
|
"""
|
|
139
138
|
The account in which the Synthetics monitor will be created.
|
|
140
139
|
"""
|
|
141
140
|
return pulumi.get(self, "account_id")
|
|
142
141
|
|
|
143
142
|
@account_id.setter
|
|
144
|
-
def account_id(self, value: Optional[pulumi.Input[
|
|
143
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
145
144
|
pulumi.set(self, "account_id", value)
|
|
146
145
|
|
|
147
|
-
@property
|
|
146
|
+
@_builtins.property
|
|
148
147
|
@pulumi.getter
|
|
149
|
-
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
148
|
+
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
150
149
|
"""
|
|
151
150
|
The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
152
151
|
"""
|
|
153
152
|
return pulumi.get(self, "browsers")
|
|
154
153
|
|
|
155
154
|
@browsers.setter
|
|
156
|
-
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
155
|
+
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
157
156
|
pulumi.set(self, "browsers", value)
|
|
158
157
|
|
|
159
|
-
@property
|
|
158
|
+
@_builtins.property
|
|
160
159
|
@pulumi.getter(name="deviceOrientation")
|
|
161
|
-
def device_orientation(self) -> Optional[pulumi.Input[
|
|
160
|
+
def device_orientation(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
162
161
|
"""
|
|
163
162
|
Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`. 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.
|
|
164
163
|
"""
|
|
165
164
|
return pulumi.get(self, "device_orientation")
|
|
166
165
|
|
|
167
166
|
@device_orientation.setter
|
|
168
|
-
def device_orientation(self, value: Optional[pulumi.Input[
|
|
167
|
+
def device_orientation(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
169
168
|
pulumi.set(self, "device_orientation", value)
|
|
170
169
|
|
|
171
|
-
@property
|
|
170
|
+
@_builtins.property
|
|
172
171
|
@pulumi.getter(name="deviceType")
|
|
173
|
-
def device_type(self) -> Optional[pulumi.Input[
|
|
172
|
+
def device_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
174
173
|
"""
|
|
175
174
|
Device emulation type field. Valid values are `MOBILE` and `TABLET`. 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.
|
|
176
175
|
"""
|
|
177
176
|
return pulumi.get(self, "device_type")
|
|
178
177
|
|
|
179
178
|
@device_type.setter
|
|
180
|
-
def device_type(self, value: Optional[pulumi.Input[
|
|
179
|
+
def device_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
181
180
|
pulumi.set(self, "device_type", value)
|
|
182
181
|
|
|
183
|
-
@property
|
|
182
|
+
@_builtins.property
|
|
184
183
|
@pulumi.getter
|
|
185
|
-
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
184
|
+
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
186
185
|
"""
|
|
187
186
|
The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
188
187
|
"""
|
|
189
188
|
return pulumi.get(self, "devices")
|
|
190
189
|
|
|
191
190
|
@devices.setter
|
|
192
|
-
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
191
|
+
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
193
192
|
pulumi.set(self, "devices", value)
|
|
194
193
|
|
|
195
|
-
@property
|
|
194
|
+
@_builtins.property
|
|
196
195
|
@pulumi.getter(name="enableScreenshotOnFailureAndScript")
|
|
197
|
-
def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[
|
|
196
|
+
def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
198
197
|
"""
|
|
199
198
|
Capture a screenshot during job execution.
|
|
200
199
|
"""
|
|
201
200
|
return pulumi.get(self, "enable_screenshot_on_failure_and_script")
|
|
202
201
|
|
|
203
202
|
@enable_screenshot_on_failure_and_script.setter
|
|
204
|
-
def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[
|
|
203
|
+
def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
205
204
|
pulumi.set(self, "enable_screenshot_on_failure_and_script", value)
|
|
206
205
|
|
|
207
|
-
@property
|
|
206
|
+
@_builtins.property
|
|
208
207
|
@pulumi.getter(name="locationPrivates")
|
|
209
208
|
def location_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorLocationPrivateArgs']]]]:
|
|
210
209
|
"""
|
|
@@ -216,79 +215,79 @@ class ScriptMonitorArgs:
|
|
|
216
215
|
def location_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorLocationPrivateArgs']]]]):
|
|
217
216
|
pulumi.set(self, "location_privates", value)
|
|
218
217
|
|
|
219
|
-
@property
|
|
218
|
+
@_builtins.property
|
|
220
219
|
@pulumi.getter(name="locationsPublics")
|
|
221
|
-
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
220
|
+
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
222
221
|
"""
|
|
223
222
|
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. The `AWS_` prefix is not needed, as the provider uses NerdGraph. **At least one of either** `locations_public` **or** `location_private` **is required**.
|
|
224
223
|
"""
|
|
225
224
|
return pulumi.get(self, "locations_publics")
|
|
226
225
|
|
|
227
226
|
@locations_publics.setter
|
|
228
|
-
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
227
|
+
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
229
228
|
pulumi.set(self, "locations_publics", value)
|
|
230
229
|
|
|
231
|
-
@property
|
|
230
|
+
@_builtins.property
|
|
232
231
|
@pulumi.getter
|
|
233
|
-
def name(self) -> Optional[pulumi.Input[
|
|
232
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
234
233
|
"""
|
|
235
234
|
The name for the monitor.
|
|
236
235
|
"""
|
|
237
236
|
return pulumi.get(self, "name")
|
|
238
237
|
|
|
239
238
|
@name.setter
|
|
240
|
-
def name(self, value: Optional[pulumi.Input[
|
|
239
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
241
240
|
pulumi.set(self, "name", value)
|
|
242
241
|
|
|
243
|
-
@property
|
|
242
|
+
@_builtins.property
|
|
244
243
|
@pulumi.getter(name="runtimeType")
|
|
245
|
-
def runtime_type(self) -> Optional[pulumi.Input[
|
|
244
|
+
def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
246
245
|
"""
|
|
247
246
|
The runtime that the monitor will use to run jobs. For the `SCRIPT_API` monitor type, a valid value is `NODE_API`. For the `SCRIPT_BROWSER` monitor type, a valid value is `CHROME_BROWSER`.
|
|
248
247
|
"""
|
|
249
248
|
return pulumi.get(self, "runtime_type")
|
|
250
249
|
|
|
251
250
|
@runtime_type.setter
|
|
252
|
-
def runtime_type(self, value: Optional[pulumi.Input[
|
|
251
|
+
def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
253
252
|
pulumi.set(self, "runtime_type", value)
|
|
254
253
|
|
|
255
|
-
@property
|
|
254
|
+
@_builtins.property
|
|
256
255
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
257
|
-
def runtime_type_version(self) -> Optional[pulumi.Input[
|
|
256
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
258
257
|
"""
|
|
259
258
|
The specific version of the runtime type selected. For the `SCRIPT_API` monitor type, a valid value is `16.10`, which corresponds to the version of Node.js. For the `SCRIPT_BROWSER` monitor type, a valid value is `100`, which corresponds to the version of the Chrome browser.
|
|
260
259
|
"""
|
|
261
260
|
return pulumi.get(self, "runtime_type_version")
|
|
262
261
|
|
|
263
262
|
@runtime_type_version.setter
|
|
264
|
-
def runtime_type_version(self, value: Optional[pulumi.Input[
|
|
263
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
265
264
|
pulumi.set(self, "runtime_type_version", value)
|
|
266
265
|
|
|
267
|
-
@property
|
|
266
|
+
@_builtins.property
|
|
268
267
|
@pulumi.getter
|
|
269
|
-
def script(self) -> Optional[pulumi.Input[
|
|
268
|
+
def script(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
270
269
|
"""
|
|
271
270
|
The script that the monitor runs.
|
|
272
271
|
"""
|
|
273
272
|
return pulumi.get(self, "script")
|
|
274
273
|
|
|
275
274
|
@script.setter
|
|
276
|
-
def script(self, value: Optional[pulumi.Input[
|
|
275
|
+
def script(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
277
276
|
pulumi.set(self, "script", value)
|
|
278
277
|
|
|
279
|
-
@property
|
|
278
|
+
@_builtins.property
|
|
280
279
|
@pulumi.getter(name="scriptLanguage")
|
|
281
|
-
def script_language(self) -> Optional[pulumi.Input[
|
|
280
|
+
def script_language(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
282
281
|
"""
|
|
283
282
|
The programing language that should execute the script.
|
|
284
283
|
"""
|
|
285
284
|
return pulumi.get(self, "script_language")
|
|
286
285
|
|
|
287
286
|
@script_language.setter
|
|
288
|
-
def script_language(self, value: Optional[pulumi.Input[
|
|
287
|
+
def script_language(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
289
288
|
pulumi.set(self, "script_language", value)
|
|
290
289
|
|
|
291
|
-
@property
|
|
290
|
+
@_builtins.property
|
|
292
291
|
@pulumi.getter
|
|
293
292
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorTagArgs']]]]:
|
|
294
293
|
"""
|
|
@@ -302,64 +301,64 @@ class ScriptMonitorArgs:
|
|
|
302
301
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorTagArgs']]]]):
|
|
303
302
|
pulumi.set(self, "tags", value)
|
|
304
303
|
|
|
305
|
-
@property
|
|
304
|
+
@_builtins.property
|
|
306
305
|
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
307
|
-
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[
|
|
306
|
+
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
308
307
|
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
309
308
|
|
|
310
309
|
@use_unsupported_legacy_runtime.setter
|
|
311
|
-
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[
|
|
310
|
+
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
312
311
|
pulumi.set(self, "use_unsupported_legacy_runtime", value)
|
|
313
312
|
|
|
314
313
|
|
|
315
314
|
@pulumi.input_type
|
|
316
315
|
class _ScriptMonitorState:
|
|
317
316
|
def __init__(__self__, *,
|
|
318
|
-
account_id: Optional[pulumi.Input[
|
|
319
|
-
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
320
|
-
device_orientation: Optional[pulumi.Input[
|
|
321
|
-
device_type: Optional[pulumi.Input[
|
|
322
|
-
devices: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
323
|
-
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[
|
|
324
|
-
guid: Optional[pulumi.Input[
|
|
317
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
318
|
+
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
319
|
+
device_orientation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
320
|
+
device_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
321
|
+
devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
322
|
+
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
323
|
+
guid: Optional[pulumi.Input[_builtins.str]] = None,
|
|
325
324
|
location_privates: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorLocationPrivateArgs']]]] = None,
|
|
326
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
327
|
-
monitor_id: Optional[pulumi.Input[
|
|
328
|
-
name: Optional[pulumi.Input[
|
|
329
|
-
period: Optional[pulumi.Input[
|
|
330
|
-
period_in_minutes: Optional[pulumi.Input[
|
|
331
|
-
runtime_type: Optional[pulumi.Input[
|
|
332
|
-
runtime_type_version: Optional[pulumi.Input[
|
|
333
|
-
script: Optional[pulumi.Input[
|
|
334
|
-
script_language: Optional[pulumi.Input[
|
|
335
|
-
status: Optional[pulumi.Input[
|
|
325
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
326
|
+
monitor_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
327
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
328
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
329
|
+
period_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
330
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
331
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
332
|
+
script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
333
|
+
script_language: Optional[pulumi.Input[_builtins.str]] = None,
|
|
334
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
336
335
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorTagArgs']]]] = None,
|
|
337
|
-
type: Optional[pulumi.Input[
|
|
338
|
-
use_unsupported_legacy_runtime: Optional[pulumi.Input[
|
|
336
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
337
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
339
338
|
"""
|
|
340
339
|
Input properties used for looking up and filtering ScriptMonitor resources.
|
|
341
|
-
:param pulumi.Input[
|
|
342
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
343
|
-
:param pulumi.Input[
|
|
344
|
-
:param pulumi.Input[
|
|
345
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
346
|
-
:param pulumi.Input[
|
|
347
|
-
:param pulumi.Input[
|
|
340
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
341
|
+
: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`.
|
|
342
|
+
:param pulumi.Input[_builtins.str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`. 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.
|
|
343
|
+
:param pulumi.Input[_builtins.str] device_type: Device emulation type field. Valid values are `MOBILE` and `TABLET`. 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.
|
|
344
|
+
: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`.
|
|
345
|
+
:param pulumi.Input[_builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
346
|
+
:param pulumi.Input[_builtins.str] guid: The unique entity identifier of the monitor in New Relic.
|
|
348
347
|
:param pulumi.Input[Sequence[pulumi.Input['ScriptMonitorLocationPrivateArgs']]] location_privates: The location the monitor will run from. See Nested location_private blocks below for details. **At least one of either** `locations_public` **or** `location_private` **is required**.
|
|
349
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
350
|
-
:param pulumi.Input[
|
|
351
|
-
:param pulumi.Input[
|
|
352
|
-
:param pulumi.Input[
|
|
353
|
-
:param pulumi.Input[
|
|
354
|
-
:param pulumi.Input[
|
|
355
|
-
:param pulumi.Input[
|
|
356
|
-
:param pulumi.Input[
|
|
357
|
-
:param pulumi.Input[
|
|
358
|
-
:param pulumi.Input[
|
|
348
|
+
: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. The `AWS_` prefix is not needed, as the provider uses NerdGraph. **At least one of either** `locations_public` **or** `location_private` **is required**.
|
|
349
|
+
:param pulumi.Input[_builtins.str] monitor_id: The monitor id of the Synthetics script monitor (not to be confused with the GUID of the monitor).
|
|
350
|
+
:param pulumi.Input[_builtins.str] name: The name for the monitor.
|
|
351
|
+
: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`.
|
|
352
|
+
:param pulumi.Input[_builtins.int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
|
|
353
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs. For the `SCRIPT_API` monitor type, a valid value is `NODE_API`. For the `SCRIPT_BROWSER` monitor type, a valid value is `CHROME_BROWSER`.
|
|
354
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific version of the runtime type selected. For the `SCRIPT_API` monitor type, a valid value is `16.10`, which corresponds to the version of Node.js. For the `SCRIPT_BROWSER` monitor type, a valid value is `100`, which corresponds to the version of the Chrome browser.
|
|
355
|
+
:param pulumi.Input[_builtins.str] script: The script that the monitor runs.
|
|
356
|
+
:param pulumi.Input[_builtins.str] script_language: The programing language that should execute the script.
|
|
357
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
359
358
|
:param pulumi.Input[Sequence[pulumi.Input['ScriptMonitorTagArgs']]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
360
359
|
|
|
361
360
|
The `SCRIPTED_BROWSER` monitor type supports the following additional arguments:
|
|
362
|
-
:param pulumi.Input[
|
|
361
|
+
:param pulumi.Input[_builtins.str] type: The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
363
362
|
"""
|
|
364
363
|
if account_id is not None:
|
|
365
364
|
pulumi.set(__self__, "account_id", account_id)
|
|
@@ -404,91 +403,91 @@ class _ScriptMonitorState:
|
|
|
404
403
|
if use_unsupported_legacy_runtime is not None:
|
|
405
404
|
pulumi.set(__self__, "use_unsupported_legacy_runtime", use_unsupported_legacy_runtime)
|
|
406
405
|
|
|
407
|
-
@property
|
|
406
|
+
@_builtins.property
|
|
408
407
|
@pulumi.getter(name="accountId")
|
|
409
|
-
def account_id(self) -> Optional[pulumi.Input[
|
|
408
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
410
409
|
"""
|
|
411
410
|
The account in which the Synthetics monitor will be created.
|
|
412
411
|
"""
|
|
413
412
|
return pulumi.get(self, "account_id")
|
|
414
413
|
|
|
415
414
|
@account_id.setter
|
|
416
|
-
def account_id(self, value: Optional[pulumi.Input[
|
|
415
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
417
416
|
pulumi.set(self, "account_id", value)
|
|
418
417
|
|
|
419
|
-
@property
|
|
418
|
+
@_builtins.property
|
|
420
419
|
@pulumi.getter
|
|
421
|
-
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
420
|
+
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
422
421
|
"""
|
|
423
422
|
The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
424
423
|
"""
|
|
425
424
|
return pulumi.get(self, "browsers")
|
|
426
425
|
|
|
427
426
|
@browsers.setter
|
|
428
|
-
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
427
|
+
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
429
428
|
pulumi.set(self, "browsers", value)
|
|
430
429
|
|
|
431
|
-
@property
|
|
430
|
+
@_builtins.property
|
|
432
431
|
@pulumi.getter(name="deviceOrientation")
|
|
433
|
-
def device_orientation(self) -> Optional[pulumi.Input[
|
|
432
|
+
def device_orientation(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
434
433
|
"""
|
|
435
434
|
Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`. 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.
|
|
436
435
|
"""
|
|
437
436
|
return pulumi.get(self, "device_orientation")
|
|
438
437
|
|
|
439
438
|
@device_orientation.setter
|
|
440
|
-
def device_orientation(self, value: Optional[pulumi.Input[
|
|
439
|
+
def device_orientation(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
441
440
|
pulumi.set(self, "device_orientation", value)
|
|
442
441
|
|
|
443
|
-
@property
|
|
442
|
+
@_builtins.property
|
|
444
443
|
@pulumi.getter(name="deviceType")
|
|
445
|
-
def device_type(self) -> Optional[pulumi.Input[
|
|
444
|
+
def device_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
446
445
|
"""
|
|
447
446
|
Device emulation type field. Valid values are `MOBILE` and `TABLET`. 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.
|
|
448
447
|
"""
|
|
449
448
|
return pulumi.get(self, "device_type")
|
|
450
449
|
|
|
451
450
|
@device_type.setter
|
|
452
|
-
def device_type(self, value: Optional[pulumi.Input[
|
|
451
|
+
def device_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
453
452
|
pulumi.set(self, "device_type", value)
|
|
454
453
|
|
|
455
|
-
@property
|
|
454
|
+
@_builtins.property
|
|
456
455
|
@pulumi.getter
|
|
457
|
-
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
456
|
+
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
458
457
|
"""
|
|
459
458
|
The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
460
459
|
"""
|
|
461
460
|
return pulumi.get(self, "devices")
|
|
462
461
|
|
|
463
462
|
@devices.setter
|
|
464
|
-
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
463
|
+
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
465
464
|
pulumi.set(self, "devices", value)
|
|
466
465
|
|
|
467
|
-
@property
|
|
466
|
+
@_builtins.property
|
|
468
467
|
@pulumi.getter(name="enableScreenshotOnFailureAndScript")
|
|
469
|
-
def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[
|
|
468
|
+
def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
470
469
|
"""
|
|
471
470
|
Capture a screenshot during job execution.
|
|
472
471
|
"""
|
|
473
472
|
return pulumi.get(self, "enable_screenshot_on_failure_and_script")
|
|
474
473
|
|
|
475
474
|
@enable_screenshot_on_failure_and_script.setter
|
|
476
|
-
def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[
|
|
475
|
+
def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
477
476
|
pulumi.set(self, "enable_screenshot_on_failure_and_script", value)
|
|
478
477
|
|
|
479
|
-
@property
|
|
478
|
+
@_builtins.property
|
|
480
479
|
@pulumi.getter
|
|
481
|
-
def guid(self) -> Optional[pulumi.Input[
|
|
480
|
+
def guid(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
482
481
|
"""
|
|
483
482
|
The unique entity identifier of the monitor in New Relic.
|
|
484
483
|
"""
|
|
485
484
|
return pulumi.get(self, "guid")
|
|
486
485
|
|
|
487
486
|
@guid.setter
|
|
488
|
-
def guid(self, value: Optional[pulumi.Input[
|
|
487
|
+
def guid(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
489
488
|
pulumi.set(self, "guid", value)
|
|
490
489
|
|
|
491
|
-
@property
|
|
490
|
+
@_builtins.property
|
|
492
491
|
@pulumi.getter(name="locationPrivates")
|
|
493
492
|
def location_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorLocationPrivateArgs']]]]:
|
|
494
493
|
"""
|
|
@@ -500,127 +499,127 @@ class _ScriptMonitorState:
|
|
|
500
499
|
def location_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorLocationPrivateArgs']]]]):
|
|
501
500
|
pulumi.set(self, "location_privates", value)
|
|
502
501
|
|
|
503
|
-
@property
|
|
502
|
+
@_builtins.property
|
|
504
503
|
@pulumi.getter(name="locationsPublics")
|
|
505
|
-
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
504
|
+
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
506
505
|
"""
|
|
507
506
|
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. The `AWS_` prefix is not needed, as the provider uses NerdGraph. **At least one of either** `locations_public` **or** `location_private` **is required**.
|
|
508
507
|
"""
|
|
509
508
|
return pulumi.get(self, "locations_publics")
|
|
510
509
|
|
|
511
510
|
@locations_publics.setter
|
|
512
|
-
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
511
|
+
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
513
512
|
pulumi.set(self, "locations_publics", value)
|
|
514
513
|
|
|
515
|
-
@property
|
|
514
|
+
@_builtins.property
|
|
516
515
|
@pulumi.getter(name="monitorId")
|
|
517
|
-
def monitor_id(self) -> Optional[pulumi.Input[
|
|
516
|
+
def monitor_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
518
517
|
"""
|
|
519
518
|
The monitor id of the Synthetics script monitor (not to be confused with the GUID of the monitor).
|
|
520
519
|
"""
|
|
521
520
|
return pulumi.get(self, "monitor_id")
|
|
522
521
|
|
|
523
522
|
@monitor_id.setter
|
|
524
|
-
def monitor_id(self, value: Optional[pulumi.Input[
|
|
523
|
+
def monitor_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
525
524
|
pulumi.set(self, "monitor_id", value)
|
|
526
525
|
|
|
527
|
-
@property
|
|
526
|
+
@_builtins.property
|
|
528
527
|
@pulumi.getter
|
|
529
|
-
def name(self) -> Optional[pulumi.Input[
|
|
528
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
530
529
|
"""
|
|
531
530
|
The name for the monitor.
|
|
532
531
|
"""
|
|
533
532
|
return pulumi.get(self, "name")
|
|
534
533
|
|
|
535
534
|
@name.setter
|
|
536
|
-
def name(self, value: Optional[pulumi.Input[
|
|
535
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
537
536
|
pulumi.set(self, "name", value)
|
|
538
537
|
|
|
539
|
-
@property
|
|
538
|
+
@_builtins.property
|
|
540
539
|
@pulumi.getter
|
|
541
|
-
def period(self) -> Optional[pulumi.Input[
|
|
540
|
+
def period(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
542
541
|
"""
|
|
543
542
|
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`.
|
|
544
543
|
"""
|
|
545
544
|
return pulumi.get(self, "period")
|
|
546
545
|
|
|
547
546
|
@period.setter
|
|
548
|
-
def period(self, value: Optional[pulumi.Input[
|
|
547
|
+
def period(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
549
548
|
pulumi.set(self, "period", value)
|
|
550
549
|
|
|
551
|
-
@property
|
|
550
|
+
@_builtins.property
|
|
552
551
|
@pulumi.getter(name="periodInMinutes")
|
|
553
|
-
def period_in_minutes(self) -> Optional[pulumi.Input[
|
|
552
|
+
def period_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
554
553
|
"""
|
|
555
554
|
The interval in minutes at which Synthetic monitor should run.
|
|
556
555
|
"""
|
|
557
556
|
return pulumi.get(self, "period_in_minutes")
|
|
558
557
|
|
|
559
558
|
@period_in_minutes.setter
|
|
560
|
-
def period_in_minutes(self, value: Optional[pulumi.Input[
|
|
559
|
+
def period_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
561
560
|
pulumi.set(self, "period_in_minutes", value)
|
|
562
561
|
|
|
563
|
-
@property
|
|
562
|
+
@_builtins.property
|
|
564
563
|
@pulumi.getter(name="runtimeType")
|
|
565
|
-
def runtime_type(self) -> Optional[pulumi.Input[
|
|
564
|
+
def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
566
565
|
"""
|
|
567
566
|
The runtime that the monitor will use to run jobs. For the `SCRIPT_API` monitor type, a valid value is `NODE_API`. For the `SCRIPT_BROWSER` monitor type, a valid value is `CHROME_BROWSER`.
|
|
568
567
|
"""
|
|
569
568
|
return pulumi.get(self, "runtime_type")
|
|
570
569
|
|
|
571
570
|
@runtime_type.setter
|
|
572
|
-
def runtime_type(self, value: Optional[pulumi.Input[
|
|
571
|
+
def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
573
572
|
pulumi.set(self, "runtime_type", value)
|
|
574
573
|
|
|
575
|
-
@property
|
|
574
|
+
@_builtins.property
|
|
576
575
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
577
|
-
def runtime_type_version(self) -> Optional[pulumi.Input[
|
|
576
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
578
577
|
"""
|
|
579
578
|
The specific version of the runtime type selected. For the `SCRIPT_API` monitor type, a valid value is `16.10`, which corresponds to the version of Node.js. For the `SCRIPT_BROWSER` monitor type, a valid value is `100`, which corresponds to the version of the Chrome browser.
|
|
580
579
|
"""
|
|
581
580
|
return pulumi.get(self, "runtime_type_version")
|
|
582
581
|
|
|
583
582
|
@runtime_type_version.setter
|
|
584
|
-
def runtime_type_version(self, value: Optional[pulumi.Input[
|
|
583
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
585
584
|
pulumi.set(self, "runtime_type_version", value)
|
|
586
585
|
|
|
587
|
-
@property
|
|
586
|
+
@_builtins.property
|
|
588
587
|
@pulumi.getter
|
|
589
|
-
def script(self) -> Optional[pulumi.Input[
|
|
588
|
+
def script(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
590
589
|
"""
|
|
591
590
|
The script that the monitor runs.
|
|
592
591
|
"""
|
|
593
592
|
return pulumi.get(self, "script")
|
|
594
593
|
|
|
595
594
|
@script.setter
|
|
596
|
-
def script(self, value: Optional[pulumi.Input[
|
|
595
|
+
def script(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
597
596
|
pulumi.set(self, "script", value)
|
|
598
597
|
|
|
599
|
-
@property
|
|
598
|
+
@_builtins.property
|
|
600
599
|
@pulumi.getter(name="scriptLanguage")
|
|
601
|
-
def script_language(self) -> Optional[pulumi.Input[
|
|
600
|
+
def script_language(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
602
601
|
"""
|
|
603
602
|
The programing language that should execute the script.
|
|
604
603
|
"""
|
|
605
604
|
return pulumi.get(self, "script_language")
|
|
606
605
|
|
|
607
606
|
@script_language.setter
|
|
608
|
-
def script_language(self, value: Optional[pulumi.Input[
|
|
607
|
+
def script_language(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
609
608
|
pulumi.set(self, "script_language", value)
|
|
610
609
|
|
|
611
|
-
@property
|
|
610
|
+
@_builtins.property
|
|
612
611
|
@pulumi.getter
|
|
613
|
-
def status(self) -> Optional[pulumi.Input[
|
|
612
|
+
def status(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
614
613
|
"""
|
|
615
614
|
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
616
615
|
"""
|
|
617
616
|
return pulumi.get(self, "status")
|
|
618
617
|
|
|
619
618
|
@status.setter
|
|
620
|
-
def status(self, value: Optional[pulumi.Input[
|
|
619
|
+
def status(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
621
620
|
pulumi.set(self, "status", value)
|
|
622
621
|
|
|
623
|
-
@property
|
|
622
|
+
@_builtins.property
|
|
624
623
|
@pulumi.getter
|
|
625
624
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorTagArgs']]]]:
|
|
626
625
|
"""
|
|
@@ -634,25 +633,25 @@ class _ScriptMonitorState:
|
|
|
634
633
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorTagArgs']]]]):
|
|
635
634
|
pulumi.set(self, "tags", value)
|
|
636
635
|
|
|
637
|
-
@property
|
|
636
|
+
@_builtins.property
|
|
638
637
|
@pulumi.getter
|
|
639
|
-
def type(self) -> Optional[pulumi.Input[
|
|
638
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
640
639
|
"""
|
|
641
640
|
The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
642
641
|
"""
|
|
643
642
|
return pulumi.get(self, "type")
|
|
644
643
|
|
|
645
644
|
@type.setter
|
|
646
|
-
def type(self, value: Optional[pulumi.Input[
|
|
645
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
647
646
|
pulumi.set(self, "type", value)
|
|
648
647
|
|
|
649
|
-
@property
|
|
648
|
+
@_builtins.property
|
|
650
649
|
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
651
|
-
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[
|
|
650
|
+
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
652
651
|
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
653
652
|
|
|
654
653
|
@use_unsupported_legacy_runtime.setter
|
|
655
|
-
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[
|
|
654
|
+
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
656
655
|
pulumi.set(self, "use_unsupported_legacy_runtime", value)
|
|
657
656
|
|
|
658
657
|
|
|
@@ -662,24 +661,24 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
662
661
|
def __init__(__self__,
|
|
663
662
|
resource_name: str,
|
|
664
663
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
665
|
-
account_id: Optional[pulumi.Input[
|
|
666
|
-
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
667
|
-
device_orientation: Optional[pulumi.Input[
|
|
668
|
-
device_type: Optional[pulumi.Input[
|
|
669
|
-
devices: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
670
|
-
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[
|
|
664
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
665
|
+
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
666
|
+
device_orientation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
667
|
+
device_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
668
|
+
devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
669
|
+
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
671
670
|
location_privates: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorLocationPrivateArgs', 'ScriptMonitorLocationPrivateArgsDict']]]]] = None,
|
|
672
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
673
|
-
name: Optional[pulumi.Input[
|
|
674
|
-
period: Optional[pulumi.Input[
|
|
675
|
-
runtime_type: Optional[pulumi.Input[
|
|
676
|
-
runtime_type_version: Optional[pulumi.Input[
|
|
677
|
-
script: Optional[pulumi.Input[
|
|
678
|
-
script_language: Optional[pulumi.Input[
|
|
679
|
-
status: Optional[pulumi.Input[
|
|
671
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
672
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
673
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
674
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
675
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
676
|
+
script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
677
|
+
script_language: Optional[pulumi.Input[_builtins.str]] = None,
|
|
678
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
680
679
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorTagArgs', 'ScriptMonitorTagArgsDict']]]]] = None,
|
|
681
|
-
type: Optional[pulumi.Input[
|
|
682
|
-
use_unsupported_legacy_runtime: Optional[pulumi.Input[
|
|
680
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
681
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
683
682
|
__props__=None):
|
|
684
683
|
"""
|
|
685
684
|
## Example Usage
|
|
@@ -813,6 +812,37 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
813
812
|
}])
|
|
814
813
|
```
|
|
815
814
|
|
|
815
|
+
### Create a monitor and a secure credential
|
|
816
|
+
|
|
817
|
+
The following example shows how to use `depends_on` to create a monitor that uses a new secure credential.
|
|
818
|
+
The `depends_on` creates an explicit dependency between resources to ensure that the secure credential is created before the monitor that uses it.
|
|
819
|
+
|
|
820
|
+
> **NOTE:** Use the `depends_on` when you are creating both monitor and its secure credentials together.
|
|
821
|
+
|
|
822
|
+
##### Type: `SCRIPT_BROWSER`
|
|
823
|
+
|
|
824
|
+
```python
|
|
825
|
+
import pulumi
|
|
826
|
+
import pulumi_newrelic as newrelic
|
|
827
|
+
|
|
828
|
+
example_credential = newrelic.synthetics.SecureCredential("example_credential",
|
|
829
|
+
key="TEST_SECURE_CREDENTIAL",
|
|
830
|
+
value="some_value")
|
|
831
|
+
example_script_monitor = newrelic.synthetics.ScriptMonitor("example_script_monitor",
|
|
832
|
+
name="script_monitor",
|
|
833
|
+
type="SCRIPT_BROWSER",
|
|
834
|
+
period="EVERY_HOUR",
|
|
835
|
+
locations_publics=["US_EAST_1"],
|
|
836
|
+
status="ENABLED",
|
|
837
|
+
script=\"\"\" var assert = require('assert');
|
|
838
|
+
var secureCredential = $secure.TEST_SECURE_CREDENTIAL;
|
|
839
|
+
\"\"\",
|
|
840
|
+
script_language="JAVASCRIPT",
|
|
841
|
+
runtime_type="CHROME_BROWSER",
|
|
842
|
+
runtime_type_version="100",
|
|
843
|
+
opts = pulumi.ResourceOptions(depends_on=[example_credential]))
|
|
844
|
+
```
|
|
845
|
+
|
|
816
846
|
## Import
|
|
817
847
|
|
|
818
848
|
Synthetics monitor scripts can be imported using the `guid`, e.g.
|
|
@@ -825,25 +855,25 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
825
855
|
|
|
826
856
|
:param str resource_name: The name of the resource.
|
|
827
857
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
828
|
-
:param pulumi.Input[
|
|
829
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
830
|
-
:param pulumi.Input[
|
|
831
|
-
:param pulumi.Input[
|
|
832
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
833
|
-
:param pulumi.Input[
|
|
858
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
859
|
+
: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`.
|
|
860
|
+
:param pulumi.Input[_builtins.str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`. 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.
|
|
861
|
+
:param pulumi.Input[_builtins.str] device_type: Device emulation type field. Valid values are `MOBILE` and `TABLET`. 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.
|
|
862
|
+
: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`.
|
|
863
|
+
:param pulumi.Input[_builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
834
864
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorLocationPrivateArgs', 'ScriptMonitorLocationPrivateArgsDict']]]] location_privates: The location the monitor will run from. See Nested location_private blocks below for details. **At least one of either** `locations_public` **or** `location_private` **is required**.
|
|
835
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
836
|
-
:param pulumi.Input[
|
|
837
|
-
:param pulumi.Input[
|
|
838
|
-
:param pulumi.Input[
|
|
839
|
-
:param pulumi.Input[
|
|
840
|
-
:param pulumi.Input[
|
|
841
|
-
:param pulumi.Input[
|
|
842
|
-
:param pulumi.Input[
|
|
865
|
+
: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. The `AWS_` prefix is not needed, as the provider uses NerdGraph. **At least one of either** `locations_public` **or** `location_private` **is required**.
|
|
866
|
+
:param pulumi.Input[_builtins.str] name: The name for the monitor.
|
|
867
|
+
: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`.
|
|
868
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs. For the `SCRIPT_API` monitor type, a valid value is `NODE_API`. For the `SCRIPT_BROWSER` monitor type, a valid value is `CHROME_BROWSER`.
|
|
869
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific version of the runtime type selected. For the `SCRIPT_API` monitor type, a valid value is `16.10`, which corresponds to the version of Node.js. For the `SCRIPT_BROWSER` monitor type, a valid value is `100`, which corresponds to the version of the Chrome browser.
|
|
870
|
+
:param pulumi.Input[_builtins.str] script: The script that the monitor runs.
|
|
871
|
+
:param pulumi.Input[_builtins.str] script_language: The programing language that should execute the script.
|
|
872
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
843
873
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorTagArgs', 'ScriptMonitorTagArgsDict']]]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
844
874
|
|
|
845
875
|
The `SCRIPTED_BROWSER` monitor type supports the following additional arguments:
|
|
846
|
-
:param pulumi.Input[
|
|
876
|
+
:param pulumi.Input[_builtins.str] type: The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
847
877
|
"""
|
|
848
878
|
...
|
|
849
879
|
@overload
|
|
@@ -983,6 +1013,37 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
983
1013
|
}])
|
|
984
1014
|
```
|
|
985
1015
|
|
|
1016
|
+
### Create a monitor and a secure credential
|
|
1017
|
+
|
|
1018
|
+
The following example shows how to use `depends_on` to create a monitor that uses a new secure credential.
|
|
1019
|
+
The `depends_on` creates an explicit dependency between resources to ensure that the secure credential is created before the monitor that uses it.
|
|
1020
|
+
|
|
1021
|
+
> **NOTE:** Use the `depends_on` when you are creating both monitor and its secure credentials together.
|
|
1022
|
+
|
|
1023
|
+
##### Type: `SCRIPT_BROWSER`
|
|
1024
|
+
|
|
1025
|
+
```python
|
|
1026
|
+
import pulumi
|
|
1027
|
+
import pulumi_newrelic as newrelic
|
|
1028
|
+
|
|
1029
|
+
example_credential = newrelic.synthetics.SecureCredential("example_credential",
|
|
1030
|
+
key="TEST_SECURE_CREDENTIAL",
|
|
1031
|
+
value="some_value")
|
|
1032
|
+
example_script_monitor = newrelic.synthetics.ScriptMonitor("example_script_monitor",
|
|
1033
|
+
name="script_monitor",
|
|
1034
|
+
type="SCRIPT_BROWSER",
|
|
1035
|
+
period="EVERY_HOUR",
|
|
1036
|
+
locations_publics=["US_EAST_1"],
|
|
1037
|
+
status="ENABLED",
|
|
1038
|
+
script=\"\"\" var assert = require('assert');
|
|
1039
|
+
var secureCredential = $secure.TEST_SECURE_CREDENTIAL;
|
|
1040
|
+
\"\"\",
|
|
1041
|
+
script_language="JAVASCRIPT",
|
|
1042
|
+
runtime_type="CHROME_BROWSER",
|
|
1043
|
+
runtime_type_version="100",
|
|
1044
|
+
opts = pulumi.ResourceOptions(depends_on=[example_credential]))
|
|
1045
|
+
```
|
|
1046
|
+
|
|
986
1047
|
## Import
|
|
987
1048
|
|
|
988
1049
|
Synthetics monitor scripts can be imported using the `guid`, e.g.
|
|
@@ -1008,24 +1069,24 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
1008
1069
|
def _internal_init(__self__,
|
|
1009
1070
|
resource_name: str,
|
|
1010
1071
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1011
|
-
account_id: Optional[pulumi.Input[
|
|
1012
|
-
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1013
|
-
device_orientation: Optional[pulumi.Input[
|
|
1014
|
-
device_type: Optional[pulumi.Input[
|
|
1015
|
-
devices: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1016
|
-
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[
|
|
1072
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1073
|
+
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1074
|
+
device_orientation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1075
|
+
device_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1076
|
+
devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1077
|
+
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1017
1078
|
location_privates: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorLocationPrivateArgs', 'ScriptMonitorLocationPrivateArgsDict']]]]] = None,
|
|
1018
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1019
|
-
name: Optional[pulumi.Input[
|
|
1020
|
-
period: Optional[pulumi.Input[
|
|
1021
|
-
runtime_type: Optional[pulumi.Input[
|
|
1022
|
-
runtime_type_version: Optional[pulumi.Input[
|
|
1023
|
-
script: Optional[pulumi.Input[
|
|
1024
|
-
script_language: Optional[pulumi.Input[
|
|
1025
|
-
status: Optional[pulumi.Input[
|
|
1079
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1080
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1081
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1082
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1083
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1084
|
+
script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1085
|
+
script_language: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1086
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1026
1087
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorTagArgs', 'ScriptMonitorTagArgsDict']]]]] = None,
|
|
1027
|
-
type: Optional[pulumi.Input[
|
|
1028
|
-
use_unsupported_legacy_runtime: Optional[pulumi.Input[
|
|
1088
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1089
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1029
1090
|
__props__=None):
|
|
1030
1091
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1031
1092
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -1072,27 +1133,27 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
1072
1133
|
def get(resource_name: str,
|
|
1073
1134
|
id: pulumi.Input[str],
|
|
1074
1135
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1075
|
-
account_id: Optional[pulumi.Input[
|
|
1076
|
-
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1077
|
-
device_orientation: Optional[pulumi.Input[
|
|
1078
|
-
device_type: Optional[pulumi.Input[
|
|
1079
|
-
devices: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1080
|
-
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[
|
|
1081
|
-
guid: Optional[pulumi.Input[
|
|
1136
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1137
|
+
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1138
|
+
device_orientation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1139
|
+
device_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1140
|
+
devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1141
|
+
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1142
|
+
guid: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1082
1143
|
location_privates: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorLocationPrivateArgs', 'ScriptMonitorLocationPrivateArgsDict']]]]] = None,
|
|
1083
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1084
|
-
monitor_id: Optional[pulumi.Input[
|
|
1085
|
-
name: Optional[pulumi.Input[
|
|
1086
|
-
period: Optional[pulumi.Input[
|
|
1087
|
-
period_in_minutes: Optional[pulumi.Input[
|
|
1088
|
-
runtime_type: Optional[pulumi.Input[
|
|
1089
|
-
runtime_type_version: Optional[pulumi.Input[
|
|
1090
|
-
script: Optional[pulumi.Input[
|
|
1091
|
-
script_language: Optional[pulumi.Input[
|
|
1092
|
-
status: Optional[pulumi.Input[
|
|
1144
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1145
|
+
monitor_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1146
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1147
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1148
|
+
period_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1149
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1150
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1151
|
+
script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1152
|
+
script_language: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1153
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1093
1154
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorTagArgs', 'ScriptMonitorTagArgsDict']]]]] = None,
|
|
1094
|
-
type: Optional[pulumi.Input[
|
|
1095
|
-
use_unsupported_legacy_runtime: Optional[pulumi.Input[
|
|
1155
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1156
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None) -> 'ScriptMonitor':
|
|
1096
1157
|
"""
|
|
1097
1158
|
Get an existing ScriptMonitor resource's state with the given name, id, and optional extra
|
|
1098
1159
|
properties used to qualify the lookup.
|
|
@@ -1100,28 +1161,28 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
1100
1161
|
:param str resource_name: The unique name of the resulting resource.
|
|
1101
1162
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1102
1163
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1103
|
-
:param pulumi.Input[
|
|
1104
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1105
|
-
:param pulumi.Input[
|
|
1106
|
-
:param pulumi.Input[
|
|
1107
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1108
|
-
:param pulumi.Input[
|
|
1109
|
-
:param pulumi.Input[
|
|
1164
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
1165
|
+
: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`.
|
|
1166
|
+
:param pulumi.Input[_builtins.str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`. 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.
|
|
1167
|
+
:param pulumi.Input[_builtins.str] device_type: Device emulation type field. Valid values are `MOBILE` and `TABLET`. 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.
|
|
1168
|
+
: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`.
|
|
1169
|
+
:param pulumi.Input[_builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
1170
|
+
:param pulumi.Input[_builtins.str] guid: The unique entity identifier of the monitor in New Relic.
|
|
1110
1171
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorLocationPrivateArgs', 'ScriptMonitorLocationPrivateArgsDict']]]] location_privates: The location the monitor will run from. See Nested location_private blocks below for details. **At least one of either** `locations_public` **or** `location_private` **is required**.
|
|
1111
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1112
|
-
:param pulumi.Input[
|
|
1113
|
-
:param pulumi.Input[
|
|
1114
|
-
:param pulumi.Input[
|
|
1115
|
-
:param pulumi.Input[
|
|
1116
|
-
:param pulumi.Input[
|
|
1117
|
-
:param pulumi.Input[
|
|
1118
|
-
:param pulumi.Input[
|
|
1119
|
-
:param pulumi.Input[
|
|
1120
|
-
:param pulumi.Input[
|
|
1172
|
+
: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. The `AWS_` prefix is not needed, as the provider uses NerdGraph. **At least one of either** `locations_public` **or** `location_private` **is required**.
|
|
1173
|
+
:param pulumi.Input[_builtins.str] monitor_id: The monitor id of the Synthetics script monitor (not to be confused with the GUID of the monitor).
|
|
1174
|
+
:param pulumi.Input[_builtins.str] name: The name for the monitor.
|
|
1175
|
+
: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`.
|
|
1176
|
+
:param pulumi.Input[_builtins.int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
|
|
1177
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs. For the `SCRIPT_API` monitor type, a valid value is `NODE_API`. For the `SCRIPT_BROWSER` monitor type, a valid value is `CHROME_BROWSER`.
|
|
1178
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific version of the runtime type selected. For the `SCRIPT_API` monitor type, a valid value is `16.10`, which corresponds to the version of Node.js. For the `SCRIPT_BROWSER` monitor type, a valid value is `100`, which corresponds to the version of the Chrome browser.
|
|
1179
|
+
:param pulumi.Input[_builtins.str] script: The script that the monitor runs.
|
|
1180
|
+
:param pulumi.Input[_builtins.str] script_language: The programing language that should execute the script.
|
|
1181
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
1121
1182
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorTagArgs', 'ScriptMonitorTagArgsDict']]]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
1122
1183
|
|
|
1123
1184
|
The `SCRIPTED_BROWSER` monitor type supports the following additional arguments:
|
|
1124
|
-
:param pulumi.Input[
|
|
1185
|
+
:param pulumi.Input[_builtins.str] type: The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
1125
1186
|
"""
|
|
1126
1187
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
1127
1188
|
|
|
@@ -1150,63 +1211,63 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
1150
1211
|
__props__.__dict__["use_unsupported_legacy_runtime"] = use_unsupported_legacy_runtime
|
|
1151
1212
|
return ScriptMonitor(resource_name, opts=opts, __props__=__props__)
|
|
1152
1213
|
|
|
1153
|
-
@property
|
|
1214
|
+
@_builtins.property
|
|
1154
1215
|
@pulumi.getter(name="accountId")
|
|
1155
|
-
def account_id(self) -> pulumi.Output[
|
|
1216
|
+
def account_id(self) -> pulumi.Output[_builtins.str]:
|
|
1156
1217
|
"""
|
|
1157
1218
|
The account in which the Synthetics monitor will be created.
|
|
1158
1219
|
"""
|
|
1159
1220
|
return pulumi.get(self, "account_id")
|
|
1160
1221
|
|
|
1161
|
-
@property
|
|
1222
|
+
@_builtins.property
|
|
1162
1223
|
@pulumi.getter
|
|
1163
|
-
def browsers(self) -> pulumi.Output[Optional[Sequence[
|
|
1224
|
+
def browsers(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1164
1225
|
"""
|
|
1165
1226
|
The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
1166
1227
|
"""
|
|
1167
1228
|
return pulumi.get(self, "browsers")
|
|
1168
1229
|
|
|
1169
|
-
@property
|
|
1230
|
+
@_builtins.property
|
|
1170
1231
|
@pulumi.getter(name="deviceOrientation")
|
|
1171
|
-
def device_orientation(self) -> pulumi.Output[Optional[
|
|
1232
|
+
def device_orientation(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1172
1233
|
"""
|
|
1173
1234
|
Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`. 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.
|
|
1174
1235
|
"""
|
|
1175
1236
|
return pulumi.get(self, "device_orientation")
|
|
1176
1237
|
|
|
1177
|
-
@property
|
|
1238
|
+
@_builtins.property
|
|
1178
1239
|
@pulumi.getter(name="deviceType")
|
|
1179
|
-
def device_type(self) -> pulumi.Output[Optional[
|
|
1240
|
+
def device_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1180
1241
|
"""
|
|
1181
1242
|
Device emulation type field. Valid values are `MOBILE` and `TABLET`. 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.
|
|
1182
1243
|
"""
|
|
1183
1244
|
return pulumi.get(self, "device_type")
|
|
1184
1245
|
|
|
1185
|
-
@property
|
|
1246
|
+
@_builtins.property
|
|
1186
1247
|
@pulumi.getter
|
|
1187
|
-
def devices(self) -> pulumi.Output[Optional[Sequence[
|
|
1248
|
+
def devices(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1188
1249
|
"""
|
|
1189
1250
|
The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
1190
1251
|
"""
|
|
1191
1252
|
return pulumi.get(self, "devices")
|
|
1192
1253
|
|
|
1193
|
-
@property
|
|
1254
|
+
@_builtins.property
|
|
1194
1255
|
@pulumi.getter(name="enableScreenshotOnFailureAndScript")
|
|
1195
|
-
def enable_screenshot_on_failure_and_script(self) -> pulumi.Output[Optional[
|
|
1256
|
+
def enable_screenshot_on_failure_and_script(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1196
1257
|
"""
|
|
1197
1258
|
Capture a screenshot during job execution.
|
|
1198
1259
|
"""
|
|
1199
1260
|
return pulumi.get(self, "enable_screenshot_on_failure_and_script")
|
|
1200
1261
|
|
|
1201
|
-
@property
|
|
1262
|
+
@_builtins.property
|
|
1202
1263
|
@pulumi.getter
|
|
1203
|
-
def guid(self) -> pulumi.Output[
|
|
1264
|
+
def guid(self) -> pulumi.Output[_builtins.str]:
|
|
1204
1265
|
"""
|
|
1205
1266
|
The unique entity identifier of the monitor in New Relic.
|
|
1206
1267
|
"""
|
|
1207
1268
|
return pulumi.get(self, "guid")
|
|
1208
1269
|
|
|
1209
|
-
@property
|
|
1270
|
+
@_builtins.property
|
|
1210
1271
|
@pulumi.getter(name="locationPrivates")
|
|
1211
1272
|
def location_privates(self) -> pulumi.Output[Optional[Sequence['outputs.ScriptMonitorLocationPrivate']]]:
|
|
1212
1273
|
"""
|
|
@@ -1214,87 +1275,87 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
1214
1275
|
"""
|
|
1215
1276
|
return pulumi.get(self, "location_privates")
|
|
1216
1277
|
|
|
1217
|
-
@property
|
|
1278
|
+
@_builtins.property
|
|
1218
1279
|
@pulumi.getter(name="locationsPublics")
|
|
1219
|
-
def locations_publics(self) -> pulumi.Output[Optional[Sequence[
|
|
1280
|
+
def locations_publics(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1220
1281
|
"""
|
|
1221
1282
|
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. The `AWS_` prefix is not needed, as the provider uses NerdGraph. **At least one of either** `locations_public` **or** `location_private` **is required**.
|
|
1222
1283
|
"""
|
|
1223
1284
|
return pulumi.get(self, "locations_publics")
|
|
1224
1285
|
|
|
1225
|
-
@property
|
|
1286
|
+
@_builtins.property
|
|
1226
1287
|
@pulumi.getter(name="monitorId")
|
|
1227
|
-
def monitor_id(self) -> pulumi.Output[
|
|
1288
|
+
def monitor_id(self) -> pulumi.Output[_builtins.str]:
|
|
1228
1289
|
"""
|
|
1229
1290
|
The monitor id of the Synthetics script monitor (not to be confused with the GUID of the monitor).
|
|
1230
1291
|
"""
|
|
1231
1292
|
return pulumi.get(self, "monitor_id")
|
|
1232
1293
|
|
|
1233
|
-
@property
|
|
1294
|
+
@_builtins.property
|
|
1234
1295
|
@pulumi.getter
|
|
1235
|
-
def name(self) -> pulumi.Output[
|
|
1296
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
1236
1297
|
"""
|
|
1237
1298
|
The name for the monitor.
|
|
1238
1299
|
"""
|
|
1239
1300
|
return pulumi.get(self, "name")
|
|
1240
1301
|
|
|
1241
|
-
@property
|
|
1302
|
+
@_builtins.property
|
|
1242
1303
|
@pulumi.getter
|
|
1243
|
-
def period(self) -> pulumi.Output[
|
|
1304
|
+
def period(self) -> pulumi.Output[_builtins.str]:
|
|
1244
1305
|
"""
|
|
1245
1306
|
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`.
|
|
1246
1307
|
"""
|
|
1247
1308
|
return pulumi.get(self, "period")
|
|
1248
1309
|
|
|
1249
|
-
@property
|
|
1310
|
+
@_builtins.property
|
|
1250
1311
|
@pulumi.getter(name="periodInMinutes")
|
|
1251
|
-
def period_in_minutes(self) -> pulumi.Output[
|
|
1312
|
+
def period_in_minutes(self) -> pulumi.Output[_builtins.int]:
|
|
1252
1313
|
"""
|
|
1253
1314
|
The interval in minutes at which Synthetic monitor should run.
|
|
1254
1315
|
"""
|
|
1255
1316
|
return pulumi.get(self, "period_in_minutes")
|
|
1256
1317
|
|
|
1257
|
-
@property
|
|
1318
|
+
@_builtins.property
|
|
1258
1319
|
@pulumi.getter(name="runtimeType")
|
|
1259
|
-
def runtime_type(self) -> pulumi.Output[Optional[
|
|
1320
|
+
def runtime_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1260
1321
|
"""
|
|
1261
1322
|
The runtime that the monitor will use to run jobs. For the `SCRIPT_API` monitor type, a valid value is `NODE_API`. For the `SCRIPT_BROWSER` monitor type, a valid value is `CHROME_BROWSER`.
|
|
1262
1323
|
"""
|
|
1263
1324
|
return pulumi.get(self, "runtime_type")
|
|
1264
1325
|
|
|
1265
|
-
@property
|
|
1326
|
+
@_builtins.property
|
|
1266
1327
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
1267
|
-
def runtime_type_version(self) -> pulumi.Output[Optional[
|
|
1328
|
+
def runtime_type_version(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1268
1329
|
"""
|
|
1269
1330
|
The specific version of the runtime type selected. For the `SCRIPT_API` monitor type, a valid value is `16.10`, which corresponds to the version of Node.js. For the `SCRIPT_BROWSER` monitor type, a valid value is `100`, which corresponds to the version of the Chrome browser.
|
|
1270
1331
|
"""
|
|
1271
1332
|
return pulumi.get(self, "runtime_type_version")
|
|
1272
1333
|
|
|
1273
|
-
@property
|
|
1334
|
+
@_builtins.property
|
|
1274
1335
|
@pulumi.getter
|
|
1275
|
-
def script(self) -> pulumi.Output[Optional[
|
|
1336
|
+
def script(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1276
1337
|
"""
|
|
1277
1338
|
The script that the monitor runs.
|
|
1278
1339
|
"""
|
|
1279
1340
|
return pulumi.get(self, "script")
|
|
1280
1341
|
|
|
1281
|
-
@property
|
|
1342
|
+
@_builtins.property
|
|
1282
1343
|
@pulumi.getter(name="scriptLanguage")
|
|
1283
|
-
def script_language(self) -> pulumi.Output[Optional[
|
|
1344
|
+
def script_language(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1284
1345
|
"""
|
|
1285
1346
|
The programing language that should execute the script.
|
|
1286
1347
|
"""
|
|
1287
1348
|
return pulumi.get(self, "script_language")
|
|
1288
1349
|
|
|
1289
|
-
@property
|
|
1350
|
+
@_builtins.property
|
|
1290
1351
|
@pulumi.getter
|
|
1291
|
-
def status(self) -> pulumi.Output[
|
|
1352
|
+
def status(self) -> pulumi.Output[_builtins.str]:
|
|
1292
1353
|
"""
|
|
1293
1354
|
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
1294
1355
|
"""
|
|
1295
1356
|
return pulumi.get(self, "status")
|
|
1296
1357
|
|
|
1297
|
-
@property
|
|
1358
|
+
@_builtins.property
|
|
1298
1359
|
@pulumi.getter
|
|
1299
1360
|
def tags(self) -> pulumi.Output[Optional[Sequence['outputs.ScriptMonitorTag']]]:
|
|
1300
1361
|
"""
|
|
@@ -1304,16 +1365,16 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
1304
1365
|
"""
|
|
1305
1366
|
return pulumi.get(self, "tags")
|
|
1306
1367
|
|
|
1307
|
-
@property
|
|
1368
|
+
@_builtins.property
|
|
1308
1369
|
@pulumi.getter
|
|
1309
|
-
def type(self) -> pulumi.Output[
|
|
1370
|
+
def type(self) -> pulumi.Output[_builtins.str]:
|
|
1310
1371
|
"""
|
|
1311
1372
|
The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
1312
1373
|
"""
|
|
1313
1374
|
return pulumi.get(self, "type")
|
|
1314
1375
|
|
|
1315
|
-
@property
|
|
1376
|
+
@_builtins.property
|
|
1316
1377
|
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
1317
|
-
def use_unsupported_legacy_runtime(self) -> pulumi.Output[Optional[
|
|
1378
|
+
def use_unsupported_legacy_runtime(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1318
1379
|
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
1319
1380
|
|