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