pulumi-newrelic 5.22.0__py3-none-any.whl → 5.58.0a1763707205__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 +28 -1
- pulumi_newrelic/_inputs.py +10385 -2976
- pulumi_newrelic/_utilities.py +50 -10
- pulumi_newrelic/account_management.py +48 -42
- pulumi_newrelic/alert_channel.py +165 -175
- pulumi_newrelic/alert_condition.py +307 -319
- pulumi_newrelic/alert_muting_rule.py +193 -140
- pulumi_newrelic/alert_policy.py +121 -117
- pulumi_newrelic/alert_policy_channel.py +89 -79
- pulumi_newrelic/api_access_key.py +195 -193
- pulumi_newrelic/browser_application.py +120 -114
- pulumi_newrelic/cloud/__init__.py +3 -1
- pulumi_newrelic/cloud/_inputs.py +4267 -2714
- pulumi_newrelic/cloud/aws_govcloud_integrations.py +206 -196
- pulumi_newrelic/cloud/aws_govcloud_link_account.py +143 -228
- pulumi_newrelic/cloud/aws_integrations.py +510 -1490
- pulumi_newrelic/cloud/aws_link_account.py +80 -76
- pulumi_newrelic/cloud/azure_integrations.py +673 -587
- pulumi_newrelic/cloud/azure_link_account.py +121 -117
- pulumi_newrelic/cloud/gcp_integrations.py +428 -408
- pulumi_newrelic/cloud/gcp_link_account.py +65 -61
- pulumi_newrelic/cloud/oci_link_account.py +926 -0
- pulumi_newrelic/cloud/outputs.py +1678 -2321
- pulumi_newrelic/config/__init__.py +2 -1
- pulumi_newrelic/config/__init__.pyi +8 -3
- pulumi_newrelic/config/vars.py +22 -17
- pulumi_newrelic/data_partition_rule.py +119 -117
- pulumi_newrelic/entity_tags.py +111 -53
- pulumi_newrelic/events_to_metrics_rule.py +106 -102
- pulumi_newrelic/get_account.py +41 -33
- pulumi_newrelic/get_alert_channel.py +73 -28
- pulumi_newrelic/get_alert_policy.py +82 -33
- pulumi_newrelic/get_application.py +51 -43
- pulumi_newrelic/get_authentication_domain.py +27 -23
- pulumi_newrelic/get_cloud_account.py +43 -35
- pulumi_newrelic/get_entity.py +126 -183
- pulumi_newrelic/get_group.py +76 -31
- pulumi_newrelic/get_key_transaction.py +117 -42
- pulumi_newrelic/get_notification_destination.py +75 -38
- pulumi_newrelic/get_obfuscation_expression.py +47 -39
- pulumi_newrelic/get_service_level_alert_helper.py +189 -171
- pulumi_newrelic/get_test_grok_pattern.py +47 -36
- pulumi_newrelic/get_user.py +39 -31
- pulumi_newrelic/group.py +59 -199
- pulumi_newrelic/infra_alert_condition.py +399 -405
- pulumi_newrelic/insights/__init__.py +2 -1
- pulumi_newrelic/insights/_inputs.py +71 -28
- pulumi_newrelic/insights/event.py +54 -52
- pulumi_newrelic/insights/outputs.py +28 -23
- pulumi_newrelic/key_transaction.py +465 -0
- pulumi_newrelic/log_parsing_rule.py +159 -157
- pulumi_newrelic/monitor_downtime.py +311 -331
- pulumi_newrelic/notification_channel.py +534 -464
- pulumi_newrelic/notification_destination.py +238 -141
- pulumi_newrelic/nrql_alert_condition.py +820 -614
- pulumi_newrelic/nrql_drop_rule.py +113 -151
- pulumi_newrelic/obfuscation_expression.py +80 -76
- pulumi_newrelic/obfuscation_rule.py +115 -109
- pulumi_newrelic/one_dashboard.py +110 -104
- pulumi_newrelic/one_dashboard_json.py +69 -63
- pulumi_newrelic/one_dashboard_raw.py +212 -206
- pulumi_newrelic/outputs.py +4936 -2234
- pulumi_newrelic/pipeline_cloud_rule.py +335 -0
- pulumi_newrelic/plugins/__init__.py +2 -1
- pulumi_newrelic/plugins/_inputs.py +519 -89
- pulumi_newrelic/plugins/application_settings.py +463 -187
- pulumi_newrelic/plugins/outputs.py +336 -74
- pulumi_newrelic/plugins/workload.py +313 -189
- pulumi_newrelic/provider.py +156 -142
- pulumi_newrelic/pulumi-plugin.json +2 -1
- pulumi_newrelic/service_level.py +263 -263
- pulumi_newrelic/synthetics/__init__.py +2 -1
- pulumi_newrelic/synthetics/_inputs.py +265 -108
- pulumi_newrelic/synthetics/alert_condition.py +170 -180
- pulumi_newrelic/synthetics/broken_links_monitor.py +297 -249
- pulumi_newrelic/synthetics/cert_check_monitor.py +306 -258
- pulumi_newrelic/synthetics/get_private_location.py +51 -47
- pulumi_newrelic/synthetics/get_secure_credential.py +39 -31
- pulumi_newrelic/synthetics/monitor.py +658 -460
- pulumi_newrelic/synthetics/multi_location_alert_condition.py +211 -205
- pulumi_newrelic/synthetics/outputs.py +92 -87
- pulumi_newrelic/synthetics/private_location.py +118 -112
- pulumi_newrelic/synthetics/script_monitor.py +613 -373
- pulumi_newrelic/synthetics/secure_credential.py +97 -95
- pulumi_newrelic/synthetics/step_monitor.py +445 -275
- pulumi_newrelic/user.py +84 -80
- pulumi_newrelic/workflow.py +336 -322
- {pulumi_newrelic-5.22.0.dist-info → pulumi_newrelic-5.58.0a1763707205.dist-info}/METADATA +7 -6
- pulumi_newrelic-5.58.0a1763707205.dist-info/RECORD +92 -0
- {pulumi_newrelic-5.22.0.dist-info → pulumi_newrelic-5.58.0a1763707205.dist-info}/WHEEL +1 -1
- pulumi_newrelic-5.22.0.dist-info/RECORD +0 -89
- {pulumi_newrelic-5.22.0.dist-info → pulumi_newrelic-5.58.0a1763707205.dist-info}/top_level.txt +0 -0
|
@@ -1,12 +1,17 @@
|
|
|
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
|
+
import sys
|
|
7
8
|
import pulumi
|
|
8
9
|
import pulumi.runtime
|
|
9
10
|
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
10
15
|
from .. import _utilities
|
|
11
16
|
from . import outputs
|
|
12
17
|
from ._inputs import *
|
|
@@ -16,50 +21,59 @@ __all__ = ['ScriptMonitorArgs', 'ScriptMonitor']
|
|
|
16
21
|
@pulumi.input_type
|
|
17
22
|
class ScriptMonitorArgs:
|
|
18
23
|
def __init__(__self__, *,
|
|
19
|
-
period: pulumi.Input[str],
|
|
20
|
-
status: pulumi.Input[str],
|
|
21
|
-
type: pulumi.Input[str],
|
|
22
|
-
account_id: Optional[pulumi.Input[
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
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,
|
|
26
33
|
location_privates: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorLocationPrivateArgs']]]] = None,
|
|
27
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
28
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
29
|
-
runtime_type: Optional[pulumi.Input[str]] = None,
|
|
30
|
-
runtime_type_version: Optional[pulumi.Input[str]] = None,
|
|
31
|
-
script: Optional[pulumi.Input[str]] = None,
|
|
32
|
-
script_language: Optional[pulumi.Input[str]] = None,
|
|
33
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorTagArgs']]]] = 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
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorTagArgs']]]] = None,
|
|
41
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
34
42
|
"""
|
|
35
43
|
The set of arguments for constructing a ScriptMonitor resource.
|
|
36
|
-
:param pulumi.Input[str] period: The interval at which this monitor should run. Valid values are EVERY_MINUTE
|
|
37
|
-
:param pulumi.Input[str] status: The monitor
|
|
38
|
-
:param pulumi.Input[str] type: The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
39
|
-
:param pulumi.Input[
|
|
40
|
-
:param pulumi.Input[str]
|
|
41
|
-
:param pulumi.Input[str]
|
|
42
|
-
: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.
|
|
43
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**.
|
|
44
|
-
: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**.
|
|
45
|
-
:param pulumi.Input[str] name: The name for the monitor.
|
|
46
|
-
:param pulumi.Input[str] runtime_type: The runtime that the monitor will use to run jobs.
|
|
47
|
-
:param pulumi.Input[str] runtime_type_version: The specific version of the runtime type selected.
|
|
48
|
-
:param pulumi.Input[str] script: The script that the monitor runs.
|
|
49
|
-
: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.
|
|
50
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.
|
|
51
61
|
|
|
52
|
-
The `SCRIPTED_BROWSER` monitor type supports the following additional
|
|
62
|
+
The `SCRIPTED_BROWSER` monitor type supports the following additional arguments:
|
|
53
63
|
"""
|
|
54
64
|
pulumi.set(__self__, "period", period)
|
|
55
65
|
pulumi.set(__self__, "status", status)
|
|
56
66
|
pulumi.set(__self__, "type", type)
|
|
57
67
|
if account_id is not None:
|
|
58
68
|
pulumi.set(__self__, "account_id", account_id)
|
|
69
|
+
if browsers is not None:
|
|
70
|
+
pulumi.set(__self__, "browsers", browsers)
|
|
59
71
|
if device_orientation is not None:
|
|
60
72
|
pulumi.set(__self__, "device_orientation", device_orientation)
|
|
61
73
|
if device_type is not None:
|
|
62
74
|
pulumi.set(__self__, "device_type", device_type)
|
|
75
|
+
if devices is not None:
|
|
76
|
+
pulumi.set(__self__, "devices", devices)
|
|
63
77
|
if enable_screenshot_on_failure_and_script is not None:
|
|
64
78
|
pulumi.set(__self__, "enable_screenshot_on_failure_and_script", enable_screenshot_on_failure_and_script)
|
|
65
79
|
if location_privates is not None:
|
|
@@ -78,92 +92,118 @@ class ScriptMonitorArgs:
|
|
|
78
92
|
pulumi.set(__self__, "script_language", script_language)
|
|
79
93
|
if tags is not None:
|
|
80
94
|
pulumi.set(__self__, "tags", tags)
|
|
95
|
+
if use_unsupported_legacy_runtime is not None:
|
|
96
|
+
pulumi.set(__self__, "use_unsupported_legacy_runtime", use_unsupported_legacy_runtime)
|
|
81
97
|
|
|
82
|
-
@property
|
|
98
|
+
@_builtins.property
|
|
83
99
|
@pulumi.getter
|
|
84
|
-
def period(self) -> pulumi.Input[str]:
|
|
100
|
+
def period(self) -> pulumi.Input[_builtins.str]:
|
|
85
101
|
"""
|
|
86
|
-
The interval at which this monitor should run. Valid values are EVERY_MINUTE
|
|
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`.
|
|
87
103
|
"""
|
|
88
104
|
return pulumi.get(self, "period")
|
|
89
105
|
|
|
90
106
|
@period.setter
|
|
91
|
-
def period(self, value: pulumi.Input[str]):
|
|
107
|
+
def period(self, value: pulumi.Input[_builtins.str]):
|
|
92
108
|
pulumi.set(self, "period", value)
|
|
93
109
|
|
|
94
|
-
@property
|
|
110
|
+
@_builtins.property
|
|
95
111
|
@pulumi.getter
|
|
96
|
-
def status(self) -> pulumi.Input[str]:
|
|
112
|
+
def status(self) -> pulumi.Input[_builtins.str]:
|
|
97
113
|
"""
|
|
98
|
-
The monitor
|
|
114
|
+
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
99
115
|
"""
|
|
100
116
|
return pulumi.get(self, "status")
|
|
101
117
|
|
|
102
118
|
@status.setter
|
|
103
|
-
def status(self, value: pulumi.Input[str]):
|
|
119
|
+
def status(self, value: pulumi.Input[_builtins.str]):
|
|
104
120
|
pulumi.set(self, "status", value)
|
|
105
121
|
|
|
106
|
-
@property
|
|
122
|
+
@_builtins.property
|
|
107
123
|
@pulumi.getter
|
|
108
|
-
def type(self) -> pulumi.Input[str]:
|
|
124
|
+
def type(self) -> pulumi.Input[_builtins.str]:
|
|
109
125
|
"""
|
|
110
126
|
The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
111
127
|
"""
|
|
112
128
|
return pulumi.get(self, "type")
|
|
113
129
|
|
|
114
130
|
@type.setter
|
|
115
|
-
def type(self, value: pulumi.Input[str]):
|
|
131
|
+
def type(self, value: pulumi.Input[_builtins.str]):
|
|
116
132
|
pulumi.set(self, "type", value)
|
|
117
133
|
|
|
118
|
-
@property
|
|
134
|
+
@_builtins.property
|
|
119
135
|
@pulumi.getter(name="accountId")
|
|
120
|
-
def account_id(self) -> Optional[pulumi.Input[
|
|
136
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
121
137
|
"""
|
|
122
138
|
The account in which the Synthetics monitor will be created.
|
|
123
139
|
"""
|
|
124
140
|
return pulumi.get(self, "account_id")
|
|
125
141
|
|
|
126
142
|
@account_id.setter
|
|
127
|
-
def account_id(self, value: Optional[pulumi.Input[
|
|
143
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
128
144
|
pulumi.set(self, "account_id", value)
|
|
129
145
|
|
|
130
|
-
@property
|
|
146
|
+
@_builtins.property
|
|
147
|
+
@pulumi.getter
|
|
148
|
+
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
149
|
+
"""
|
|
150
|
+
The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
151
|
+
"""
|
|
152
|
+
return pulumi.get(self, "browsers")
|
|
153
|
+
|
|
154
|
+
@browsers.setter
|
|
155
|
+
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
156
|
+
pulumi.set(self, "browsers", value)
|
|
157
|
+
|
|
158
|
+
@_builtins.property
|
|
131
159
|
@pulumi.getter(name="deviceOrientation")
|
|
132
|
-
def device_orientation(self) -> Optional[pulumi.Input[str]]:
|
|
160
|
+
def device_orientation(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
133
161
|
"""
|
|
134
|
-
Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
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.
|
|
135
163
|
"""
|
|
136
164
|
return pulumi.get(self, "device_orientation")
|
|
137
165
|
|
|
138
166
|
@device_orientation.setter
|
|
139
|
-
def device_orientation(self, value: Optional[pulumi.Input[str]]):
|
|
167
|
+
def device_orientation(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
140
168
|
pulumi.set(self, "device_orientation", value)
|
|
141
169
|
|
|
142
|
-
@property
|
|
170
|
+
@_builtins.property
|
|
143
171
|
@pulumi.getter(name="deviceType")
|
|
144
|
-
def device_type(self) -> Optional[pulumi.Input[str]]:
|
|
172
|
+
def device_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
145
173
|
"""
|
|
146
|
-
Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
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.
|
|
147
175
|
"""
|
|
148
176
|
return pulumi.get(self, "device_type")
|
|
149
177
|
|
|
150
178
|
@device_type.setter
|
|
151
|
-
def device_type(self, value: Optional[pulumi.Input[str]]):
|
|
179
|
+
def device_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
152
180
|
pulumi.set(self, "device_type", value)
|
|
153
181
|
|
|
154
|
-
@property
|
|
182
|
+
@_builtins.property
|
|
183
|
+
@pulumi.getter
|
|
184
|
+
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
185
|
+
"""
|
|
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
|
+
"""
|
|
188
|
+
return pulumi.get(self, "devices")
|
|
189
|
+
|
|
190
|
+
@devices.setter
|
|
191
|
+
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
192
|
+
pulumi.set(self, "devices", value)
|
|
193
|
+
|
|
194
|
+
@_builtins.property
|
|
155
195
|
@pulumi.getter(name="enableScreenshotOnFailureAndScript")
|
|
156
|
-
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]]:
|
|
157
197
|
"""
|
|
158
198
|
Capture a screenshot during job execution.
|
|
159
199
|
"""
|
|
160
200
|
return pulumi.get(self, "enable_screenshot_on_failure_and_script")
|
|
161
201
|
|
|
162
202
|
@enable_screenshot_on_failure_and_script.setter
|
|
163
|
-
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]]):
|
|
164
204
|
pulumi.set(self, "enable_screenshot_on_failure_and_script", value)
|
|
165
205
|
|
|
166
|
-
@property
|
|
206
|
+
@_builtins.property
|
|
167
207
|
@pulumi.getter(name="locationPrivates")
|
|
168
208
|
def location_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorLocationPrivateArgs']]]]:
|
|
169
209
|
"""
|
|
@@ -175,85 +215,85 @@ class ScriptMonitorArgs:
|
|
|
175
215
|
def location_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorLocationPrivateArgs']]]]):
|
|
176
216
|
pulumi.set(self, "location_privates", value)
|
|
177
217
|
|
|
178
|
-
@property
|
|
218
|
+
@_builtins.property
|
|
179
219
|
@pulumi.getter(name="locationsPublics")
|
|
180
|
-
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
220
|
+
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
181
221
|
"""
|
|
182
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**.
|
|
183
223
|
"""
|
|
184
224
|
return pulumi.get(self, "locations_publics")
|
|
185
225
|
|
|
186
226
|
@locations_publics.setter
|
|
187
|
-
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]]]]):
|
|
188
228
|
pulumi.set(self, "locations_publics", value)
|
|
189
229
|
|
|
190
|
-
@property
|
|
230
|
+
@_builtins.property
|
|
191
231
|
@pulumi.getter
|
|
192
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
232
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
193
233
|
"""
|
|
194
234
|
The name for the monitor.
|
|
195
235
|
"""
|
|
196
236
|
return pulumi.get(self, "name")
|
|
197
237
|
|
|
198
238
|
@name.setter
|
|
199
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
239
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
200
240
|
pulumi.set(self, "name", value)
|
|
201
241
|
|
|
202
|
-
@property
|
|
242
|
+
@_builtins.property
|
|
203
243
|
@pulumi.getter(name="runtimeType")
|
|
204
|
-
def runtime_type(self) -> Optional[pulumi.Input[str]]:
|
|
244
|
+
def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
205
245
|
"""
|
|
206
|
-
The runtime that the monitor will use to run jobs.
|
|
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`.
|
|
207
247
|
"""
|
|
208
248
|
return pulumi.get(self, "runtime_type")
|
|
209
249
|
|
|
210
250
|
@runtime_type.setter
|
|
211
|
-
def runtime_type(self, value: Optional[pulumi.Input[str]]):
|
|
251
|
+
def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
212
252
|
pulumi.set(self, "runtime_type", value)
|
|
213
253
|
|
|
214
|
-
@property
|
|
254
|
+
@_builtins.property
|
|
215
255
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
216
|
-
def runtime_type_version(self) -> Optional[pulumi.Input[str]]:
|
|
256
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
217
257
|
"""
|
|
218
|
-
The specific version of the runtime type selected.
|
|
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.
|
|
219
259
|
"""
|
|
220
260
|
return pulumi.get(self, "runtime_type_version")
|
|
221
261
|
|
|
222
262
|
@runtime_type_version.setter
|
|
223
|
-
def runtime_type_version(self, value: Optional[pulumi.Input[str]]):
|
|
263
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
224
264
|
pulumi.set(self, "runtime_type_version", value)
|
|
225
265
|
|
|
226
|
-
@property
|
|
266
|
+
@_builtins.property
|
|
227
267
|
@pulumi.getter
|
|
228
|
-
def script(self) -> Optional[pulumi.Input[str]]:
|
|
268
|
+
def script(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
229
269
|
"""
|
|
230
270
|
The script that the monitor runs.
|
|
231
271
|
"""
|
|
232
272
|
return pulumi.get(self, "script")
|
|
233
273
|
|
|
234
274
|
@script.setter
|
|
235
|
-
def script(self, value: Optional[pulumi.Input[str]]):
|
|
275
|
+
def script(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
236
276
|
pulumi.set(self, "script", value)
|
|
237
277
|
|
|
238
|
-
@property
|
|
278
|
+
@_builtins.property
|
|
239
279
|
@pulumi.getter(name="scriptLanguage")
|
|
240
|
-
def script_language(self) -> Optional[pulumi.Input[str]]:
|
|
280
|
+
def script_language(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
241
281
|
"""
|
|
242
282
|
The programing language that should execute the script.
|
|
243
283
|
"""
|
|
244
284
|
return pulumi.get(self, "script_language")
|
|
245
285
|
|
|
246
286
|
@script_language.setter
|
|
247
|
-
def script_language(self, value: Optional[pulumi.Input[str]]):
|
|
287
|
+
def script_language(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
248
288
|
pulumi.set(self, "script_language", value)
|
|
249
289
|
|
|
250
|
-
@property
|
|
290
|
+
@_builtins.property
|
|
251
291
|
@pulumi.getter
|
|
252
292
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorTagArgs']]]]:
|
|
253
293
|
"""
|
|
254
294
|
The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
255
295
|
|
|
256
|
-
The `SCRIPTED_BROWSER` monitor type supports the following additional
|
|
296
|
+
The `SCRIPTED_BROWSER` monitor type supports the following additional arguments:
|
|
257
297
|
"""
|
|
258
298
|
return pulumi.get(self, "tags")
|
|
259
299
|
|
|
@@ -261,55 +301,75 @@ class ScriptMonitorArgs:
|
|
|
261
301
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorTagArgs']]]]):
|
|
262
302
|
pulumi.set(self, "tags", value)
|
|
263
303
|
|
|
304
|
+
@_builtins.property
|
|
305
|
+
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
306
|
+
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
307
|
+
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
308
|
+
|
|
309
|
+
@use_unsupported_legacy_runtime.setter
|
|
310
|
+
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
311
|
+
pulumi.set(self, "use_unsupported_legacy_runtime", value)
|
|
312
|
+
|
|
264
313
|
|
|
265
314
|
@pulumi.input_type
|
|
266
315
|
class _ScriptMonitorState:
|
|
267
316
|
def __init__(__self__, *,
|
|
268
|
-
account_id: Optional[pulumi.Input[
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
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,
|
|
273
324
|
location_privates: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorLocationPrivateArgs']]]] = None,
|
|
274
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
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,
|
|
283
335
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorTagArgs']]]] = None,
|
|
284
|
-
type: Optional[pulumi.Input[str]] = None
|
|
336
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
337
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
285
338
|
"""
|
|
286
339
|
Input properties used for looking up and filtering ScriptMonitor resources.
|
|
287
|
-
:param pulumi.Input[
|
|
288
|
-
:param pulumi.Input[str]
|
|
289
|
-
:param pulumi.Input[str]
|
|
290
|
-
:param pulumi.Input[
|
|
291
|
-
:param pulumi.Input[str]
|
|
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.
|
|
292
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**.
|
|
293
|
-
: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**.
|
|
294
|
-
:param pulumi.Input[str]
|
|
295
|
-
:param pulumi.Input[str]
|
|
296
|
-
:param pulumi.Input[
|
|
297
|
-
:param pulumi.Input[
|
|
298
|
-
:param pulumi.Input[str]
|
|
299
|
-
:param pulumi.Input[str]
|
|
300
|
-
:param pulumi.Input[str]
|
|
301
|
-
: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`).
|
|
302
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.
|
|
303
359
|
|
|
304
|
-
The `SCRIPTED_BROWSER` monitor type supports the following additional
|
|
305
|
-
:param pulumi.Input[str] type: The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
360
|
+
The `SCRIPTED_BROWSER` monitor type supports the following additional arguments:
|
|
361
|
+
:param pulumi.Input[_builtins.str] type: The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
306
362
|
"""
|
|
307
363
|
if account_id is not None:
|
|
308
364
|
pulumi.set(__self__, "account_id", account_id)
|
|
365
|
+
if browsers is not None:
|
|
366
|
+
pulumi.set(__self__, "browsers", browsers)
|
|
309
367
|
if device_orientation is not None:
|
|
310
368
|
pulumi.set(__self__, "device_orientation", device_orientation)
|
|
311
369
|
if device_type is not None:
|
|
312
370
|
pulumi.set(__self__, "device_type", device_type)
|
|
371
|
+
if devices is not None:
|
|
372
|
+
pulumi.set(__self__, "devices", devices)
|
|
313
373
|
if enable_screenshot_on_failure_and_script is not None:
|
|
314
374
|
pulumi.set(__self__, "enable_screenshot_on_failure_and_script", enable_screenshot_on_failure_and_script)
|
|
315
375
|
if guid is not None:
|
|
@@ -318,6 +378,8 @@ class _ScriptMonitorState:
|
|
|
318
378
|
pulumi.set(__self__, "location_privates", location_privates)
|
|
319
379
|
if locations_publics is not None:
|
|
320
380
|
pulumi.set(__self__, "locations_publics", locations_publics)
|
|
381
|
+
if monitor_id is not None:
|
|
382
|
+
pulumi.set(__self__, "monitor_id", monitor_id)
|
|
321
383
|
if name is not None:
|
|
322
384
|
pulumi.set(__self__, "name", name)
|
|
323
385
|
if period is not None:
|
|
@@ -338,68 +400,94 @@ class _ScriptMonitorState:
|
|
|
338
400
|
pulumi.set(__self__, "tags", tags)
|
|
339
401
|
if type is not None:
|
|
340
402
|
pulumi.set(__self__, "type", type)
|
|
403
|
+
if use_unsupported_legacy_runtime is not None:
|
|
404
|
+
pulumi.set(__self__, "use_unsupported_legacy_runtime", use_unsupported_legacy_runtime)
|
|
341
405
|
|
|
342
|
-
@property
|
|
406
|
+
@_builtins.property
|
|
343
407
|
@pulumi.getter(name="accountId")
|
|
344
|
-
def account_id(self) -> Optional[pulumi.Input[
|
|
408
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
345
409
|
"""
|
|
346
410
|
The account in which the Synthetics monitor will be created.
|
|
347
411
|
"""
|
|
348
412
|
return pulumi.get(self, "account_id")
|
|
349
413
|
|
|
350
414
|
@account_id.setter
|
|
351
|
-
def account_id(self, value: Optional[pulumi.Input[
|
|
415
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
352
416
|
pulumi.set(self, "account_id", value)
|
|
353
417
|
|
|
354
|
-
@property
|
|
418
|
+
@_builtins.property
|
|
419
|
+
@pulumi.getter
|
|
420
|
+
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
421
|
+
"""
|
|
422
|
+
The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
423
|
+
"""
|
|
424
|
+
return pulumi.get(self, "browsers")
|
|
425
|
+
|
|
426
|
+
@browsers.setter
|
|
427
|
+
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
428
|
+
pulumi.set(self, "browsers", value)
|
|
429
|
+
|
|
430
|
+
@_builtins.property
|
|
355
431
|
@pulumi.getter(name="deviceOrientation")
|
|
356
|
-
def device_orientation(self) -> Optional[pulumi.Input[str]]:
|
|
432
|
+
def device_orientation(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
357
433
|
"""
|
|
358
|
-
Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
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.
|
|
359
435
|
"""
|
|
360
436
|
return pulumi.get(self, "device_orientation")
|
|
361
437
|
|
|
362
438
|
@device_orientation.setter
|
|
363
|
-
def device_orientation(self, value: Optional[pulumi.Input[str]]):
|
|
439
|
+
def device_orientation(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
364
440
|
pulumi.set(self, "device_orientation", value)
|
|
365
441
|
|
|
366
|
-
@property
|
|
442
|
+
@_builtins.property
|
|
367
443
|
@pulumi.getter(name="deviceType")
|
|
368
|
-
def device_type(self) -> Optional[pulumi.Input[str]]:
|
|
444
|
+
def device_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
369
445
|
"""
|
|
370
|
-
Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
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.
|
|
371
447
|
"""
|
|
372
448
|
return pulumi.get(self, "device_type")
|
|
373
449
|
|
|
374
450
|
@device_type.setter
|
|
375
|
-
def device_type(self, value: Optional[pulumi.Input[str]]):
|
|
451
|
+
def device_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
376
452
|
pulumi.set(self, "device_type", value)
|
|
377
453
|
|
|
378
|
-
@property
|
|
454
|
+
@_builtins.property
|
|
455
|
+
@pulumi.getter
|
|
456
|
+
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
457
|
+
"""
|
|
458
|
+
The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
459
|
+
"""
|
|
460
|
+
return pulumi.get(self, "devices")
|
|
461
|
+
|
|
462
|
+
@devices.setter
|
|
463
|
+
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
464
|
+
pulumi.set(self, "devices", value)
|
|
465
|
+
|
|
466
|
+
@_builtins.property
|
|
379
467
|
@pulumi.getter(name="enableScreenshotOnFailureAndScript")
|
|
380
|
-
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]]:
|
|
381
469
|
"""
|
|
382
470
|
Capture a screenshot during job execution.
|
|
383
471
|
"""
|
|
384
472
|
return pulumi.get(self, "enable_screenshot_on_failure_and_script")
|
|
385
473
|
|
|
386
474
|
@enable_screenshot_on_failure_and_script.setter
|
|
387
|
-
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]]):
|
|
388
476
|
pulumi.set(self, "enable_screenshot_on_failure_and_script", value)
|
|
389
477
|
|
|
390
|
-
@property
|
|
478
|
+
@_builtins.property
|
|
391
479
|
@pulumi.getter
|
|
392
|
-
def guid(self) -> Optional[pulumi.Input[str]]:
|
|
480
|
+
def guid(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
393
481
|
"""
|
|
394
|
-
The unique identifier
|
|
482
|
+
The unique entity identifier of the monitor in New Relic.
|
|
395
483
|
"""
|
|
396
484
|
return pulumi.get(self, "guid")
|
|
397
485
|
|
|
398
486
|
@guid.setter
|
|
399
|
-
def guid(self, value: Optional[pulumi.Input[str]]):
|
|
487
|
+
def guid(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
400
488
|
pulumi.set(self, "guid", value)
|
|
401
489
|
|
|
402
|
-
@property
|
|
490
|
+
@_builtins.property
|
|
403
491
|
@pulumi.getter(name="locationPrivates")
|
|
404
492
|
def location_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorLocationPrivateArgs']]]]:
|
|
405
493
|
"""
|
|
@@ -411,121 +499,133 @@ class _ScriptMonitorState:
|
|
|
411
499
|
def location_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorLocationPrivateArgs']]]]):
|
|
412
500
|
pulumi.set(self, "location_privates", value)
|
|
413
501
|
|
|
414
|
-
@property
|
|
502
|
+
@_builtins.property
|
|
415
503
|
@pulumi.getter(name="locationsPublics")
|
|
416
|
-
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
504
|
+
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
417
505
|
"""
|
|
418
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**.
|
|
419
507
|
"""
|
|
420
508
|
return pulumi.get(self, "locations_publics")
|
|
421
509
|
|
|
422
510
|
@locations_publics.setter
|
|
423
|
-
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]]]]):
|
|
424
512
|
pulumi.set(self, "locations_publics", value)
|
|
425
513
|
|
|
426
|
-
@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
|
|
427
527
|
@pulumi.getter
|
|
428
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
528
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
429
529
|
"""
|
|
430
530
|
The name for the monitor.
|
|
431
531
|
"""
|
|
432
532
|
return pulumi.get(self, "name")
|
|
433
533
|
|
|
434
534
|
@name.setter
|
|
435
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
535
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
436
536
|
pulumi.set(self, "name", value)
|
|
437
537
|
|
|
438
|
-
@property
|
|
538
|
+
@_builtins.property
|
|
439
539
|
@pulumi.getter
|
|
440
|
-
def period(self) -> Optional[pulumi.Input[str]]:
|
|
540
|
+
def period(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
441
541
|
"""
|
|
442
|
-
The interval at which this monitor should run. Valid values are EVERY_MINUTE
|
|
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`.
|
|
443
543
|
"""
|
|
444
544
|
return pulumi.get(self, "period")
|
|
445
545
|
|
|
446
546
|
@period.setter
|
|
447
|
-
def period(self, value: Optional[pulumi.Input[str]]):
|
|
547
|
+
def period(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
448
548
|
pulumi.set(self, "period", value)
|
|
449
549
|
|
|
450
|
-
@property
|
|
550
|
+
@_builtins.property
|
|
451
551
|
@pulumi.getter(name="periodInMinutes")
|
|
452
|
-
def period_in_minutes(self) -> Optional[pulumi.Input[int]]:
|
|
552
|
+
def period_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
453
553
|
"""
|
|
454
554
|
The interval in minutes at which Synthetic monitor should run.
|
|
455
555
|
"""
|
|
456
556
|
return pulumi.get(self, "period_in_minutes")
|
|
457
557
|
|
|
458
558
|
@period_in_minutes.setter
|
|
459
|
-
def period_in_minutes(self, value: Optional[pulumi.Input[int]]):
|
|
559
|
+
def period_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
460
560
|
pulumi.set(self, "period_in_minutes", value)
|
|
461
561
|
|
|
462
|
-
@property
|
|
562
|
+
@_builtins.property
|
|
463
563
|
@pulumi.getter(name="runtimeType")
|
|
464
|
-
def runtime_type(self) -> Optional[pulumi.Input[str]]:
|
|
564
|
+
def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
465
565
|
"""
|
|
466
|
-
The runtime that the monitor will use to run jobs.
|
|
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`.
|
|
467
567
|
"""
|
|
468
568
|
return pulumi.get(self, "runtime_type")
|
|
469
569
|
|
|
470
570
|
@runtime_type.setter
|
|
471
|
-
def runtime_type(self, value: Optional[pulumi.Input[str]]):
|
|
571
|
+
def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
472
572
|
pulumi.set(self, "runtime_type", value)
|
|
473
573
|
|
|
474
|
-
@property
|
|
574
|
+
@_builtins.property
|
|
475
575
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
476
|
-
def runtime_type_version(self) -> Optional[pulumi.Input[str]]:
|
|
576
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
477
577
|
"""
|
|
478
|
-
The specific version of the runtime type selected.
|
|
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.
|
|
479
579
|
"""
|
|
480
580
|
return pulumi.get(self, "runtime_type_version")
|
|
481
581
|
|
|
482
582
|
@runtime_type_version.setter
|
|
483
|
-
def runtime_type_version(self, value: Optional[pulumi.Input[str]]):
|
|
583
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
484
584
|
pulumi.set(self, "runtime_type_version", value)
|
|
485
585
|
|
|
486
|
-
@property
|
|
586
|
+
@_builtins.property
|
|
487
587
|
@pulumi.getter
|
|
488
|
-
def script(self) -> Optional[pulumi.Input[str]]:
|
|
588
|
+
def script(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
489
589
|
"""
|
|
490
590
|
The script that the monitor runs.
|
|
491
591
|
"""
|
|
492
592
|
return pulumi.get(self, "script")
|
|
493
593
|
|
|
494
594
|
@script.setter
|
|
495
|
-
def script(self, value: Optional[pulumi.Input[str]]):
|
|
595
|
+
def script(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
496
596
|
pulumi.set(self, "script", value)
|
|
497
597
|
|
|
498
|
-
@property
|
|
598
|
+
@_builtins.property
|
|
499
599
|
@pulumi.getter(name="scriptLanguage")
|
|
500
|
-
def script_language(self) -> Optional[pulumi.Input[str]]:
|
|
600
|
+
def script_language(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
501
601
|
"""
|
|
502
602
|
The programing language that should execute the script.
|
|
503
603
|
"""
|
|
504
604
|
return pulumi.get(self, "script_language")
|
|
505
605
|
|
|
506
606
|
@script_language.setter
|
|
507
|
-
def script_language(self, value: Optional[pulumi.Input[str]]):
|
|
607
|
+
def script_language(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
508
608
|
pulumi.set(self, "script_language", value)
|
|
509
609
|
|
|
510
|
-
@property
|
|
610
|
+
@_builtins.property
|
|
511
611
|
@pulumi.getter
|
|
512
|
-
def status(self) -> Optional[pulumi.Input[str]]:
|
|
612
|
+
def status(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
513
613
|
"""
|
|
514
|
-
The monitor
|
|
614
|
+
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
515
615
|
"""
|
|
516
616
|
return pulumi.get(self, "status")
|
|
517
617
|
|
|
518
618
|
@status.setter
|
|
519
|
-
def status(self, value: Optional[pulumi.Input[str]]):
|
|
619
|
+
def status(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
520
620
|
pulumi.set(self, "status", value)
|
|
521
621
|
|
|
522
|
-
@property
|
|
622
|
+
@_builtins.property
|
|
523
623
|
@pulumi.getter
|
|
524
624
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorTagArgs']]]]:
|
|
525
625
|
"""
|
|
526
626
|
The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
527
627
|
|
|
528
|
-
The `SCRIPTED_BROWSER` monitor type supports the following additional
|
|
628
|
+
The `SCRIPTED_BROWSER` monitor type supports the following additional arguments:
|
|
529
629
|
"""
|
|
530
630
|
return pulumi.get(self, "tags")
|
|
531
631
|
|
|
@@ -533,96 +633,111 @@ class _ScriptMonitorState:
|
|
|
533
633
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ScriptMonitorTagArgs']]]]):
|
|
534
634
|
pulumi.set(self, "tags", value)
|
|
535
635
|
|
|
536
|
-
@property
|
|
636
|
+
@_builtins.property
|
|
537
637
|
@pulumi.getter
|
|
538
|
-
def type(self) -> Optional[pulumi.Input[str]]:
|
|
638
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
539
639
|
"""
|
|
540
640
|
The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
541
641
|
"""
|
|
542
642
|
return pulumi.get(self, "type")
|
|
543
643
|
|
|
544
644
|
@type.setter
|
|
545
|
-
def type(self, value: Optional[pulumi.Input[str]]):
|
|
645
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
546
646
|
pulumi.set(self, "type", value)
|
|
547
647
|
|
|
648
|
+
@_builtins.property
|
|
649
|
+
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
650
|
+
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
651
|
+
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
548
652
|
|
|
653
|
+
@use_unsupported_legacy_runtime.setter
|
|
654
|
+
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
655
|
+
pulumi.set(self, "use_unsupported_legacy_runtime", value)
|
|
656
|
+
|
|
657
|
+
|
|
658
|
+
@pulumi.type_token("newrelic:synthetics/scriptMonitor:ScriptMonitor")
|
|
549
659
|
class ScriptMonitor(pulumi.CustomResource):
|
|
550
660
|
@overload
|
|
551
661
|
def __init__(__self__,
|
|
552
662
|
resource_name: str,
|
|
553
663
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
554
|
-
account_id: Optional[pulumi.Input[
|
|
555
|
-
|
|
556
|
-
|
|
557
|
-
|
|
558
|
-
|
|
559
|
-
|
|
560
|
-
|
|
561
|
-
|
|
562
|
-
|
|
563
|
-
|
|
564
|
-
|
|
565
|
-
|
|
566
|
-
|
|
567
|
-
|
|
568
|
-
|
|
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,
|
|
670
|
+
location_privates: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorLocationPrivateArgs', 'ScriptMonitorLocationPrivateArgsDict']]]]] = 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,
|
|
679
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorTagArgs', 'ScriptMonitorTagArgsDict']]]]] = None,
|
|
680
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
681
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
569
682
|
__props__=None):
|
|
570
683
|
"""
|
|
571
|
-
Use this resource to create update, and delete a Script API or Script Browser Synthetics Monitor in New Relic.
|
|
572
|
-
|
|
573
684
|
## Example Usage
|
|
574
685
|
|
|
575
686
|
##### Type: `SCRIPT_API`
|
|
576
687
|
|
|
577
|
-
<!--Start PulumiCodeChooser -->
|
|
578
688
|
```python
|
|
579
689
|
import pulumi
|
|
580
690
|
import pulumi_newrelic as newrelic
|
|
581
691
|
|
|
582
692
|
monitor = newrelic.synthetics.ScriptMonitor("monitor",
|
|
693
|
+
status="ENABLED",
|
|
694
|
+
name="script_monitor",
|
|
695
|
+
type="SCRIPT_API",
|
|
583
696
|
locations_publics=[
|
|
584
697
|
"AP_SOUTH_1",
|
|
585
698
|
"AP_EAST_1",
|
|
586
699
|
],
|
|
587
700
|
period="EVERY_6_HOURS",
|
|
588
|
-
runtime_type="NODE_API",
|
|
589
|
-
runtime_type_version="16.10",
|
|
590
701
|
script="console.log('it works!')",
|
|
591
702
|
script_language="JAVASCRIPT",
|
|
592
|
-
|
|
593
|
-
|
|
594
|
-
|
|
595
|
-
|
|
596
|
-
|
|
597
|
-
|
|
703
|
+
runtime_type="NODE_API",
|
|
704
|
+
runtime_type_version="16.10",
|
|
705
|
+
tags=[{
|
|
706
|
+
"key": "some_key",
|
|
707
|
+
"values": ["some_value"],
|
|
708
|
+
}])
|
|
598
709
|
```
|
|
599
|
-
<!--End PulumiCodeChooser -->
|
|
600
710
|
##### Type: `SCRIPT_BROWSER`
|
|
601
711
|
|
|
602
|
-
<!--Start PulumiCodeChooser -->
|
|
603
712
|
```python
|
|
604
713
|
import pulumi
|
|
605
714
|
import pulumi_newrelic as newrelic
|
|
606
715
|
|
|
607
716
|
monitor = newrelic.synthetics.ScriptMonitor("monitor",
|
|
608
|
-
|
|
717
|
+
status="ENABLED",
|
|
718
|
+
name="script_monitor",
|
|
719
|
+
type="SCRIPT_BROWSER",
|
|
609
720
|
locations_publics=[
|
|
610
721
|
"AP_SOUTH_1",
|
|
611
722
|
"AP_EAST_1",
|
|
612
723
|
],
|
|
613
724
|
period="EVERY_HOUR",
|
|
614
|
-
runtime_type="CHROME_BROWSER",
|
|
615
|
-
runtime_type_version="100",
|
|
616
725
|
script="$browser.get('https://one.newrelic.com')",
|
|
726
|
+
runtime_type_version="100",
|
|
727
|
+
runtime_type="CHROME_BROWSER",
|
|
617
728
|
script_language="JAVASCRIPT",
|
|
618
|
-
|
|
619
|
-
|
|
620
|
-
|
|
621
|
-
|
|
622
|
-
|
|
623
|
-
|
|
729
|
+
devices=[
|
|
730
|
+
"DESKTOP",
|
|
731
|
+
"MOBILE_PORTRAIT",
|
|
732
|
+
"TABLET_LANDSCAPE",
|
|
733
|
+
],
|
|
734
|
+
browsers=["CHROME"],
|
|
735
|
+
enable_screenshot_on_failure_and_script=False,
|
|
736
|
+
tags=[{
|
|
737
|
+
"key": "some_key",
|
|
738
|
+
"values": ["some_value"],
|
|
739
|
+
}])
|
|
624
740
|
```
|
|
625
|
-
<!--End PulumiCodeChooser -->
|
|
626
741
|
See additional examples.
|
|
627
742
|
|
|
628
743
|
## Additional Examples
|
|
@@ -635,61 +750,98 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
635
750
|
|
|
636
751
|
##### Type: `SCRIPT_API`
|
|
637
752
|
|
|
638
|
-
<!--Start PulumiCodeChooser -->
|
|
639
753
|
```python
|
|
640
754
|
import pulumi
|
|
641
755
|
import pulumi_newrelic as newrelic
|
|
642
756
|
|
|
643
757
|
location = newrelic.synthetics.PrivateLocation("location",
|
|
644
758
|
description="Example private location",
|
|
759
|
+
name="private_location",
|
|
645
760
|
verified_script_execution=True)
|
|
646
761
|
monitor = newrelic.synthetics.ScriptMonitor("monitor",
|
|
647
762
|
status="ENABLED",
|
|
763
|
+
name="script_monitor",
|
|
648
764
|
type="SCRIPT_API",
|
|
649
|
-
location_privates=[
|
|
650
|
-
guid
|
|
651
|
-
vse_password
|
|
652
|
-
|
|
765
|
+
location_privates=[{
|
|
766
|
+
"guid": location.id,
|
|
767
|
+
"vse_password": "secret",
|
|
768
|
+
}],
|
|
653
769
|
period="EVERY_6_HOURS",
|
|
654
770
|
script="console.log('terraform integration test updated')",
|
|
655
771
|
script_language="JAVASCRIPT",
|
|
656
772
|
runtime_type="NODE_API",
|
|
657
773
|
runtime_type_version="16.10",
|
|
658
|
-
tags=[
|
|
659
|
-
key
|
|
660
|
-
values
|
|
661
|
-
|
|
774
|
+
tags=[{
|
|
775
|
+
"key": "some_key",
|
|
776
|
+
"values": ["some_value"],
|
|
777
|
+
}])
|
|
662
778
|
```
|
|
663
|
-
<!--End PulumiCodeChooser -->
|
|
664
779
|
##### Type: `SCRIPT_BROWSER`
|
|
665
780
|
|
|
666
|
-
<!--Start PulumiCodeChooser -->
|
|
667
781
|
```python
|
|
668
782
|
import pulumi
|
|
669
783
|
import pulumi_newrelic as newrelic
|
|
670
784
|
|
|
671
785
|
location = newrelic.synthetics.PrivateLocation("location",
|
|
672
786
|
description="Test Description",
|
|
787
|
+
name="private_location",
|
|
673
788
|
verified_script_execution=True)
|
|
674
789
|
monitor = newrelic.synthetics.ScriptMonitor("monitor",
|
|
675
790
|
status="ENABLED",
|
|
791
|
+
name="script_monitor",
|
|
676
792
|
type="SCRIPT_BROWSER",
|
|
677
793
|
period="EVERY_HOUR",
|
|
678
794
|
script="$browser.get('https://one.newrelic.com')",
|
|
679
|
-
enable_screenshot_on_failure_and_script=False,
|
|
680
|
-
location_privates=[newrelic.synthetics.ScriptMonitorLocationPrivateArgs(
|
|
681
|
-
guid=location.id,
|
|
682
|
-
vse_password="secret",
|
|
683
|
-
)],
|
|
684
795
|
runtime_type_version="100",
|
|
685
796
|
runtime_type="CHROME_BROWSER",
|
|
686
797
|
script_language="JAVASCRIPT",
|
|
687
|
-
|
|
688
|
-
|
|
689
|
-
|
|
690
|
-
|
|
798
|
+
devices=[
|
|
799
|
+
"DESKTOP",
|
|
800
|
+
"MOBILE_PORTRAIT",
|
|
801
|
+
"TABLET_LANDSCAPE",
|
|
802
|
+
],
|
|
803
|
+
browsers=["CHROME"],
|
|
804
|
+
enable_screenshot_on_failure_and_script=False,
|
|
805
|
+
location_privates=[{
|
|
806
|
+
"guid": location.id,
|
|
807
|
+
"vse_password": "secret",
|
|
808
|
+
}],
|
|
809
|
+
tags=[{
|
|
810
|
+
"key": "some_key",
|
|
811
|
+
"values": ["some_value"],
|
|
812
|
+
}])
|
|
813
|
+
```
|
|
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]))
|
|
691
844
|
```
|
|
692
|
-
<!--End PulumiCodeChooser -->
|
|
693
845
|
|
|
694
846
|
## Import
|
|
695
847
|
|
|
@@ -703,23 +855,25 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
703
855
|
|
|
704
856
|
:param str resource_name: The name of the resource.
|
|
705
857
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
706
|
-
:param pulumi.Input[
|
|
707
|
-
:param pulumi.Input[str]
|
|
708
|
-
:param pulumi.Input[str]
|
|
709
|
-
:param pulumi.Input[
|
|
710
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
711
|
-
:param pulumi.Input[
|
|
712
|
-
:param pulumi.Input[
|
|
713
|
-
:param pulumi.Input[str]
|
|
714
|
-
:param pulumi.Input[str]
|
|
715
|
-
:param pulumi.Input[str]
|
|
716
|
-
:param pulumi.Input[str]
|
|
717
|
-
:param pulumi.Input[str]
|
|
718
|
-
:param pulumi.Input[str]
|
|
719
|
-
: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.
|
|
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**.
|
|
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`).
|
|
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.
|
|
720
874
|
|
|
721
|
-
The `SCRIPTED_BROWSER` monitor type supports the following additional
|
|
722
|
-
:param pulumi.Input[str] type: The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
875
|
+
The `SCRIPTED_BROWSER` monitor type supports the following additional arguments:
|
|
876
|
+
:param pulumi.Input[_builtins.str] type: The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
723
877
|
"""
|
|
724
878
|
...
|
|
725
879
|
@overload
|
|
@@ -728,61 +882,63 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
728
882
|
args: ScriptMonitorArgs,
|
|
729
883
|
opts: Optional[pulumi.ResourceOptions] = None):
|
|
730
884
|
"""
|
|
731
|
-
Use this resource to create update, and delete a Script API or Script Browser Synthetics Monitor in New Relic.
|
|
732
|
-
|
|
733
885
|
## Example Usage
|
|
734
886
|
|
|
735
887
|
##### Type: `SCRIPT_API`
|
|
736
888
|
|
|
737
|
-
<!--Start PulumiCodeChooser -->
|
|
738
889
|
```python
|
|
739
890
|
import pulumi
|
|
740
891
|
import pulumi_newrelic as newrelic
|
|
741
892
|
|
|
742
893
|
monitor = newrelic.synthetics.ScriptMonitor("monitor",
|
|
894
|
+
status="ENABLED",
|
|
895
|
+
name="script_monitor",
|
|
896
|
+
type="SCRIPT_API",
|
|
743
897
|
locations_publics=[
|
|
744
898
|
"AP_SOUTH_1",
|
|
745
899
|
"AP_EAST_1",
|
|
746
900
|
],
|
|
747
901
|
period="EVERY_6_HOURS",
|
|
748
|
-
runtime_type="NODE_API",
|
|
749
|
-
runtime_type_version="16.10",
|
|
750
902
|
script="console.log('it works!')",
|
|
751
903
|
script_language="JAVASCRIPT",
|
|
752
|
-
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
904
|
+
runtime_type="NODE_API",
|
|
905
|
+
runtime_type_version="16.10",
|
|
906
|
+
tags=[{
|
|
907
|
+
"key": "some_key",
|
|
908
|
+
"values": ["some_value"],
|
|
909
|
+
}])
|
|
758
910
|
```
|
|
759
|
-
<!--End PulumiCodeChooser -->
|
|
760
911
|
##### Type: `SCRIPT_BROWSER`
|
|
761
912
|
|
|
762
|
-
<!--Start PulumiCodeChooser -->
|
|
763
913
|
```python
|
|
764
914
|
import pulumi
|
|
765
915
|
import pulumi_newrelic as newrelic
|
|
766
916
|
|
|
767
917
|
monitor = newrelic.synthetics.ScriptMonitor("monitor",
|
|
768
|
-
|
|
918
|
+
status="ENABLED",
|
|
919
|
+
name="script_monitor",
|
|
920
|
+
type="SCRIPT_BROWSER",
|
|
769
921
|
locations_publics=[
|
|
770
922
|
"AP_SOUTH_1",
|
|
771
923
|
"AP_EAST_1",
|
|
772
924
|
],
|
|
773
925
|
period="EVERY_HOUR",
|
|
774
|
-
runtime_type="CHROME_BROWSER",
|
|
775
|
-
runtime_type_version="100",
|
|
776
926
|
script="$browser.get('https://one.newrelic.com')",
|
|
927
|
+
runtime_type_version="100",
|
|
928
|
+
runtime_type="CHROME_BROWSER",
|
|
777
929
|
script_language="JAVASCRIPT",
|
|
778
|
-
|
|
779
|
-
|
|
780
|
-
|
|
781
|
-
|
|
782
|
-
|
|
783
|
-
|
|
930
|
+
devices=[
|
|
931
|
+
"DESKTOP",
|
|
932
|
+
"MOBILE_PORTRAIT",
|
|
933
|
+
"TABLET_LANDSCAPE",
|
|
934
|
+
],
|
|
935
|
+
browsers=["CHROME"],
|
|
936
|
+
enable_screenshot_on_failure_and_script=False,
|
|
937
|
+
tags=[{
|
|
938
|
+
"key": "some_key",
|
|
939
|
+
"values": ["some_value"],
|
|
940
|
+
}])
|
|
784
941
|
```
|
|
785
|
-
<!--End PulumiCodeChooser -->
|
|
786
942
|
See additional examples.
|
|
787
943
|
|
|
788
944
|
## Additional Examples
|
|
@@ -795,61 +951,98 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
795
951
|
|
|
796
952
|
##### Type: `SCRIPT_API`
|
|
797
953
|
|
|
798
|
-
<!--Start PulumiCodeChooser -->
|
|
799
954
|
```python
|
|
800
955
|
import pulumi
|
|
801
956
|
import pulumi_newrelic as newrelic
|
|
802
957
|
|
|
803
958
|
location = newrelic.synthetics.PrivateLocation("location",
|
|
804
959
|
description="Example private location",
|
|
960
|
+
name="private_location",
|
|
805
961
|
verified_script_execution=True)
|
|
806
962
|
monitor = newrelic.synthetics.ScriptMonitor("monitor",
|
|
807
963
|
status="ENABLED",
|
|
964
|
+
name="script_monitor",
|
|
808
965
|
type="SCRIPT_API",
|
|
809
|
-
location_privates=[
|
|
810
|
-
guid
|
|
811
|
-
vse_password
|
|
812
|
-
|
|
966
|
+
location_privates=[{
|
|
967
|
+
"guid": location.id,
|
|
968
|
+
"vse_password": "secret",
|
|
969
|
+
}],
|
|
813
970
|
period="EVERY_6_HOURS",
|
|
814
971
|
script="console.log('terraform integration test updated')",
|
|
815
972
|
script_language="JAVASCRIPT",
|
|
816
973
|
runtime_type="NODE_API",
|
|
817
974
|
runtime_type_version="16.10",
|
|
818
|
-
tags=[
|
|
819
|
-
key
|
|
820
|
-
values
|
|
821
|
-
|
|
975
|
+
tags=[{
|
|
976
|
+
"key": "some_key",
|
|
977
|
+
"values": ["some_value"],
|
|
978
|
+
}])
|
|
822
979
|
```
|
|
823
|
-
<!--End PulumiCodeChooser -->
|
|
824
980
|
##### Type: `SCRIPT_BROWSER`
|
|
825
981
|
|
|
826
|
-
<!--Start PulumiCodeChooser -->
|
|
827
982
|
```python
|
|
828
983
|
import pulumi
|
|
829
984
|
import pulumi_newrelic as newrelic
|
|
830
985
|
|
|
831
986
|
location = newrelic.synthetics.PrivateLocation("location",
|
|
832
987
|
description="Test Description",
|
|
988
|
+
name="private_location",
|
|
833
989
|
verified_script_execution=True)
|
|
834
990
|
monitor = newrelic.synthetics.ScriptMonitor("monitor",
|
|
835
991
|
status="ENABLED",
|
|
992
|
+
name="script_monitor",
|
|
836
993
|
type="SCRIPT_BROWSER",
|
|
837
994
|
period="EVERY_HOUR",
|
|
838
995
|
script="$browser.get('https://one.newrelic.com')",
|
|
839
|
-
enable_screenshot_on_failure_and_script=False,
|
|
840
|
-
location_privates=[newrelic.synthetics.ScriptMonitorLocationPrivateArgs(
|
|
841
|
-
guid=location.id,
|
|
842
|
-
vse_password="secret",
|
|
843
|
-
)],
|
|
844
996
|
runtime_type_version="100",
|
|
845
997
|
runtime_type="CHROME_BROWSER",
|
|
846
998
|
script_language="JAVASCRIPT",
|
|
847
|
-
|
|
848
|
-
|
|
849
|
-
|
|
850
|
-
|
|
999
|
+
devices=[
|
|
1000
|
+
"DESKTOP",
|
|
1001
|
+
"MOBILE_PORTRAIT",
|
|
1002
|
+
"TABLET_LANDSCAPE",
|
|
1003
|
+
],
|
|
1004
|
+
browsers=["CHROME"],
|
|
1005
|
+
enable_screenshot_on_failure_and_script=False,
|
|
1006
|
+
location_privates=[{
|
|
1007
|
+
"guid": location.id,
|
|
1008
|
+
"vse_password": "secret",
|
|
1009
|
+
}],
|
|
1010
|
+
tags=[{
|
|
1011
|
+
"key": "some_key",
|
|
1012
|
+
"values": ["some_value"],
|
|
1013
|
+
}])
|
|
1014
|
+
```
|
|
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]))
|
|
851
1045
|
```
|
|
852
|
-
<!--End PulumiCodeChooser -->
|
|
853
1046
|
|
|
854
1047
|
## Import
|
|
855
1048
|
|
|
@@ -876,21 +1069,24 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
876
1069
|
def _internal_init(__self__,
|
|
877
1070
|
resource_name: str,
|
|
878
1071
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
879
|
-
account_id: Optional[pulumi.Input[
|
|
880
|
-
|
|
881
|
-
|
|
882
|
-
|
|
883
|
-
|
|
884
|
-
|
|
885
|
-
|
|
886
|
-
|
|
887
|
-
|
|
888
|
-
|
|
889
|
-
|
|
890
|
-
|
|
891
|
-
|
|
892
|
-
|
|
893
|
-
|
|
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,
|
|
1078
|
+
location_privates: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorLocationPrivateArgs', 'ScriptMonitorLocationPrivateArgsDict']]]]] = 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,
|
|
1087
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorTagArgs', 'ScriptMonitorTagArgsDict']]]]] = None,
|
|
1088
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1089
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
894
1090
|
__props__=None):
|
|
895
1091
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
896
1092
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -901,8 +1097,10 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
901
1097
|
__props__ = ScriptMonitorArgs.__new__(ScriptMonitorArgs)
|
|
902
1098
|
|
|
903
1099
|
__props__.__dict__["account_id"] = account_id
|
|
1100
|
+
__props__.__dict__["browsers"] = browsers
|
|
904
1101
|
__props__.__dict__["device_orientation"] = device_orientation
|
|
905
1102
|
__props__.__dict__["device_type"] = device_type
|
|
1103
|
+
__props__.__dict__["devices"] = devices
|
|
906
1104
|
__props__.__dict__["enable_screenshot_on_failure_and_script"] = enable_screenshot_on_failure_and_script
|
|
907
1105
|
__props__.__dict__["location_privates"] = location_privates
|
|
908
1106
|
__props__.__dict__["locations_publics"] = locations_publics
|
|
@@ -921,7 +1119,9 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
921
1119
|
if type is None and not opts.urn:
|
|
922
1120
|
raise TypeError("Missing required property 'type'")
|
|
923
1121
|
__props__.__dict__["type"] = type
|
|
1122
|
+
__props__.__dict__["use_unsupported_legacy_runtime"] = use_unsupported_legacy_runtime
|
|
924
1123
|
__props__.__dict__["guid"] = None
|
|
1124
|
+
__props__.__dict__["monitor_id"] = None
|
|
925
1125
|
__props__.__dict__["period_in_minutes"] = None
|
|
926
1126
|
super(ScriptMonitor, __self__).__init__(
|
|
927
1127
|
'newrelic:synthetics/scriptMonitor:ScriptMonitor',
|
|
@@ -933,23 +1133,27 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
933
1133
|
def get(resource_name: str,
|
|
934
1134
|
id: pulumi.Input[str],
|
|
935
1135
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
936
|
-
account_id: Optional[pulumi.Input[
|
|
937
|
-
|
|
938
|
-
|
|
939
|
-
|
|
940
|
-
|
|
941
|
-
|
|
942
|
-
|
|
943
|
-
|
|
944
|
-
|
|
945
|
-
|
|
946
|
-
|
|
947
|
-
|
|
948
|
-
|
|
949
|
-
|
|
950
|
-
|
|
951
|
-
|
|
952
|
-
|
|
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,
|
|
1143
|
+
location_privates: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorLocationPrivateArgs', 'ScriptMonitorLocationPrivateArgsDict']]]]] = None,
|
|
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,
|
|
1154
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ScriptMonitorTagArgs', 'ScriptMonitorTagArgsDict']]]]] = None,
|
|
1155
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1156
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None) -> 'ScriptMonitor':
|
|
953
1157
|
"""
|
|
954
1158
|
Get an existing ScriptMonitor resource's state with the given name, id, and optional extra
|
|
955
1159
|
properties used to qualify the lookup.
|
|
@@ -957,37 +1161,43 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
957
1161
|
:param str resource_name: The unique name of the resulting resource.
|
|
958
1162
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
959
1163
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
960
|
-
:param pulumi.Input[
|
|
961
|
-
:param pulumi.Input[str]
|
|
962
|
-
:param pulumi.Input[str]
|
|
963
|
-
:param pulumi.Input[
|
|
964
|
-
:param pulumi.Input[str]
|
|
965
|
-
:param pulumi.Input[
|
|
966
|
-
:param pulumi.Input[
|
|
967
|
-
:param pulumi.Input[
|
|
968
|
-
:param pulumi.Input[str]
|
|
969
|
-
:param pulumi.Input[
|
|
970
|
-
:param pulumi.Input[str]
|
|
971
|
-
:param pulumi.Input[str]
|
|
972
|
-
:param pulumi.Input[
|
|
973
|
-
:param pulumi.Input[str]
|
|
974
|
-
:param pulumi.Input[str]
|
|
975
|
-
: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.
|
|
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**.
|
|
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`).
|
|
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.
|
|
976
1183
|
|
|
977
|
-
The `SCRIPTED_BROWSER` monitor type supports the following additional
|
|
978
|
-
:param pulumi.Input[str] type: The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
1184
|
+
The `SCRIPTED_BROWSER` monitor type supports the following additional arguments:
|
|
1185
|
+
:param pulumi.Input[_builtins.str] type: The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
979
1186
|
"""
|
|
980
1187
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
981
1188
|
|
|
982
1189
|
__props__ = _ScriptMonitorState.__new__(_ScriptMonitorState)
|
|
983
1190
|
|
|
984
1191
|
__props__.__dict__["account_id"] = account_id
|
|
1192
|
+
__props__.__dict__["browsers"] = browsers
|
|
985
1193
|
__props__.__dict__["device_orientation"] = device_orientation
|
|
986
1194
|
__props__.__dict__["device_type"] = device_type
|
|
1195
|
+
__props__.__dict__["devices"] = devices
|
|
987
1196
|
__props__.__dict__["enable_screenshot_on_failure_and_script"] = enable_screenshot_on_failure_and_script
|
|
988
1197
|
__props__.__dict__["guid"] = guid
|
|
989
1198
|
__props__.__dict__["location_privates"] = location_privates
|
|
990
1199
|
__props__.__dict__["locations_publics"] = locations_publics
|
|
1200
|
+
__props__.__dict__["monitor_id"] = monitor_id
|
|
991
1201
|
__props__.__dict__["name"] = name
|
|
992
1202
|
__props__.__dict__["period"] = period
|
|
993
1203
|
__props__.__dict__["period_in_minutes"] = period_in_minutes
|
|
@@ -998,49 +1208,66 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
998
1208
|
__props__.__dict__["status"] = status
|
|
999
1209
|
__props__.__dict__["tags"] = tags
|
|
1000
1210
|
__props__.__dict__["type"] = type
|
|
1211
|
+
__props__.__dict__["use_unsupported_legacy_runtime"] = use_unsupported_legacy_runtime
|
|
1001
1212
|
return ScriptMonitor(resource_name, opts=opts, __props__=__props__)
|
|
1002
1213
|
|
|
1003
|
-
@property
|
|
1214
|
+
@_builtins.property
|
|
1004
1215
|
@pulumi.getter(name="accountId")
|
|
1005
|
-
def account_id(self) -> pulumi.Output[
|
|
1216
|
+
def account_id(self) -> pulumi.Output[_builtins.str]:
|
|
1006
1217
|
"""
|
|
1007
1218
|
The account in which the Synthetics monitor will be created.
|
|
1008
1219
|
"""
|
|
1009
1220
|
return pulumi.get(self, "account_id")
|
|
1010
1221
|
|
|
1011
|
-
@property
|
|
1222
|
+
@_builtins.property
|
|
1223
|
+
@pulumi.getter
|
|
1224
|
+
def browsers(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1225
|
+
"""
|
|
1226
|
+
The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
1227
|
+
"""
|
|
1228
|
+
return pulumi.get(self, "browsers")
|
|
1229
|
+
|
|
1230
|
+
@_builtins.property
|
|
1012
1231
|
@pulumi.getter(name="deviceOrientation")
|
|
1013
|
-
def device_orientation(self) -> pulumi.Output[Optional[str]]:
|
|
1232
|
+
def device_orientation(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1014
1233
|
"""
|
|
1015
|
-
Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
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.
|
|
1016
1235
|
"""
|
|
1017
1236
|
return pulumi.get(self, "device_orientation")
|
|
1018
1237
|
|
|
1019
|
-
@property
|
|
1238
|
+
@_builtins.property
|
|
1020
1239
|
@pulumi.getter(name="deviceType")
|
|
1021
|
-
def device_type(self) -> pulumi.Output[Optional[str]]:
|
|
1240
|
+
def device_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1022
1241
|
"""
|
|
1023
|
-
Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
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.
|
|
1024
1243
|
"""
|
|
1025
1244
|
return pulumi.get(self, "device_type")
|
|
1026
1245
|
|
|
1027
|
-
@property
|
|
1246
|
+
@_builtins.property
|
|
1247
|
+
@pulumi.getter
|
|
1248
|
+
def devices(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1249
|
+
"""
|
|
1250
|
+
The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
1251
|
+
"""
|
|
1252
|
+
return pulumi.get(self, "devices")
|
|
1253
|
+
|
|
1254
|
+
@_builtins.property
|
|
1028
1255
|
@pulumi.getter(name="enableScreenshotOnFailureAndScript")
|
|
1029
|
-
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]]:
|
|
1030
1257
|
"""
|
|
1031
1258
|
Capture a screenshot during job execution.
|
|
1032
1259
|
"""
|
|
1033
1260
|
return pulumi.get(self, "enable_screenshot_on_failure_and_script")
|
|
1034
1261
|
|
|
1035
|
-
@property
|
|
1262
|
+
@_builtins.property
|
|
1036
1263
|
@pulumi.getter
|
|
1037
|
-
def guid(self) -> pulumi.Output[str]:
|
|
1264
|
+
def guid(self) -> pulumi.Output[_builtins.str]:
|
|
1038
1265
|
"""
|
|
1039
|
-
The unique identifier
|
|
1266
|
+
The unique entity identifier of the monitor in New Relic.
|
|
1040
1267
|
"""
|
|
1041
1268
|
return pulumi.get(self, "guid")
|
|
1042
1269
|
|
|
1043
|
-
@property
|
|
1270
|
+
@_builtins.property
|
|
1044
1271
|
@pulumi.getter(name="locationPrivates")
|
|
1045
1272
|
def location_privates(self) -> pulumi.Output[Optional[Sequence['outputs.ScriptMonitorLocationPrivate']]]:
|
|
1046
1273
|
"""
|
|
@@ -1048,93 +1275,106 @@ class ScriptMonitor(pulumi.CustomResource):
|
|
|
1048
1275
|
"""
|
|
1049
1276
|
return pulumi.get(self, "location_privates")
|
|
1050
1277
|
|
|
1051
|
-
@property
|
|
1278
|
+
@_builtins.property
|
|
1052
1279
|
@pulumi.getter(name="locationsPublics")
|
|
1053
|
-
def locations_publics(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1280
|
+
def locations_publics(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1054
1281
|
"""
|
|
1055
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**.
|
|
1056
1283
|
"""
|
|
1057
1284
|
return pulumi.get(self, "locations_publics")
|
|
1058
1285
|
|
|
1059
|
-
@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
|
|
1060
1295
|
@pulumi.getter
|
|
1061
|
-
def name(self) -> pulumi.Output[str]:
|
|
1296
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
1062
1297
|
"""
|
|
1063
1298
|
The name for the monitor.
|
|
1064
1299
|
"""
|
|
1065
1300
|
return pulumi.get(self, "name")
|
|
1066
1301
|
|
|
1067
|
-
@property
|
|
1302
|
+
@_builtins.property
|
|
1068
1303
|
@pulumi.getter
|
|
1069
|
-
def period(self) -> pulumi.Output[str]:
|
|
1304
|
+
def period(self) -> pulumi.Output[_builtins.str]:
|
|
1070
1305
|
"""
|
|
1071
|
-
The interval at which this monitor should run. Valid values are EVERY_MINUTE
|
|
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`.
|
|
1072
1307
|
"""
|
|
1073
1308
|
return pulumi.get(self, "period")
|
|
1074
1309
|
|
|
1075
|
-
@property
|
|
1310
|
+
@_builtins.property
|
|
1076
1311
|
@pulumi.getter(name="periodInMinutes")
|
|
1077
|
-
def period_in_minutes(self) -> pulumi.Output[int]:
|
|
1312
|
+
def period_in_minutes(self) -> pulumi.Output[_builtins.int]:
|
|
1078
1313
|
"""
|
|
1079
1314
|
The interval in minutes at which Synthetic monitor should run.
|
|
1080
1315
|
"""
|
|
1081
1316
|
return pulumi.get(self, "period_in_minutes")
|
|
1082
1317
|
|
|
1083
|
-
@property
|
|
1318
|
+
@_builtins.property
|
|
1084
1319
|
@pulumi.getter(name="runtimeType")
|
|
1085
|
-
def runtime_type(self) -> pulumi.Output[Optional[str]]:
|
|
1320
|
+
def runtime_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1086
1321
|
"""
|
|
1087
|
-
The runtime that the monitor will use to run jobs.
|
|
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`.
|
|
1088
1323
|
"""
|
|
1089
1324
|
return pulumi.get(self, "runtime_type")
|
|
1090
1325
|
|
|
1091
|
-
@property
|
|
1326
|
+
@_builtins.property
|
|
1092
1327
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
1093
|
-
def runtime_type_version(self) -> pulumi.Output[Optional[str]]:
|
|
1328
|
+
def runtime_type_version(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1094
1329
|
"""
|
|
1095
|
-
The specific version of the runtime type selected.
|
|
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.
|
|
1096
1331
|
"""
|
|
1097
1332
|
return pulumi.get(self, "runtime_type_version")
|
|
1098
1333
|
|
|
1099
|
-
@property
|
|
1334
|
+
@_builtins.property
|
|
1100
1335
|
@pulumi.getter
|
|
1101
|
-
def script(self) -> pulumi.Output[Optional[str]]:
|
|
1336
|
+
def script(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1102
1337
|
"""
|
|
1103
1338
|
The script that the monitor runs.
|
|
1104
1339
|
"""
|
|
1105
1340
|
return pulumi.get(self, "script")
|
|
1106
1341
|
|
|
1107
|
-
@property
|
|
1342
|
+
@_builtins.property
|
|
1108
1343
|
@pulumi.getter(name="scriptLanguage")
|
|
1109
|
-
def script_language(self) -> pulumi.Output[Optional[str]]:
|
|
1344
|
+
def script_language(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1110
1345
|
"""
|
|
1111
1346
|
The programing language that should execute the script.
|
|
1112
1347
|
"""
|
|
1113
1348
|
return pulumi.get(self, "script_language")
|
|
1114
1349
|
|
|
1115
|
-
@property
|
|
1350
|
+
@_builtins.property
|
|
1116
1351
|
@pulumi.getter
|
|
1117
|
-
def status(self) -> pulumi.Output[str]:
|
|
1352
|
+
def status(self) -> pulumi.Output[_builtins.str]:
|
|
1118
1353
|
"""
|
|
1119
|
-
The monitor
|
|
1354
|
+
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
1120
1355
|
"""
|
|
1121
1356
|
return pulumi.get(self, "status")
|
|
1122
1357
|
|
|
1123
|
-
@property
|
|
1358
|
+
@_builtins.property
|
|
1124
1359
|
@pulumi.getter
|
|
1125
1360
|
def tags(self) -> pulumi.Output[Optional[Sequence['outputs.ScriptMonitorTag']]]:
|
|
1126
1361
|
"""
|
|
1127
1362
|
The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
1128
1363
|
|
|
1129
|
-
The `SCRIPTED_BROWSER` monitor type supports the following additional
|
|
1364
|
+
The `SCRIPTED_BROWSER` monitor type supports the following additional arguments:
|
|
1130
1365
|
"""
|
|
1131
1366
|
return pulumi.get(self, "tags")
|
|
1132
1367
|
|
|
1133
|
-
@property
|
|
1368
|
+
@_builtins.property
|
|
1134
1369
|
@pulumi.getter
|
|
1135
|
-
def type(self) -> pulumi.Output[str]:
|
|
1370
|
+
def type(self) -> pulumi.Output[_builtins.str]:
|
|
1136
1371
|
"""
|
|
1137
1372
|
The plaintext representing the monitor script. Valid values are SCRIPT_BROWSER or SCRIPT_API
|
|
1138
1373
|
"""
|
|
1139
1374
|
return pulumi.get(self, "type")
|
|
1140
1375
|
|
|
1376
|
+
@_builtins.property
|
|
1377
|
+
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
1378
|
+
def use_unsupported_legacy_runtime(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1379
|
+
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
1380
|
+
|