pulumi-newrelic 5.42.1__py3-none-any.whl → 5.58.0a1766556761__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- pulumi_newrelic/__init__.py +19 -1
- pulumi_newrelic/_inputs.py +4314 -3779
- pulumi_newrelic/_utilities.py +1 -1
- pulumi_newrelic/account_management.py +37 -36
- pulumi_newrelic/alert_channel.py +63 -62
- pulumi_newrelic/alert_condition.py +219 -218
- pulumi_newrelic/alert_muting_rule.py +96 -95
- pulumi_newrelic/alert_policy.py +71 -70
- pulumi_newrelic/alert_policy_channel.py +54 -53
- pulumi_newrelic/api_access_key.py +186 -201
- pulumi_newrelic/browser_application.py +115 -114
- pulumi_newrelic/cloud/__init__.py +3 -1
- pulumi_newrelic/cloud/_inputs.py +2226 -2118
- pulumi_newrelic/cloud/aws_govcloud_integrations.py +101 -96
- pulumi_newrelic/cloud/aws_govcloud_link_account.py +71 -70
- pulumi_newrelic/cloud/aws_integrations.py +240 -192
- pulumi_newrelic/cloud/aws_link_account.py +71 -70
- pulumi_newrelic/cloud/azure_integrations.py +180 -132
- pulumi_newrelic/cloud/azure_link_account.py +105 -104
- pulumi_newrelic/cloud/gcp_integrations.py +115 -114
- pulumi_newrelic/cloud/gcp_link_account.py +56 -55
- pulumi_newrelic/cloud/oci_link_account.py +926 -0
- pulumi_newrelic/cloud/outputs.py +1512 -1410
- pulumi_newrelic/config/__init__.py +2 -1
- pulumi_newrelic/config/__init__.pyi +2 -2
- pulumi_newrelic/config/vars.py +15 -15
- pulumi_newrelic/data_partition_rule.py +114 -113
- pulumi_newrelic/entity_tags.py +79 -22
- pulumi_newrelic/events_to_metrics_rule.py +97 -96
- pulumi_newrelic/get_account.py +22 -22
- pulumi_newrelic/get_alert_channel.py +53 -21
- pulumi_newrelic/get_alert_policy.py +52 -26
- pulumi_newrelic/get_application.py +14 -14
- pulumi_newrelic/get_authentication_domain.py +10 -10
- pulumi_newrelic/get_cloud_account.py +22 -22
- pulumi_newrelic/get_entity.py +53 -53
- pulumi_newrelic/get_group.py +22 -22
- pulumi_newrelic/get_key_transaction.py +26 -26
- pulumi_newrelic/get_notification_destination.py +31 -31
- pulumi_newrelic/get_obfuscation_expression.py +16 -16
- pulumi_newrelic/get_service_level_alert_helper.py +54 -54
- pulumi_newrelic/get_test_grok_pattern.py +23 -23
- pulumi_newrelic/get_user.py +22 -22
- pulumi_newrelic/group.py +54 -53
- pulumi_newrelic/infra_alert_condition.py +257 -256
- pulumi_newrelic/insights/__init__.py +2 -1
- pulumi_newrelic/insights/_inputs.py +33 -33
- pulumi_newrelic/insights/event.py +6 -5
- pulumi_newrelic/insights/outputs.py +23 -23
- pulumi_newrelic/key_transaction.py +106 -105
- pulumi_newrelic/log_parsing_rule.py +148 -147
- pulumi_newrelic/monitor_downtime.py +148 -154
- pulumi_newrelic/notification_channel.py +218 -163
- pulumi_newrelic/notification_destination.py +123 -136
- pulumi_newrelic/nrql_alert_condition.py +513 -414
- pulumi_newrelic/nrql_drop_rule.py +108 -147
- pulumi_newrelic/obfuscation_expression.py +71 -70
- pulumi_newrelic/obfuscation_rule.py +91 -90
- pulumi_newrelic/one_dashboard.py +95 -94
- pulumi_newrelic/one_dashboard_json.py +64 -63
- pulumi_newrelic/one_dashboard_raw.py +116 -115
- pulumi_newrelic/outputs.py +3026 -2665
- pulumi_newrelic/pipeline_cloud_rule.py +335 -0
- pulumi_newrelic/plugins/__init__.py +2 -1
- pulumi_newrelic/plugins/_inputs.py +159 -159
- pulumi_newrelic/plugins/application_settings.py +186 -171
- pulumi_newrelic/plugins/outputs.py +109 -109
- pulumi_newrelic/plugins/workload.py +133 -132
- pulumi_newrelic/provider.py +136 -116
- pulumi_newrelic/pulumi-plugin.json +1 -1
- pulumi_newrelic/service_level.py +78 -77
- pulumi_newrelic/synthetics/__init__.py +2 -1
- pulumi_newrelic/synthetics/_inputs.py +128 -128
- pulumi_newrelic/synthetics/alert_condition.py +97 -96
- pulumi_newrelic/synthetics/broken_links_monitor.py +218 -189
- pulumi_newrelic/synthetics/cert_check_monitor.py +226 -197
- pulumi_newrelic/synthetics/get_private_location.py +22 -22
- pulumi_newrelic/synthetics/get_secure_credential.py +20 -20
- pulumi_newrelic/synthetics/monitor.py +399 -370
- pulumi_newrelic/synthetics/multi_location_alert_condition.py +120 -119
- pulumi_newrelic/synthetics/outputs.py +86 -86
- pulumi_newrelic/synthetics/private_location.py +107 -106
- pulumi_newrelic/synthetics/script_monitor.py +385 -294
- pulumi_newrelic/synthetics/secure_credential.py +88 -87
- pulumi_newrelic/synthetics/step_monitor.py +241 -212
- pulumi_newrelic/user.py +71 -70
- pulumi_newrelic/workflow.py +141 -140
- {pulumi_newrelic-5.42.1.dist-info → pulumi_newrelic-5.58.0a1766556761.dist-info}/METADATA +4 -4
- pulumi_newrelic-5.58.0a1766556761.dist-info/RECORD +92 -0
- {pulumi_newrelic-5.42.1.dist-info → pulumi_newrelic-5.58.0a1766556761.dist-info}/WHEEL +1 -1
- pulumi_newrelic-5.42.1.dist-info/RECORD +0 -90
- {pulumi_newrelic-5.42.1.dist-info → pulumi_newrelic-5.58.0a1766556761.dist-info}/top_level.txt +0 -0
|
@@ -1,8 +1,8 @@
|
|
|
1
1
|
# coding=utf-8
|
|
2
|
-
# *** WARNING: this file was generated by
|
|
2
|
+
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
-
import
|
|
5
|
+
import builtins as _builtins
|
|
6
6
|
import warnings
|
|
7
7
|
import sys
|
|
8
8
|
import pulumi
|
|
@@ -21,42 +21,42 @@ __all__ = ['ScriptMonitorArgs', 'ScriptMonitor']
|
|
|
21
21
|
@pulumi.input_type
|
|
22
22
|
class ScriptMonitorArgs:
|
|
23
23
|
def __init__(__self__, *,
|
|
24
|
-
period: pulumi.Input[str],
|
|
25
|
-
status: pulumi.Input[str],
|
|
26
|
-
type: pulumi.Input[str],
|
|
27
|
-
account_id: Optional[pulumi.Input[str]] = None,
|
|
28
|
-
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
29
|
-
device_orientation: Optional[pulumi.Input[str]] = None,
|
|
30
|
-
device_type: Optional[pulumi.Input[str]] = None,
|
|
31
|
-
devices: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
32
|
-
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[bool]] = None,
|
|
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,
|
|
33
33
|
location_privates: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorLocationPrivateArgs']]]] = None,
|
|
34
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
35
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
36
|
-
runtime_type: Optional[pulumi.Input[str]] = None,
|
|
37
|
-
runtime_type_version: Optional[pulumi.Input[str]] = None,
|
|
38
|
-
script: Optional[pulumi.Input[str]] = None,
|
|
39
|
-
script_language: Optional[pulumi.Input[str]] = None,
|
|
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,
|
|
40
40
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorTagArgs']]]] = None,
|
|
41
|
-
use_unsupported_legacy_runtime: Optional[pulumi.Input[bool]] = None):
|
|
41
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
42
42
|
"""
|
|
43
43
|
The set of arguments for constructing a ScriptMonitor resource.
|
|
44
|
-
:param pulumi.Input[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[str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
46
|
-
:param pulumi.Input[str] type: The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
47
|
-
:param pulumi.Input[str] account_id: The account in which the Synthetics monitor will be created.
|
|
48
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
49
|
-
:param pulumi.Input[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[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[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[bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
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.
|
|
53
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**.
|
|
54
|
-
:param pulumi.Input[Sequence[pulumi.Input[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[str] name: The name for the monitor.
|
|
56
|
-
:param pulumi.Input[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[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[str] script: The script that the monitor runs.
|
|
59
|
-
:param pulumi.Input[str] script_language: The programing language that should execute the script.
|
|
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.
|
|
60
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.
|
|
61
61
|
|
|
62
62
|
The `SCRIPTED_BROWSER` monitor type supports the following additional arguments:
|
|
@@ -95,115 +95,115 @@ class ScriptMonitorArgs:
|
|
|
95
95
|
if use_unsupported_legacy_runtime is not None:
|
|
96
96
|
pulumi.set(__self__, "use_unsupported_legacy_runtime", use_unsupported_legacy_runtime)
|
|
97
97
|
|
|
98
|
-
@property
|
|
98
|
+
@_builtins.property
|
|
99
99
|
@pulumi.getter
|
|
100
|
-
def period(self) -> pulumi.Input[str]:
|
|
100
|
+
def period(self) -> pulumi.Input[_builtins.str]:
|
|
101
101
|
"""
|
|
102
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`.
|
|
103
103
|
"""
|
|
104
104
|
return pulumi.get(self, "period")
|
|
105
105
|
|
|
106
106
|
@period.setter
|
|
107
|
-
def period(self, value: pulumi.Input[str]):
|
|
107
|
+
def period(self, value: pulumi.Input[_builtins.str]):
|
|
108
108
|
pulumi.set(self, "period", value)
|
|
109
109
|
|
|
110
|
-
@property
|
|
110
|
+
@_builtins.property
|
|
111
111
|
@pulumi.getter
|
|
112
|
-
def status(self) -> pulumi.Input[str]:
|
|
112
|
+
def status(self) -> pulumi.Input[_builtins.str]:
|
|
113
113
|
"""
|
|
114
114
|
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
115
115
|
"""
|
|
116
116
|
return pulumi.get(self, "status")
|
|
117
117
|
|
|
118
118
|
@status.setter
|
|
119
|
-
def status(self, value: pulumi.Input[str]):
|
|
119
|
+
def status(self, value: pulumi.Input[_builtins.str]):
|
|
120
120
|
pulumi.set(self, "status", value)
|
|
121
121
|
|
|
122
|
-
@property
|
|
122
|
+
@_builtins.property
|
|
123
123
|
@pulumi.getter
|
|
124
|
-
def type(self) -> pulumi.Input[str]:
|
|
124
|
+
def type(self) -> pulumi.Input[_builtins.str]:
|
|
125
125
|
"""
|
|
126
126
|
The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
127
127
|
"""
|
|
128
128
|
return pulumi.get(self, "type")
|
|
129
129
|
|
|
130
130
|
@type.setter
|
|
131
|
-
def type(self, value: pulumi.Input[str]):
|
|
131
|
+
def type(self, value: pulumi.Input[_builtins.str]):
|
|
132
132
|
pulumi.set(self, "type", value)
|
|
133
133
|
|
|
134
|
-
@property
|
|
134
|
+
@_builtins.property
|
|
135
135
|
@pulumi.getter(name="accountId")
|
|
136
|
-
def account_id(self) -> Optional[pulumi.Input[str]]:
|
|
136
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
137
137
|
"""
|
|
138
138
|
The account in which the Synthetics monitor will be created.
|
|
139
139
|
"""
|
|
140
140
|
return pulumi.get(self, "account_id")
|
|
141
141
|
|
|
142
142
|
@account_id.setter
|
|
143
|
-
def account_id(self, value: Optional[pulumi.Input[str]]):
|
|
143
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
144
144
|
pulumi.set(self, "account_id", value)
|
|
145
145
|
|
|
146
|
-
@property
|
|
146
|
+
@_builtins.property
|
|
147
147
|
@pulumi.getter
|
|
148
|
-
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
148
|
+
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
149
149
|
"""
|
|
150
150
|
The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
151
151
|
"""
|
|
152
152
|
return pulumi.get(self, "browsers")
|
|
153
153
|
|
|
154
154
|
@browsers.setter
|
|
155
|
-
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
155
|
+
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
156
156
|
pulumi.set(self, "browsers", value)
|
|
157
157
|
|
|
158
|
-
@property
|
|
158
|
+
@_builtins.property
|
|
159
159
|
@pulumi.getter(name="deviceOrientation")
|
|
160
|
-
def device_orientation(self) -> Optional[pulumi.Input[str]]:
|
|
160
|
+
def device_orientation(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
161
161
|
"""
|
|
162
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.
|
|
163
163
|
"""
|
|
164
164
|
return pulumi.get(self, "device_orientation")
|
|
165
165
|
|
|
166
166
|
@device_orientation.setter
|
|
167
|
-
def device_orientation(self, value: Optional[pulumi.Input[str]]):
|
|
167
|
+
def device_orientation(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
168
168
|
pulumi.set(self, "device_orientation", value)
|
|
169
169
|
|
|
170
|
-
@property
|
|
170
|
+
@_builtins.property
|
|
171
171
|
@pulumi.getter(name="deviceType")
|
|
172
|
-
def device_type(self) -> Optional[pulumi.Input[str]]:
|
|
172
|
+
def device_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
173
173
|
"""
|
|
174
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.
|
|
175
175
|
"""
|
|
176
176
|
return pulumi.get(self, "device_type")
|
|
177
177
|
|
|
178
178
|
@device_type.setter
|
|
179
|
-
def device_type(self, value: Optional[pulumi.Input[str]]):
|
|
179
|
+
def device_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
180
180
|
pulumi.set(self, "device_type", value)
|
|
181
181
|
|
|
182
|
-
@property
|
|
182
|
+
@_builtins.property
|
|
183
183
|
@pulumi.getter
|
|
184
|
-
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
184
|
+
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
185
185
|
"""
|
|
186
186
|
The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
187
187
|
"""
|
|
188
188
|
return pulumi.get(self, "devices")
|
|
189
189
|
|
|
190
190
|
@devices.setter
|
|
191
|
-
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
191
|
+
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
192
192
|
pulumi.set(self, "devices", value)
|
|
193
193
|
|
|
194
|
-
@property
|
|
194
|
+
@_builtins.property
|
|
195
195
|
@pulumi.getter(name="enableScreenshotOnFailureAndScript")
|
|
196
|
-
def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[bool]]:
|
|
196
|
+
def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
197
197
|
"""
|
|
198
198
|
Capture a screenshot during job execution.
|
|
199
199
|
"""
|
|
200
200
|
return pulumi.get(self, "enable_screenshot_on_failure_and_script")
|
|
201
201
|
|
|
202
202
|
@enable_screenshot_on_failure_and_script.setter
|
|
203
|
-
def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[bool]]):
|
|
203
|
+
def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
204
204
|
pulumi.set(self, "enable_screenshot_on_failure_and_script", value)
|
|
205
205
|
|
|
206
|
-
@property
|
|
206
|
+
@_builtins.property
|
|
207
207
|
@pulumi.getter(name="locationPrivates")
|
|
208
208
|
def location_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorLocationPrivateArgs']]]]:
|
|
209
209
|
"""
|
|
@@ -215,79 +215,79 @@ class ScriptMonitorArgs:
|
|
|
215
215
|
def location_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorLocationPrivateArgs']]]]):
|
|
216
216
|
pulumi.set(self, "location_privates", value)
|
|
217
217
|
|
|
218
|
-
@property
|
|
218
|
+
@_builtins.property
|
|
219
219
|
@pulumi.getter(name="locationsPublics")
|
|
220
|
-
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
220
|
+
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
221
221
|
"""
|
|
222
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**.
|
|
223
223
|
"""
|
|
224
224
|
return pulumi.get(self, "locations_publics")
|
|
225
225
|
|
|
226
226
|
@locations_publics.setter
|
|
227
|
-
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
227
|
+
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
228
228
|
pulumi.set(self, "locations_publics", value)
|
|
229
229
|
|
|
230
|
-
@property
|
|
230
|
+
@_builtins.property
|
|
231
231
|
@pulumi.getter
|
|
232
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
232
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
233
233
|
"""
|
|
234
234
|
The name for the monitor.
|
|
235
235
|
"""
|
|
236
236
|
return pulumi.get(self, "name")
|
|
237
237
|
|
|
238
238
|
@name.setter
|
|
239
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
239
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
240
240
|
pulumi.set(self, "name", value)
|
|
241
241
|
|
|
242
|
-
@property
|
|
242
|
+
@_builtins.property
|
|
243
243
|
@pulumi.getter(name="runtimeType")
|
|
244
|
-
def runtime_type(self) -> Optional[pulumi.Input[str]]:
|
|
244
|
+
def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
245
245
|
"""
|
|
246
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`.
|
|
247
247
|
"""
|
|
248
248
|
return pulumi.get(self, "runtime_type")
|
|
249
249
|
|
|
250
250
|
@runtime_type.setter
|
|
251
|
-
def runtime_type(self, value: Optional[pulumi.Input[str]]):
|
|
251
|
+
def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
252
252
|
pulumi.set(self, "runtime_type", value)
|
|
253
253
|
|
|
254
|
-
@property
|
|
254
|
+
@_builtins.property
|
|
255
255
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
256
|
-
def runtime_type_version(self) -> Optional[pulumi.Input[str]]:
|
|
256
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
257
257
|
"""
|
|
258
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.
|
|
259
259
|
"""
|
|
260
260
|
return pulumi.get(self, "runtime_type_version")
|
|
261
261
|
|
|
262
262
|
@runtime_type_version.setter
|
|
263
|
-
def runtime_type_version(self, value: Optional[pulumi.Input[str]]):
|
|
263
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
264
264
|
pulumi.set(self, "runtime_type_version", value)
|
|
265
265
|
|
|
266
|
-
@property
|
|
266
|
+
@_builtins.property
|
|
267
267
|
@pulumi.getter
|
|
268
|
-
def script(self) -> Optional[pulumi.Input[str]]:
|
|
268
|
+
def script(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
269
269
|
"""
|
|
270
270
|
The script that the monitor runs.
|
|
271
271
|
"""
|
|
272
272
|
return pulumi.get(self, "script")
|
|
273
273
|
|
|
274
274
|
@script.setter
|
|
275
|
-
def script(self, value: Optional[pulumi.Input[str]]):
|
|
275
|
+
def script(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
276
276
|
pulumi.set(self, "script", value)
|
|
277
277
|
|
|
278
|
-
@property
|
|
278
|
+
@_builtins.property
|
|
279
279
|
@pulumi.getter(name="scriptLanguage")
|
|
280
|
-
def script_language(self) -> Optional[pulumi.Input[str]]:
|
|
280
|
+
def script_language(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
281
281
|
"""
|
|
282
282
|
The programing language that should execute the script.
|
|
283
283
|
"""
|
|
284
284
|
return pulumi.get(self, "script_language")
|
|
285
285
|
|
|
286
286
|
@script_language.setter
|
|
287
|
-
def script_language(self, value: Optional[pulumi.Input[str]]):
|
|
287
|
+
def script_language(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
288
288
|
pulumi.set(self, "script_language", value)
|
|
289
289
|
|
|
290
|
-
@property
|
|
290
|
+
@_builtins.property
|
|
291
291
|
@pulumi.getter
|
|
292
292
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorTagArgs']]]]:
|
|
293
293
|
"""
|
|
@@ -301,62 +301,64 @@ class ScriptMonitorArgs:
|
|
|
301
301
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorTagArgs']]]]):
|
|
302
302
|
pulumi.set(self, "tags", value)
|
|
303
303
|
|
|
304
|
-
@property
|
|
304
|
+
@_builtins.property
|
|
305
305
|
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
306
|
-
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[bool]]:
|
|
306
|
+
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
307
307
|
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
308
308
|
|
|
309
309
|
@use_unsupported_legacy_runtime.setter
|
|
310
|
-
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[bool]]):
|
|
310
|
+
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
311
311
|
pulumi.set(self, "use_unsupported_legacy_runtime", value)
|
|
312
312
|
|
|
313
313
|
|
|
314
314
|
@pulumi.input_type
|
|
315
315
|
class _ScriptMonitorState:
|
|
316
316
|
def __init__(__self__, *,
|
|
317
|
-
account_id: Optional[pulumi.Input[str]] = None,
|
|
318
|
-
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
319
|
-
device_orientation: Optional[pulumi.Input[str]] = None,
|
|
320
|
-
device_type: Optional[pulumi.Input[str]] = None,
|
|
321
|
-
devices: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
322
|
-
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[bool]] = None,
|
|
323
|
-
guid: Optional[pulumi.Input[str]] = None,
|
|
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,
|
|
324
324
|
location_privates: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorLocationPrivateArgs']]]] = None,
|
|
325
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
326
|
-
|
|
327
|
-
|
|
328
|
-
|
|
329
|
-
|
|
330
|
-
|
|
331
|
-
|
|
332
|
-
|
|
333
|
-
|
|
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,
|
|
334
335
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorTagArgs']]]] = None,
|
|
335
|
-
type: Optional[pulumi.Input[str]] = None,
|
|
336
|
-
use_unsupported_legacy_runtime: Optional[pulumi.Input[bool]] = None):
|
|
336
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
337
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
337
338
|
"""
|
|
338
339
|
Input properties used for looking up and filtering ScriptMonitor resources.
|
|
339
|
-
:param pulumi.Input[str] account_id: The account in which the Synthetics monitor will be created.
|
|
340
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
341
|
-
:param pulumi.Input[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.
|
|
342
|
-
:param pulumi.Input[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.
|
|
343
|
-
:param pulumi.Input[Sequence[pulumi.Input[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`.
|
|
344
|
-
:param pulumi.Input[bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
345
|
-
:param pulumi.Input[str] guid: The unique entity identifier of the monitor in New Relic.
|
|
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.
|
|
346
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**.
|
|
347
|
-
:param pulumi.Input[Sequence[pulumi.Input[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**.
|
|
348
|
-
:param pulumi.Input[str]
|
|
349
|
-
:param pulumi.Input[str]
|
|
350
|
-
:param pulumi.Input[
|
|
351
|
-
:param pulumi.Input[
|
|
352
|
-
:param pulumi.Input[str]
|
|
353
|
-
:param pulumi.Input[str]
|
|
354
|
-
:param pulumi.Input[str]
|
|
355
|
-
:param pulumi.Input[str]
|
|
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`).
|
|
356
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.
|
|
357
359
|
|
|
358
360
|
The `SCRIPTED_BROWSER` monitor type supports the following additional arguments:
|
|
359
|
-
:param pulumi.Input[str] type: The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
361
|
+
:param pulumi.Input[_builtins.str] type: The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
360
362
|
"""
|
|
361
363
|
if account_id is not None:
|
|
362
364
|
pulumi.set(__self__, "account_id", account_id)
|
|
@@ -376,6 +378,8 @@ class _ScriptMonitorState:
|
|
|
376
378
|
pulumi.set(__self__, "location_privates", location_privates)
|
|
377
379
|
if locations_publics is not None:
|
|
378
380
|
pulumi.set(__self__, "locations_publics", locations_publics)
|
|
381
|
+
if monitor_id is not None:
|
|
382
|
+
pulumi.set(__self__, "monitor_id", monitor_id)
|
|
379
383
|
if name is not None:
|
|
380
384
|
pulumi.set(__self__, "name", name)
|
|
381
385
|
if period is not None:
|
|
@@ -399,91 +403,91 @@ class _ScriptMonitorState:
|
|
|
399
403
|
if use_unsupported_legacy_runtime is not None:
|
|
400
404
|
pulumi.set(__self__, "use_unsupported_legacy_runtime", use_unsupported_legacy_runtime)
|
|
401
405
|
|
|
402
|
-
@property
|
|
406
|
+
@_builtins.property
|
|
403
407
|
@pulumi.getter(name="accountId")
|
|
404
|
-
def account_id(self) -> Optional[pulumi.Input[str]]:
|
|
408
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
405
409
|
"""
|
|
406
410
|
The account in which the Synthetics monitor will be created.
|
|
407
411
|
"""
|
|
408
412
|
return pulumi.get(self, "account_id")
|
|
409
413
|
|
|
410
414
|
@account_id.setter
|
|
411
|
-
def account_id(self, value: Optional[pulumi.Input[str]]):
|
|
415
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
412
416
|
pulumi.set(self, "account_id", value)
|
|
413
417
|
|
|
414
|
-
@property
|
|
418
|
+
@_builtins.property
|
|
415
419
|
@pulumi.getter
|
|
416
|
-
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
420
|
+
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
417
421
|
"""
|
|
418
422
|
The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
419
423
|
"""
|
|
420
424
|
return pulumi.get(self, "browsers")
|
|
421
425
|
|
|
422
426
|
@browsers.setter
|
|
423
|
-
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
427
|
+
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
424
428
|
pulumi.set(self, "browsers", value)
|
|
425
429
|
|
|
426
|
-
@property
|
|
430
|
+
@_builtins.property
|
|
427
431
|
@pulumi.getter(name="deviceOrientation")
|
|
428
|
-
def device_orientation(self) -> Optional[pulumi.Input[str]]:
|
|
432
|
+
def device_orientation(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
429
433
|
"""
|
|
430
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.
|
|
431
435
|
"""
|
|
432
436
|
return pulumi.get(self, "device_orientation")
|
|
433
437
|
|
|
434
438
|
@device_orientation.setter
|
|
435
|
-
def device_orientation(self, value: Optional[pulumi.Input[str]]):
|
|
439
|
+
def device_orientation(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
436
440
|
pulumi.set(self, "device_orientation", value)
|
|
437
441
|
|
|
438
|
-
@property
|
|
442
|
+
@_builtins.property
|
|
439
443
|
@pulumi.getter(name="deviceType")
|
|
440
|
-
def device_type(self) -> Optional[pulumi.Input[str]]:
|
|
444
|
+
def device_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
441
445
|
"""
|
|
442
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.
|
|
443
447
|
"""
|
|
444
448
|
return pulumi.get(self, "device_type")
|
|
445
449
|
|
|
446
450
|
@device_type.setter
|
|
447
|
-
def device_type(self, value: Optional[pulumi.Input[str]]):
|
|
451
|
+
def device_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
448
452
|
pulumi.set(self, "device_type", value)
|
|
449
453
|
|
|
450
|
-
@property
|
|
454
|
+
@_builtins.property
|
|
451
455
|
@pulumi.getter
|
|
452
|
-
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
456
|
+
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
453
457
|
"""
|
|
454
458
|
The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
455
459
|
"""
|
|
456
460
|
return pulumi.get(self, "devices")
|
|
457
461
|
|
|
458
462
|
@devices.setter
|
|
459
|
-
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
463
|
+
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
460
464
|
pulumi.set(self, "devices", value)
|
|
461
465
|
|
|
462
|
-
@property
|
|
466
|
+
@_builtins.property
|
|
463
467
|
@pulumi.getter(name="enableScreenshotOnFailureAndScript")
|
|
464
|
-
def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[bool]]:
|
|
468
|
+
def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
465
469
|
"""
|
|
466
470
|
Capture a screenshot during job execution.
|
|
467
471
|
"""
|
|
468
472
|
return pulumi.get(self, "enable_screenshot_on_failure_and_script")
|
|
469
473
|
|
|
470
474
|
@enable_screenshot_on_failure_and_script.setter
|
|
471
|
-
def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[bool]]):
|
|
475
|
+
def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
472
476
|
pulumi.set(self, "enable_screenshot_on_failure_and_script", value)
|
|
473
477
|
|
|
474
|
-
@property
|
|
478
|
+
@_builtins.property
|
|
475
479
|
@pulumi.getter
|
|
476
|
-
def guid(self) -> Optional[pulumi.Input[str]]:
|
|
480
|
+
def guid(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
477
481
|
"""
|
|
478
482
|
The unique entity identifier of the monitor in New Relic.
|
|
479
483
|
"""
|
|
480
484
|
return pulumi.get(self, "guid")
|
|
481
485
|
|
|
482
486
|
@guid.setter
|
|
483
|
-
def guid(self, value: Optional[pulumi.Input[str]]):
|
|
487
|
+
def guid(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
484
488
|
pulumi.set(self, "guid", value)
|
|
485
489
|
|
|
486
|
-
@property
|
|
490
|
+
@_builtins.property
|
|
487
491
|
@pulumi.getter(name="locationPrivates")
|
|
488
492
|
def location_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorLocationPrivateArgs']]]]:
|
|
489
493
|
"""
|
|
@@ -495,115 +499,127 @@ class _ScriptMonitorState:
|
|
|
495
499
|
def location_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorLocationPrivateArgs']]]]):
|
|
496
500
|
pulumi.set(self, "location_privates", value)
|
|
497
501
|
|
|
498
|
-
@property
|
|
502
|
+
@_builtins.property
|
|
499
503
|
@pulumi.getter(name="locationsPublics")
|
|
500
|
-
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
504
|
+
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
501
505
|
"""
|
|
502
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**.
|
|
503
507
|
"""
|
|
504
508
|
return pulumi.get(self, "locations_publics")
|
|
505
509
|
|
|
506
510
|
@locations_publics.setter
|
|
507
|
-
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
511
|
+
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
508
512
|
pulumi.set(self, "locations_publics", value)
|
|
509
513
|
|
|
510
|
-
@property
|
|
514
|
+
@_builtins.property
|
|
515
|
+
@pulumi.getter(name="monitorId")
|
|
516
|
+
def monitor_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
517
|
+
"""
|
|
518
|
+
The monitor id of the Synthetics script monitor (not to be confused with the GUID of the monitor).
|
|
519
|
+
"""
|
|
520
|
+
return pulumi.get(self, "monitor_id")
|
|
521
|
+
|
|
522
|
+
@monitor_id.setter
|
|
523
|
+
def monitor_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
524
|
+
pulumi.set(self, "monitor_id", value)
|
|
525
|
+
|
|
526
|
+
@_builtins.property
|
|
511
527
|
@pulumi.getter
|
|
512
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
528
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
513
529
|
"""
|
|
514
530
|
The name for the monitor.
|
|
515
531
|
"""
|
|
516
532
|
return pulumi.get(self, "name")
|
|
517
533
|
|
|
518
534
|
@name.setter
|
|
519
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
535
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
520
536
|
pulumi.set(self, "name", value)
|
|
521
537
|
|
|
522
|
-
@property
|
|
538
|
+
@_builtins.property
|
|
523
539
|
@pulumi.getter
|
|
524
|
-
def period(self) -> Optional[pulumi.Input[str]]:
|
|
540
|
+
def period(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
525
541
|
"""
|
|
526
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`.
|
|
527
543
|
"""
|
|
528
544
|
return pulumi.get(self, "period")
|
|
529
545
|
|
|
530
546
|
@period.setter
|
|
531
|
-
def period(self, value: Optional[pulumi.Input[str]]):
|
|
547
|
+
def period(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
532
548
|
pulumi.set(self, "period", value)
|
|
533
549
|
|
|
534
|
-
@property
|
|
550
|
+
@_builtins.property
|
|
535
551
|
@pulumi.getter(name="periodInMinutes")
|
|
536
|
-
def period_in_minutes(self) -> Optional[pulumi.Input[int]]:
|
|
552
|
+
def period_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
537
553
|
"""
|
|
538
554
|
The interval in minutes at which Synthetic monitor should run.
|
|
539
555
|
"""
|
|
540
556
|
return pulumi.get(self, "period_in_minutes")
|
|
541
557
|
|
|
542
558
|
@period_in_minutes.setter
|
|
543
|
-
def period_in_minutes(self, value: Optional[pulumi.Input[int]]):
|
|
559
|
+
def period_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
544
560
|
pulumi.set(self, "period_in_minutes", value)
|
|
545
561
|
|
|
546
|
-
@property
|
|
562
|
+
@_builtins.property
|
|
547
563
|
@pulumi.getter(name="runtimeType")
|
|
548
|
-
def runtime_type(self) -> Optional[pulumi.Input[str]]:
|
|
564
|
+
def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
549
565
|
"""
|
|
550
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`.
|
|
551
567
|
"""
|
|
552
568
|
return pulumi.get(self, "runtime_type")
|
|
553
569
|
|
|
554
570
|
@runtime_type.setter
|
|
555
|
-
def runtime_type(self, value: Optional[pulumi.Input[str]]):
|
|
571
|
+
def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
556
572
|
pulumi.set(self, "runtime_type", value)
|
|
557
573
|
|
|
558
|
-
@property
|
|
574
|
+
@_builtins.property
|
|
559
575
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
560
|
-
def runtime_type_version(self) -> Optional[pulumi.Input[str]]:
|
|
576
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
561
577
|
"""
|
|
562
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.
|
|
563
579
|
"""
|
|
564
580
|
return pulumi.get(self, "runtime_type_version")
|
|
565
581
|
|
|
566
582
|
@runtime_type_version.setter
|
|
567
|
-
def runtime_type_version(self, value: Optional[pulumi.Input[str]]):
|
|
583
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
568
584
|
pulumi.set(self, "runtime_type_version", value)
|
|
569
585
|
|
|
570
|
-
@property
|
|
586
|
+
@_builtins.property
|
|
571
587
|
@pulumi.getter
|
|
572
|
-
def script(self) -> Optional[pulumi.Input[str]]:
|
|
588
|
+
def script(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
573
589
|
"""
|
|
574
590
|
The script that the monitor runs.
|
|
575
591
|
"""
|
|
576
592
|
return pulumi.get(self, "script")
|
|
577
593
|
|
|
578
594
|
@script.setter
|
|
579
|
-
def script(self, value: Optional[pulumi.Input[str]]):
|
|
595
|
+
def script(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
580
596
|
pulumi.set(self, "script", value)
|
|
581
597
|
|
|
582
|
-
@property
|
|
598
|
+
@_builtins.property
|
|
583
599
|
@pulumi.getter(name="scriptLanguage")
|
|
584
|
-
def script_language(self) -> Optional[pulumi.Input[str]]:
|
|
600
|
+
def script_language(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
585
601
|
"""
|
|
586
602
|
The programing language that should execute the script.
|
|
587
603
|
"""
|
|
588
604
|
return pulumi.get(self, "script_language")
|
|
589
605
|
|
|
590
606
|
@script_language.setter
|
|
591
|
-
def script_language(self, value: Optional[pulumi.Input[str]]):
|
|
607
|
+
def script_language(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
592
608
|
pulumi.set(self, "script_language", value)
|
|
593
609
|
|
|
594
|
-
@property
|
|
610
|
+
@_builtins.property
|
|
595
611
|
@pulumi.getter
|
|
596
|
-
def status(self) -> Optional[pulumi.Input[str]]:
|
|
612
|
+
def status(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
597
613
|
"""
|
|
598
614
|
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
599
615
|
"""
|
|
600
616
|
return pulumi.get(self, "status")
|
|
601
617
|
|
|
602
618
|
@status.setter
|
|
603
|
-
def status(self, value: Optional[pulumi.Input[str]]):
|
|
619
|
+
def status(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
604
620
|
pulumi.set(self, "status", value)
|
|
605
621
|
|
|
606
|
-
@property
|
|
622
|
+
@_builtins.property
|
|
607
623
|
@pulumi.getter
|
|
608
624
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorTagArgs']]]]:
|
|
609
625
|
"""
|
|
@@ -617,51 +633,52 @@ class _ScriptMonitorState:
|
|
|
617
633
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorTagArgs']]]]):
|
|
618
634
|
pulumi.set(self, "tags", value)
|
|
619
635
|
|
|
620
|
-
@property
|
|
636
|
+
@_builtins.property
|
|
621
637
|
@pulumi.getter
|
|
622
|
-
def type(self) -> Optional[pulumi.Input[str]]:
|
|
638
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
623
639
|
"""
|
|
624
640
|
The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
625
641
|
"""
|
|
626
642
|
return pulumi.get(self, "type")
|
|
627
643
|
|
|
628
644
|
@type.setter
|
|
629
|
-
def type(self, value: Optional[pulumi.Input[str]]):
|
|
645
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
630
646
|
pulumi.set(self, "type", value)
|
|
631
647
|
|
|
632
|
-
@property
|
|
648
|
+
@_builtins.property
|
|
633
649
|
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
634
|
-
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[bool]]:
|
|
650
|
+
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
635
651
|
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
636
652
|
|
|
637
653
|
@use_unsupported_legacy_runtime.setter
|
|
638
|
-
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[bool]]):
|
|
654
|
+
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
639
655
|
pulumi.set(self, "use_unsupported_legacy_runtime", value)
|
|
640
656
|
|
|
641
657
|
|
|
658
|
+
@pulumi.type_token("newrelic:synthetics/scriptMonitor:ScriptMonitor")
|
|
642
659
|
class ScriptMonitor(pulumi.CustomResource):
|
|
643
660
|
@overload
|
|
644
661
|
def __init__(__self__,
|
|
645
662
|
resource_name: str,
|
|
646
663
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
647
|
-
account_id: Optional[pulumi.Input[str]] = None,
|
|
648
|
-
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
649
|
-
device_orientation: Optional[pulumi.Input[str]] = None,
|
|
650
|
-
device_type: Optional[pulumi.Input[str]] = None,
|
|
651
|
-
devices: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
652
|
-
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[bool]] = None,
|
|
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,
|
|
653
670
|
location_privates: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorLocationPrivateArgs', 'ScriptMonitorLocationPrivateArgsDict']]]]] = None,
|
|
654
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
655
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
656
|
-
period: Optional[pulumi.Input[str]] = None,
|
|
657
|
-
runtime_type: Optional[pulumi.Input[str]] = None,
|
|
658
|
-
runtime_type_version: Optional[pulumi.Input[str]] = None,
|
|
659
|
-
script: Optional[pulumi.Input[str]] = None,
|
|
660
|
-
script_language: Optional[pulumi.Input[str]] = None,
|
|
661
|
-
status: Optional[pulumi.Input[str]] = None,
|
|
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,
|
|
662
679
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorTagArgs', 'ScriptMonitorTagArgsDict']]]]] = None,
|
|
663
|
-
type: Optional[pulumi.Input[str]] = None,
|
|
664
|
-
use_unsupported_legacy_runtime: Optional[pulumi.Input[bool]] = None,
|
|
680
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
681
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
665
682
|
__props__=None):
|
|
666
683
|
"""
|
|
667
684
|
## Example Usage
|
|
@@ -795,6 +812,37 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
795
812
|
}])
|
|
796
813
|
```
|
|
797
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
|
+
|
|
798
846
|
## Import
|
|
799
847
|
|
|
800
848
|
Synthetics monitor scripts can be imported using the `guid`, e.g.
|
|
@@ -807,25 +855,25 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
807
855
|
|
|
808
856
|
:param str resource_name: The name of the resource.
|
|
809
857
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
810
|
-
:param pulumi.Input[str] account_id: The account in which the Synthetics monitor will be created.
|
|
811
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
812
|
-
:param pulumi.Input[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.
|
|
813
|
-
:param pulumi.Input[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.
|
|
814
|
-
:param pulumi.Input[Sequence[pulumi.Input[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`.
|
|
815
|
-
:param pulumi.Input[bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
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.
|
|
816
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**.
|
|
817
|
-
:param pulumi.Input[Sequence[pulumi.Input[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**.
|
|
818
|
-
:param pulumi.Input[str] name: The name for the monitor.
|
|
819
|
-
:param pulumi.Input[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`.
|
|
820
|
-
:param pulumi.Input[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`.
|
|
821
|
-
:param pulumi.Input[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.
|
|
822
|
-
:param pulumi.Input[str] script: The script that the monitor runs.
|
|
823
|
-
:param pulumi.Input[str] script_language: The programing language that should execute the script.
|
|
824
|
-
:param pulumi.Input[str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
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`).
|
|
825
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.
|
|
826
874
|
|
|
827
875
|
The `SCRIPTED_BROWSER` monitor type supports the following additional arguments:
|
|
828
|
-
:param pulumi.Input[str] type: The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
876
|
+
:param pulumi.Input[_builtins.str] type: The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
829
877
|
"""
|
|
830
878
|
...
|
|
831
879
|
@overload
|
|
@@ -965,6 +1013,37 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
965
1013
|
}])
|
|
966
1014
|
```
|
|
967
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
|
+
|
|
968
1047
|
## Import
|
|
969
1048
|
|
|
970
1049
|
Synthetics monitor scripts can be imported using the `guid`, e.g.
|
|
@@ -990,24 +1069,24 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
990
1069
|
def _internal_init(__self__,
|
|
991
1070
|
resource_name: str,
|
|
992
1071
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
993
|
-
account_id: Optional[pulumi.Input[str]] = None,
|
|
994
|
-
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
995
|
-
device_orientation: Optional[pulumi.Input[str]] = None,
|
|
996
|
-
device_type: Optional[pulumi.Input[str]] = None,
|
|
997
|
-
devices: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
998
|
-
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[bool]] = None,
|
|
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,
|
|
999
1078
|
location_privates: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorLocationPrivateArgs', 'ScriptMonitorLocationPrivateArgsDict']]]]] = None,
|
|
1000
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1001
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
1002
|
-
period: Optional[pulumi.Input[str]] = None,
|
|
1003
|
-
runtime_type: Optional[pulumi.Input[str]] = None,
|
|
1004
|
-
runtime_type_version: Optional[pulumi.Input[str]] = None,
|
|
1005
|
-
script: Optional[pulumi.Input[str]] = None,
|
|
1006
|
-
script_language: Optional[pulumi.Input[str]] = None,
|
|
1007
|
-
status: Optional[pulumi.Input[str]] = None,
|
|
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,
|
|
1008
1087
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorTagArgs', 'ScriptMonitorTagArgsDict']]]]] = None,
|
|
1009
|
-
type: Optional[pulumi.Input[str]] = None,
|
|
1010
|
-
use_unsupported_legacy_runtime: Optional[pulumi.Input[bool]] = None,
|
|
1088
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1089
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1011
1090
|
__props__=None):
|
|
1012
1091
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1013
1092
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -1042,6 +1121,7 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
1042
1121
|
__props__.__dict__["type"] = type
|
|
1043
1122
|
__props__.__dict__["use_unsupported_legacy_runtime"] = use_unsupported_legacy_runtime
|
|
1044
1123
|
__props__.__dict__["guid"] = None
|
|
1124
|
+
__props__.__dict__["monitor_id"] = None
|
|
1045
1125
|
__props__.__dict__["period_in_minutes"] = None
|
|
1046
1126
|
super(ScriptMonitor, __self__).__init__(
|
|
1047
1127
|
'newrelic:synthetics/scriptMonitor:ScriptMonitor',
|
|
@@ -1053,26 +1133,27 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
1053
1133
|
def get(resource_name: str,
|
|
1054
1134
|
id: pulumi.Input[str],
|
|
1055
1135
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1056
|
-
account_id: Optional[pulumi.Input[str]] = None,
|
|
1057
|
-
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1058
|
-
device_orientation: Optional[pulumi.Input[str]] = None,
|
|
1059
|
-
device_type: Optional[pulumi.Input[str]] = None,
|
|
1060
|
-
devices: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1061
|
-
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[bool]] = None,
|
|
1062
|
-
guid: Optional[pulumi.Input[str]] = None,
|
|
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,
|
|
1063
1143
|
location_privates: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorLocationPrivateArgs', 'ScriptMonitorLocationPrivateArgsDict']]]]] = None,
|
|
1064
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1065
|
-
|
|
1066
|
-
|
|
1067
|
-
|
|
1068
|
-
|
|
1069
|
-
|
|
1070
|
-
|
|
1071
|
-
|
|
1072
|
-
|
|
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,
|
|
1073
1154
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorTagArgs', 'ScriptMonitorTagArgsDict']]]]] = None,
|
|
1074
|
-
type: Optional[pulumi.Input[str]] = None,
|
|
1075
|
-
use_unsupported_legacy_runtime: Optional[pulumi.Input[bool]] = None) -> 'ScriptMonitor':
|
|
1155
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1156
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None) -> 'ScriptMonitor':
|
|
1076
1157
|
"""
|
|
1077
1158
|
Get an existing ScriptMonitor resource's state with the given name, id, and optional extra
|
|
1078
1159
|
properties used to qualify the lookup.
|
|
@@ -1080,27 +1161,28 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
1080
1161
|
:param str resource_name: The unique name of the resulting resource.
|
|
1081
1162
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1082
1163
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1083
|
-
:param pulumi.Input[str] account_id: The account in which the Synthetics monitor will be created.
|
|
1084
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
1085
|
-
:param pulumi.Input[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.
|
|
1086
|
-
:param pulumi.Input[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.
|
|
1087
|
-
:param pulumi.Input[Sequence[pulumi.Input[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`.
|
|
1088
|
-
:param pulumi.Input[bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
1089
|
-
:param pulumi.Input[str] guid: The unique entity identifier of the monitor in New Relic.
|
|
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.
|
|
1090
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**.
|
|
1091
|
-
:param pulumi.Input[Sequence[pulumi.Input[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**.
|
|
1092
|
-
:param pulumi.Input[str]
|
|
1093
|
-
:param pulumi.Input[str]
|
|
1094
|
-
:param pulumi.Input[
|
|
1095
|
-
:param pulumi.Input[
|
|
1096
|
-
:param pulumi.Input[str]
|
|
1097
|
-
:param pulumi.Input[str]
|
|
1098
|
-
:param pulumi.Input[str]
|
|
1099
|
-
:param pulumi.Input[str]
|
|
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`).
|
|
1100
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.
|
|
1101
1183
|
|
|
1102
1184
|
The `SCRIPTED_BROWSER` monitor type supports the following additional arguments:
|
|
1103
|
-
:param pulumi.Input[str] type: The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
1185
|
+
:param pulumi.Input[_builtins.str] type: The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
1104
1186
|
"""
|
|
1105
1187
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
1106
1188
|
|
|
@@ -1115,6 +1197,7 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
1115
1197
|
__props__.__dict__["guid"] = guid
|
|
1116
1198
|
__props__.__dict__["location_privates"] = location_privates
|
|
1117
1199
|
__props__.__dict__["locations_publics"] = locations_publics
|
|
1200
|
+
__props__.__dict__["monitor_id"] = monitor_id
|
|
1118
1201
|
__props__.__dict__["name"] = name
|
|
1119
1202
|
__props__.__dict__["period"] = period
|
|
1120
1203
|
__props__.__dict__["period_in_minutes"] = period_in_minutes
|
|
@@ -1128,63 +1211,63 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
1128
1211
|
__props__.__dict__["use_unsupported_legacy_runtime"] = use_unsupported_legacy_runtime
|
|
1129
1212
|
return ScriptMonitor(resource_name, opts=opts, __props__=__props__)
|
|
1130
1213
|
|
|
1131
|
-
@property
|
|
1214
|
+
@_builtins.property
|
|
1132
1215
|
@pulumi.getter(name="accountId")
|
|
1133
|
-
def account_id(self) -> pulumi.Output[str]:
|
|
1216
|
+
def account_id(self) -> pulumi.Output[_builtins.str]:
|
|
1134
1217
|
"""
|
|
1135
1218
|
The account in which the Synthetics monitor will be created.
|
|
1136
1219
|
"""
|
|
1137
1220
|
return pulumi.get(self, "account_id")
|
|
1138
1221
|
|
|
1139
|
-
@property
|
|
1222
|
+
@_builtins.property
|
|
1140
1223
|
@pulumi.getter
|
|
1141
|
-
def browsers(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1224
|
+
def browsers(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1142
1225
|
"""
|
|
1143
1226
|
The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
1144
1227
|
"""
|
|
1145
1228
|
return pulumi.get(self, "browsers")
|
|
1146
1229
|
|
|
1147
|
-
@property
|
|
1230
|
+
@_builtins.property
|
|
1148
1231
|
@pulumi.getter(name="deviceOrientation")
|
|
1149
|
-
def device_orientation(self) -> pulumi.Output[Optional[str]]:
|
|
1232
|
+
def device_orientation(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1150
1233
|
"""
|
|
1151
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.
|
|
1152
1235
|
"""
|
|
1153
1236
|
return pulumi.get(self, "device_orientation")
|
|
1154
1237
|
|
|
1155
|
-
@property
|
|
1238
|
+
@_builtins.property
|
|
1156
1239
|
@pulumi.getter(name="deviceType")
|
|
1157
|
-
def device_type(self) -> pulumi.Output[Optional[str]]:
|
|
1240
|
+
def device_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1158
1241
|
"""
|
|
1159
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.
|
|
1160
1243
|
"""
|
|
1161
1244
|
return pulumi.get(self, "device_type")
|
|
1162
1245
|
|
|
1163
|
-
@property
|
|
1246
|
+
@_builtins.property
|
|
1164
1247
|
@pulumi.getter
|
|
1165
|
-
def devices(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1248
|
+
def devices(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1166
1249
|
"""
|
|
1167
1250
|
The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
1168
1251
|
"""
|
|
1169
1252
|
return pulumi.get(self, "devices")
|
|
1170
1253
|
|
|
1171
|
-
@property
|
|
1254
|
+
@_builtins.property
|
|
1172
1255
|
@pulumi.getter(name="enableScreenshotOnFailureAndScript")
|
|
1173
|
-
def enable_screenshot_on_failure_and_script(self) -> pulumi.Output[Optional[bool]]:
|
|
1256
|
+
def enable_screenshot_on_failure_and_script(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1174
1257
|
"""
|
|
1175
1258
|
Capture a screenshot during job execution.
|
|
1176
1259
|
"""
|
|
1177
1260
|
return pulumi.get(self, "enable_screenshot_on_failure_and_script")
|
|
1178
1261
|
|
|
1179
|
-
@property
|
|
1262
|
+
@_builtins.property
|
|
1180
1263
|
@pulumi.getter
|
|
1181
|
-
def guid(self) -> pulumi.Output[str]:
|
|
1264
|
+
def guid(self) -> pulumi.Output[_builtins.str]:
|
|
1182
1265
|
"""
|
|
1183
1266
|
The unique entity identifier of the monitor in New Relic.
|
|
1184
1267
|
"""
|
|
1185
1268
|
return pulumi.get(self, "guid")
|
|
1186
1269
|
|
|
1187
|
-
@property
|
|
1270
|
+
@_builtins.property
|
|
1188
1271
|
@pulumi.getter(name="locationPrivates")
|
|
1189
1272
|
def location_privates(self) -> pulumi.Output[Optional[Sequence['outputs.ScriptMonitorLocationPrivate']]]:
|
|
1190
1273
|
"""
|
|
@@ -1192,79 +1275,87 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
1192
1275
|
"""
|
|
1193
1276
|
return pulumi.get(self, "location_privates")
|
|
1194
1277
|
|
|
1195
|
-
@property
|
|
1278
|
+
@_builtins.property
|
|
1196
1279
|
@pulumi.getter(name="locationsPublics")
|
|
1197
|
-
def locations_publics(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1280
|
+
def locations_publics(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1198
1281
|
"""
|
|
1199
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**.
|
|
1200
1283
|
"""
|
|
1201
1284
|
return pulumi.get(self, "locations_publics")
|
|
1202
1285
|
|
|
1203
|
-
@property
|
|
1286
|
+
@_builtins.property
|
|
1287
|
+
@pulumi.getter(name="monitorId")
|
|
1288
|
+
def monitor_id(self) -> pulumi.Output[_builtins.str]:
|
|
1289
|
+
"""
|
|
1290
|
+
The monitor id of the Synthetics script monitor (not to be confused with the GUID of the monitor).
|
|
1291
|
+
"""
|
|
1292
|
+
return pulumi.get(self, "monitor_id")
|
|
1293
|
+
|
|
1294
|
+
@_builtins.property
|
|
1204
1295
|
@pulumi.getter
|
|
1205
|
-
def name(self) -> pulumi.Output[str]:
|
|
1296
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
1206
1297
|
"""
|
|
1207
1298
|
The name for the monitor.
|
|
1208
1299
|
"""
|
|
1209
1300
|
return pulumi.get(self, "name")
|
|
1210
1301
|
|
|
1211
|
-
@property
|
|
1302
|
+
@_builtins.property
|
|
1212
1303
|
@pulumi.getter
|
|
1213
|
-
def period(self) -> pulumi.Output[str]:
|
|
1304
|
+
def period(self) -> pulumi.Output[_builtins.str]:
|
|
1214
1305
|
"""
|
|
1215
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`.
|
|
1216
1307
|
"""
|
|
1217
1308
|
return pulumi.get(self, "period")
|
|
1218
1309
|
|
|
1219
|
-
@property
|
|
1310
|
+
@_builtins.property
|
|
1220
1311
|
@pulumi.getter(name="periodInMinutes")
|
|
1221
|
-
def period_in_minutes(self) -> pulumi.Output[int]:
|
|
1312
|
+
def period_in_minutes(self) -> pulumi.Output[_builtins.int]:
|
|
1222
1313
|
"""
|
|
1223
1314
|
The interval in minutes at which Synthetic monitor should run.
|
|
1224
1315
|
"""
|
|
1225
1316
|
return pulumi.get(self, "period_in_minutes")
|
|
1226
1317
|
|
|
1227
|
-
@property
|
|
1318
|
+
@_builtins.property
|
|
1228
1319
|
@pulumi.getter(name="runtimeType")
|
|
1229
|
-
def runtime_type(self) -> pulumi.Output[Optional[str]]:
|
|
1320
|
+
def runtime_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1230
1321
|
"""
|
|
1231
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`.
|
|
1232
1323
|
"""
|
|
1233
1324
|
return pulumi.get(self, "runtime_type")
|
|
1234
1325
|
|
|
1235
|
-
@property
|
|
1326
|
+
@_builtins.property
|
|
1236
1327
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
1237
|
-
def runtime_type_version(self) -> pulumi.Output[Optional[str]]:
|
|
1328
|
+
def runtime_type_version(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1238
1329
|
"""
|
|
1239
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.
|
|
1240
1331
|
"""
|
|
1241
1332
|
return pulumi.get(self, "runtime_type_version")
|
|
1242
1333
|
|
|
1243
|
-
@property
|
|
1334
|
+
@_builtins.property
|
|
1244
1335
|
@pulumi.getter
|
|
1245
|
-
def script(self) -> pulumi.Output[Optional[str]]:
|
|
1336
|
+
def script(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1246
1337
|
"""
|
|
1247
1338
|
The script that the monitor runs.
|
|
1248
1339
|
"""
|
|
1249
1340
|
return pulumi.get(self, "script")
|
|
1250
1341
|
|
|
1251
|
-
@property
|
|
1342
|
+
@_builtins.property
|
|
1252
1343
|
@pulumi.getter(name="scriptLanguage")
|
|
1253
|
-
def script_language(self) -> pulumi.Output[Optional[str]]:
|
|
1344
|
+
def script_language(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1254
1345
|
"""
|
|
1255
1346
|
The programing language that should execute the script.
|
|
1256
1347
|
"""
|
|
1257
1348
|
return pulumi.get(self, "script_language")
|
|
1258
1349
|
|
|
1259
|
-
@property
|
|
1350
|
+
@_builtins.property
|
|
1260
1351
|
@pulumi.getter
|
|
1261
|
-
def status(self) -> pulumi.Output[str]:
|
|
1352
|
+
def status(self) -> pulumi.Output[_builtins.str]:
|
|
1262
1353
|
"""
|
|
1263
1354
|
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
1264
1355
|
"""
|
|
1265
1356
|
return pulumi.get(self, "status")
|
|
1266
1357
|
|
|
1267
|
-
@property
|
|
1358
|
+
@_builtins.property
|
|
1268
1359
|
@pulumi.getter
|
|
1269
1360
|
def tags(self) -> pulumi.Output[Optional[Sequence['outputs.ScriptMonitorTag']]]:
|
|
1270
1361
|
"""
|
|
@@ -1274,16 +1365,16 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
1274
1365
|
"""
|
|
1275
1366
|
return pulumi.get(self, "tags")
|
|
1276
1367
|
|
|
1277
|
-
@property
|
|
1368
|
+
@_builtins.property
|
|
1278
1369
|
@pulumi.getter
|
|
1279
|
-
def type(self) -> pulumi.Output[str]:
|
|
1370
|
+
def type(self) -> pulumi.Output[_builtins.str]:
|
|
1280
1371
|
"""
|
|
1281
1372
|
The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
1282
1373
|
"""
|
|
1283
1374
|
return pulumi.get(self, "type")
|
|
1284
1375
|
|
|
1285
|
-
@property
|
|
1376
|
+
@_builtins.property
|
|
1286
1377
|
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
1287
|
-
def use_unsupported_legacy_runtime(self) -> pulumi.Output[Optional[bool]]:
|
|
1378
|
+
def use_unsupported_legacy_runtime(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1288
1379
|
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
1289
1380
|
|