pulumi-newrelic 5.22.0__py3-none-any.whl → 5.58.0a1763707205__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of pulumi-newrelic might be problematic. Click here for more details.
- pulumi_newrelic/__init__.py +28 -1
- pulumi_newrelic/_inputs.py +10385 -2976
- pulumi_newrelic/_utilities.py +50 -10
- pulumi_newrelic/account_management.py +48 -42
- pulumi_newrelic/alert_channel.py +165 -175
- pulumi_newrelic/alert_condition.py +307 -319
- pulumi_newrelic/alert_muting_rule.py +193 -140
- pulumi_newrelic/alert_policy.py +121 -117
- pulumi_newrelic/alert_policy_channel.py +89 -79
- pulumi_newrelic/api_access_key.py +195 -193
- pulumi_newrelic/browser_application.py +120 -114
- pulumi_newrelic/cloud/__init__.py +3 -1
- pulumi_newrelic/cloud/_inputs.py +4267 -2714
- pulumi_newrelic/cloud/aws_govcloud_integrations.py +206 -196
- pulumi_newrelic/cloud/aws_govcloud_link_account.py +143 -228
- pulumi_newrelic/cloud/aws_integrations.py +510 -1490
- pulumi_newrelic/cloud/aws_link_account.py +80 -76
- pulumi_newrelic/cloud/azure_integrations.py +673 -587
- pulumi_newrelic/cloud/azure_link_account.py +121 -117
- pulumi_newrelic/cloud/gcp_integrations.py +428 -408
- pulumi_newrelic/cloud/gcp_link_account.py +65 -61
- pulumi_newrelic/cloud/oci_link_account.py +926 -0
- pulumi_newrelic/cloud/outputs.py +1678 -2321
- pulumi_newrelic/config/__init__.py +2 -1
- pulumi_newrelic/config/__init__.pyi +8 -3
- pulumi_newrelic/config/vars.py +22 -17
- pulumi_newrelic/data_partition_rule.py +119 -117
- pulumi_newrelic/entity_tags.py +111 -53
- pulumi_newrelic/events_to_metrics_rule.py +106 -102
- pulumi_newrelic/get_account.py +41 -33
- pulumi_newrelic/get_alert_channel.py +73 -28
- pulumi_newrelic/get_alert_policy.py +82 -33
- pulumi_newrelic/get_application.py +51 -43
- pulumi_newrelic/get_authentication_domain.py +27 -23
- pulumi_newrelic/get_cloud_account.py +43 -35
- pulumi_newrelic/get_entity.py +126 -183
- pulumi_newrelic/get_group.py +76 -31
- pulumi_newrelic/get_key_transaction.py +117 -42
- pulumi_newrelic/get_notification_destination.py +75 -38
- pulumi_newrelic/get_obfuscation_expression.py +47 -39
- pulumi_newrelic/get_service_level_alert_helper.py +189 -171
- pulumi_newrelic/get_test_grok_pattern.py +47 -36
- pulumi_newrelic/get_user.py +39 -31
- pulumi_newrelic/group.py +59 -199
- pulumi_newrelic/infra_alert_condition.py +399 -405
- pulumi_newrelic/insights/__init__.py +2 -1
- pulumi_newrelic/insights/_inputs.py +71 -28
- pulumi_newrelic/insights/event.py +54 -52
- pulumi_newrelic/insights/outputs.py +28 -23
- pulumi_newrelic/key_transaction.py +465 -0
- pulumi_newrelic/log_parsing_rule.py +159 -157
- pulumi_newrelic/monitor_downtime.py +311 -331
- pulumi_newrelic/notification_channel.py +534 -464
- pulumi_newrelic/notification_destination.py +238 -141
- pulumi_newrelic/nrql_alert_condition.py +820 -614
- pulumi_newrelic/nrql_drop_rule.py +113 -151
- pulumi_newrelic/obfuscation_expression.py +80 -76
- pulumi_newrelic/obfuscation_rule.py +115 -109
- pulumi_newrelic/one_dashboard.py +110 -104
- pulumi_newrelic/one_dashboard_json.py +69 -63
- pulumi_newrelic/one_dashboard_raw.py +212 -206
- pulumi_newrelic/outputs.py +4936 -2234
- pulumi_newrelic/pipeline_cloud_rule.py +335 -0
- pulumi_newrelic/plugins/__init__.py +2 -1
- pulumi_newrelic/plugins/_inputs.py +519 -89
- pulumi_newrelic/plugins/application_settings.py +463 -187
- pulumi_newrelic/plugins/outputs.py +336 -74
- pulumi_newrelic/plugins/workload.py +313 -189
- pulumi_newrelic/provider.py +156 -142
- pulumi_newrelic/pulumi-plugin.json +2 -1
- pulumi_newrelic/service_level.py +263 -263
- pulumi_newrelic/synthetics/__init__.py +2 -1
- pulumi_newrelic/synthetics/_inputs.py +265 -108
- pulumi_newrelic/synthetics/alert_condition.py +170 -180
- pulumi_newrelic/synthetics/broken_links_monitor.py +297 -249
- pulumi_newrelic/synthetics/cert_check_monitor.py +306 -258
- pulumi_newrelic/synthetics/get_private_location.py +51 -47
- pulumi_newrelic/synthetics/get_secure_credential.py +39 -31
- pulumi_newrelic/synthetics/monitor.py +658 -460
- pulumi_newrelic/synthetics/multi_location_alert_condition.py +211 -205
- pulumi_newrelic/synthetics/outputs.py +92 -87
- pulumi_newrelic/synthetics/private_location.py +118 -112
- pulumi_newrelic/synthetics/script_monitor.py +613 -373
- pulumi_newrelic/synthetics/secure_credential.py +97 -95
- pulumi_newrelic/synthetics/step_monitor.py +445 -275
- pulumi_newrelic/user.py +84 -80
- pulumi_newrelic/workflow.py +336 -322
- {pulumi_newrelic-5.22.0.dist-info → pulumi_newrelic-5.58.0a1763707205.dist-info}/METADATA +7 -6
- pulumi_newrelic-5.58.0a1763707205.dist-info/RECORD +92 -0
- {pulumi_newrelic-5.22.0.dist-info → pulumi_newrelic-5.58.0a1763707205.dist-info}/WHEEL +1 -1
- pulumi_newrelic-5.22.0.dist-info/RECORD +0 -89
- {pulumi_newrelic-5.22.0.dist-info → pulumi_newrelic-5.58.0a1763707205.dist-info}/top_level.txt +0 -0
|
@@ -1,12 +1,17 @@
|
|
|
1
1
|
# coding=utf-8
|
|
2
|
-
# *** WARNING: this file was generated by
|
|
2
|
+
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
-
import
|
|
5
|
+
import builtins as _builtins
|
|
6
6
|
import warnings
|
|
7
|
+
import sys
|
|
7
8
|
import pulumi
|
|
8
9
|
import pulumi.runtime
|
|
9
10
|
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
10
15
|
from .. import _utilities
|
|
11
16
|
from . import outputs
|
|
12
17
|
from ._inputs import *
|
|
@@ -16,57 +21,66 @@ __all__ = ['MonitorArgs', 'Monitor']
|
|
|
16
21
|
@pulumi.input_type
|
|
17
22
|
class MonitorArgs:
|
|
18
23
|
def __init__(__self__, *,
|
|
19
|
-
status: pulumi.Input[str],
|
|
20
|
-
type: pulumi.Input[str],
|
|
21
|
-
account_id: Optional[pulumi.Input[
|
|
22
|
-
|
|
24
|
+
status: pulumi.Input[_builtins.str],
|
|
25
|
+
type: pulumi.Input[_builtins.str],
|
|
26
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
27
|
+
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
28
|
+
bypass_head_request: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
23
29
|
custom_headers: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]]] = None,
|
|
24
|
-
device_orientation: Optional[pulumi.Input[str]] = None,
|
|
25
|
-
device_type: Optional[pulumi.Input[str]] = None,
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
30
|
+
device_orientation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
31
|
+
device_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
32
|
+
devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
33
|
+
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
34
|
+
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
35
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
36
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
37
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
38
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
39
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
40
|
+
script_language: Optional[pulumi.Input[_builtins.str]] = None,
|
|
34
41
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]]] = None,
|
|
35
|
-
treat_redirect_as_failure: Optional[pulumi.Input[bool]] = None,
|
|
36
|
-
uri: Optional[pulumi.Input[str]] = None,
|
|
37
|
-
|
|
38
|
-
|
|
42
|
+
treat_redirect_as_failure: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
43
|
+
uri: Optional[pulumi.Input[_builtins.str]] = None,
|
|
44
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
45
|
+
validation_string: Optional[pulumi.Input[_builtins.str]] = None,
|
|
46
|
+
verify_ssl: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
39
47
|
"""
|
|
40
48
|
The set of arguments for constructing a Monitor resource.
|
|
41
|
-
:param pulumi.Input[str] status: The monitor
|
|
42
|
-
:param pulumi.Input[str] type: The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
43
|
-
:param pulumi.Input[
|
|
44
|
-
:param pulumi.Input[
|
|
49
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
50
|
+
:param pulumi.Input[_builtins.str] type: The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
51
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
52
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
53
|
+
:param pulumi.Input[_builtins.bool] bypass_head_request: Monitor should skip default HEAD request and instead use GET verb in check.
|
|
45
54
|
|
|
46
55
|
The `BROWSER` monitor type supports the following additional arguments:
|
|
47
56
|
:param pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]] custom_headers: Custom headers to use in monitor job. See Nested custom_header blocks below for details.
|
|
48
|
-
:param pulumi.Input[str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
49
|
-
|
|
50
|
-
:param pulumi.Input[
|
|
51
|
-
|
|
52
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
53
|
-
:param pulumi.Input[
|
|
54
|
-
:param pulumi.Input[str]
|
|
55
|
-
:param pulumi.Input[str]
|
|
56
|
-
:param pulumi.Input[str]
|
|
57
|
-
:param pulumi.Input[str]
|
|
57
|
+
:param pulumi.Input[_builtins.str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
58
|
+
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
59
|
+
:param pulumi.Input[_builtins.str] device_type: Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
60
|
+
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
61
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] devices: The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
62
|
+
:param pulumi.Input[_builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
63
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
64
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
65
|
+
:param pulumi.Input[_builtins.str] name: The human-readable identifier for the monitor.
|
|
66
|
+
:param pulumi.Input[_builtins.str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
67
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
68
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific version of the runtime type selected (`100`).
|
|
69
|
+
:param pulumi.Input[_builtins.str] script_language: The programing language that should execute the script.
|
|
58
70
|
:param pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
59
71
|
|
|
60
72
|
The `SIMPLE` monitor type supports the following additional arguments:
|
|
61
|
-
:param pulumi.Input[bool] treat_redirect_as_failure: Categorize redirects during a monitor job as a failure.
|
|
62
|
-
:param pulumi.Input[str] uri: The URI the monitor runs against.
|
|
63
|
-
:param pulumi.Input[str] validation_string: Validation text for monitor to search for at given URI.
|
|
64
|
-
:param pulumi.Input[bool] verify_ssl: Monitor should validate SSL certificate chain.
|
|
73
|
+
:param pulumi.Input[_builtins.bool] treat_redirect_as_failure: Categorize redirects during a monitor job as a failure.
|
|
74
|
+
:param pulumi.Input[_builtins.str] uri: The URI the monitor runs against.
|
|
75
|
+
:param pulumi.Input[_builtins.str] validation_string: Validation text for monitor to search for at given URI.
|
|
76
|
+
:param pulumi.Input[_builtins.bool] verify_ssl: Monitor should validate SSL certificate chain.
|
|
65
77
|
"""
|
|
66
78
|
pulumi.set(__self__, "status", status)
|
|
67
79
|
pulumi.set(__self__, "type", type)
|
|
68
80
|
if account_id is not None:
|
|
69
81
|
pulumi.set(__self__, "account_id", account_id)
|
|
82
|
+
if browsers is not None:
|
|
83
|
+
pulumi.set(__self__, "browsers", browsers)
|
|
70
84
|
if bypass_head_request is not None:
|
|
71
85
|
pulumi.set(__self__, "bypass_head_request", bypass_head_request)
|
|
72
86
|
if custom_headers is not None:
|
|
@@ -75,6 +89,8 @@ class MonitorArgs:
|
|
|
75
89
|
pulumi.set(__self__, "device_orientation", device_orientation)
|
|
76
90
|
if device_type is not None:
|
|
77
91
|
pulumi.set(__self__, "device_type", device_type)
|
|
92
|
+
if devices is not None:
|
|
93
|
+
pulumi.set(__self__, "devices", devices)
|
|
78
94
|
if enable_screenshot_on_failure_and_script is not None:
|
|
79
95
|
pulumi.set(__self__, "enable_screenshot_on_failure_and_script", enable_screenshot_on_failure_and_script)
|
|
80
96
|
if locations_privates is not None:
|
|
@@ -97,50 +113,64 @@ class MonitorArgs:
|
|
|
97
113
|
pulumi.set(__self__, "treat_redirect_as_failure", treat_redirect_as_failure)
|
|
98
114
|
if uri is not None:
|
|
99
115
|
pulumi.set(__self__, "uri", uri)
|
|
116
|
+
if use_unsupported_legacy_runtime is not None:
|
|
117
|
+
pulumi.set(__self__, "use_unsupported_legacy_runtime", use_unsupported_legacy_runtime)
|
|
100
118
|
if validation_string is not None:
|
|
101
119
|
pulumi.set(__self__, "validation_string", validation_string)
|
|
102
120
|
if verify_ssl is not None:
|
|
103
121
|
pulumi.set(__self__, "verify_ssl", verify_ssl)
|
|
104
122
|
|
|
105
|
-
@property
|
|
123
|
+
@_builtins.property
|
|
106
124
|
@pulumi.getter
|
|
107
|
-
def status(self) -> pulumi.Input[str]:
|
|
125
|
+
def status(self) -> pulumi.Input[_builtins.str]:
|
|
108
126
|
"""
|
|
109
|
-
The monitor
|
|
127
|
+
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
110
128
|
"""
|
|
111
129
|
return pulumi.get(self, "status")
|
|
112
130
|
|
|
113
131
|
@status.setter
|
|
114
|
-
def status(self, value: pulumi.Input[str]):
|
|
132
|
+
def status(self, value: pulumi.Input[_builtins.str]):
|
|
115
133
|
pulumi.set(self, "status", value)
|
|
116
134
|
|
|
117
|
-
@property
|
|
135
|
+
@_builtins.property
|
|
118
136
|
@pulumi.getter
|
|
119
|
-
def type(self) -> pulumi.Input[str]:
|
|
137
|
+
def type(self) -> pulumi.Input[_builtins.str]:
|
|
120
138
|
"""
|
|
121
139
|
The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
122
140
|
"""
|
|
123
141
|
return pulumi.get(self, "type")
|
|
124
142
|
|
|
125
143
|
@type.setter
|
|
126
|
-
def type(self, value: pulumi.Input[str]):
|
|
144
|
+
def type(self, value: pulumi.Input[_builtins.str]):
|
|
127
145
|
pulumi.set(self, "type", value)
|
|
128
146
|
|
|
129
|
-
@property
|
|
147
|
+
@_builtins.property
|
|
130
148
|
@pulumi.getter(name="accountId")
|
|
131
|
-
def account_id(self) -> Optional[pulumi.Input[
|
|
149
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
132
150
|
"""
|
|
133
151
|
The account in which the Synthetics monitor will be created.
|
|
134
152
|
"""
|
|
135
153
|
return pulumi.get(self, "account_id")
|
|
136
154
|
|
|
137
155
|
@account_id.setter
|
|
138
|
-
def account_id(self, value: Optional[pulumi.Input[
|
|
156
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
139
157
|
pulumi.set(self, "account_id", value)
|
|
140
158
|
|
|
141
|
-
@property
|
|
159
|
+
@_builtins.property
|
|
160
|
+
@pulumi.getter
|
|
161
|
+
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
162
|
+
"""
|
|
163
|
+
The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
164
|
+
"""
|
|
165
|
+
return pulumi.get(self, "browsers")
|
|
166
|
+
|
|
167
|
+
@browsers.setter
|
|
168
|
+
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
169
|
+
pulumi.set(self, "browsers", value)
|
|
170
|
+
|
|
171
|
+
@_builtins.property
|
|
142
172
|
@pulumi.getter(name="bypassHeadRequest")
|
|
143
|
-
def bypass_head_request(self) -> Optional[pulumi.Input[bool]]:
|
|
173
|
+
def bypass_head_request(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
144
174
|
"""
|
|
145
175
|
Monitor should skip default HEAD request and instead use GET verb in check.
|
|
146
176
|
|
|
@@ -149,10 +179,10 @@ class MonitorArgs:
|
|
|
149
179
|
return pulumi.get(self, "bypass_head_request")
|
|
150
180
|
|
|
151
181
|
@bypass_head_request.setter
|
|
152
|
-
def bypass_head_request(self, value: Optional[pulumi.Input[bool]]):
|
|
182
|
+
def bypass_head_request(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
153
183
|
pulumi.set(self, "bypass_head_request", value)
|
|
154
184
|
|
|
155
|
-
@property
|
|
185
|
+
@_builtins.property
|
|
156
186
|
@pulumi.getter(name="customHeaders")
|
|
157
187
|
def custom_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]]]:
|
|
158
188
|
"""
|
|
@@ -164,127 +194,141 @@ class MonitorArgs:
|
|
|
164
194
|
def custom_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]]]):
|
|
165
195
|
pulumi.set(self, "custom_headers", value)
|
|
166
196
|
|
|
167
|
-
@property
|
|
197
|
+
@_builtins.property
|
|
168
198
|
@pulumi.getter(name="deviceOrientation")
|
|
169
|
-
def device_orientation(self) -> Optional[pulumi.Input[str]]:
|
|
199
|
+
def device_orientation(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
170
200
|
"""
|
|
171
|
-
Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
201
|
+
Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
202
|
+
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
172
203
|
"""
|
|
173
204
|
return pulumi.get(self, "device_orientation")
|
|
174
205
|
|
|
175
206
|
@device_orientation.setter
|
|
176
|
-
def device_orientation(self, value: Optional[pulumi.Input[str]]):
|
|
207
|
+
def device_orientation(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
177
208
|
pulumi.set(self, "device_orientation", value)
|
|
178
209
|
|
|
179
|
-
@property
|
|
210
|
+
@_builtins.property
|
|
180
211
|
@pulumi.getter(name="deviceType")
|
|
181
|
-
def device_type(self) -> Optional[pulumi.Input[str]]:
|
|
212
|
+
def device_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
182
213
|
"""
|
|
183
|
-
Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
214
|
+
Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
215
|
+
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
184
216
|
"""
|
|
185
217
|
return pulumi.get(self, "device_type")
|
|
186
218
|
|
|
187
219
|
@device_type.setter
|
|
188
|
-
def device_type(self, value: Optional[pulumi.Input[str]]):
|
|
220
|
+
def device_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
189
221
|
pulumi.set(self, "device_type", value)
|
|
190
222
|
|
|
191
|
-
@property
|
|
223
|
+
@_builtins.property
|
|
224
|
+
@pulumi.getter
|
|
225
|
+
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
226
|
+
"""
|
|
227
|
+
The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
228
|
+
"""
|
|
229
|
+
return pulumi.get(self, "devices")
|
|
230
|
+
|
|
231
|
+
@devices.setter
|
|
232
|
+
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
233
|
+
pulumi.set(self, "devices", value)
|
|
234
|
+
|
|
235
|
+
@_builtins.property
|
|
192
236
|
@pulumi.getter(name="enableScreenshotOnFailureAndScript")
|
|
193
|
-
def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[bool]]:
|
|
237
|
+
def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
194
238
|
"""
|
|
195
239
|
Capture a screenshot during job execution.
|
|
196
240
|
"""
|
|
197
241
|
return pulumi.get(self, "enable_screenshot_on_failure_and_script")
|
|
198
242
|
|
|
199
243
|
@enable_screenshot_on_failure_and_script.setter
|
|
200
|
-
def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[bool]]):
|
|
244
|
+
def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
201
245
|
pulumi.set(self, "enable_screenshot_on_failure_and_script", value)
|
|
202
246
|
|
|
203
|
-
@property
|
|
247
|
+
@_builtins.property
|
|
204
248
|
@pulumi.getter(name="locationsPrivates")
|
|
205
|
-
def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
249
|
+
def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
206
250
|
"""
|
|
207
251
|
The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
208
252
|
"""
|
|
209
253
|
return pulumi.get(self, "locations_privates")
|
|
210
254
|
|
|
211
255
|
@locations_privates.setter
|
|
212
|
-
def locations_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
256
|
+
def locations_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
213
257
|
pulumi.set(self, "locations_privates", value)
|
|
214
258
|
|
|
215
|
-
@property
|
|
259
|
+
@_builtins.property
|
|
216
260
|
@pulumi.getter(name="locationsPublics")
|
|
217
|
-
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
261
|
+
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
218
262
|
"""
|
|
219
|
-
The location the monitor will run from.
|
|
263
|
+
The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
220
264
|
"""
|
|
221
265
|
return pulumi.get(self, "locations_publics")
|
|
222
266
|
|
|
223
267
|
@locations_publics.setter
|
|
224
|
-
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
268
|
+
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
225
269
|
pulumi.set(self, "locations_publics", value)
|
|
226
270
|
|
|
227
|
-
@property
|
|
271
|
+
@_builtins.property
|
|
228
272
|
@pulumi.getter
|
|
229
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
273
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
230
274
|
"""
|
|
231
275
|
The human-readable identifier for the monitor.
|
|
232
276
|
"""
|
|
233
277
|
return pulumi.get(self, "name")
|
|
234
278
|
|
|
235
279
|
@name.setter
|
|
236
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
280
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
237
281
|
pulumi.set(self, "name", value)
|
|
238
282
|
|
|
239
|
-
@property
|
|
283
|
+
@_builtins.property
|
|
240
284
|
@pulumi.getter
|
|
241
|
-
def period(self) -> Optional[pulumi.Input[str]]:
|
|
285
|
+
def period(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
242
286
|
"""
|
|
243
|
-
The interval at which this monitor should run. Valid values are EVERY_MINUTE
|
|
287
|
+
The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
244
288
|
"""
|
|
245
289
|
return pulumi.get(self, "period")
|
|
246
290
|
|
|
247
291
|
@period.setter
|
|
248
|
-
def period(self, value: Optional[pulumi.Input[str]]):
|
|
292
|
+
def period(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
249
293
|
pulumi.set(self, "period", value)
|
|
250
294
|
|
|
251
|
-
@property
|
|
295
|
+
@_builtins.property
|
|
252
296
|
@pulumi.getter(name="runtimeType")
|
|
253
|
-
def runtime_type(self) -> Optional[pulumi.Input[str]]:
|
|
297
|
+
def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
254
298
|
"""
|
|
255
|
-
The runtime
|
|
299
|
+
The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
256
300
|
"""
|
|
257
301
|
return pulumi.get(self, "runtime_type")
|
|
258
302
|
|
|
259
303
|
@runtime_type.setter
|
|
260
|
-
def runtime_type(self, value: Optional[pulumi.Input[str]]):
|
|
304
|
+
def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
261
305
|
pulumi.set(self, "runtime_type", value)
|
|
262
306
|
|
|
263
|
-
@property
|
|
307
|
+
@_builtins.property
|
|
264
308
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
265
|
-
def runtime_type_version(self) -> Optional[pulumi.Input[str]]:
|
|
309
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
266
310
|
"""
|
|
267
|
-
The
|
|
311
|
+
The specific version of the runtime type selected (`100`).
|
|
268
312
|
"""
|
|
269
313
|
return pulumi.get(self, "runtime_type_version")
|
|
270
314
|
|
|
271
315
|
@runtime_type_version.setter
|
|
272
|
-
def runtime_type_version(self, value: Optional[pulumi.Input[str]]):
|
|
316
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
273
317
|
pulumi.set(self, "runtime_type_version", value)
|
|
274
318
|
|
|
275
|
-
@property
|
|
319
|
+
@_builtins.property
|
|
276
320
|
@pulumi.getter(name="scriptLanguage")
|
|
277
|
-
def script_language(self) -> Optional[pulumi.Input[str]]:
|
|
321
|
+
def script_language(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
278
322
|
"""
|
|
279
323
|
The programing language that should execute the script.
|
|
280
324
|
"""
|
|
281
325
|
return pulumi.get(self, "script_language")
|
|
282
326
|
|
|
283
327
|
@script_language.setter
|
|
284
|
-
def script_language(self, value: Optional[pulumi.Input[str]]):
|
|
328
|
+
def script_language(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
285
329
|
pulumi.set(self, "script_language", value)
|
|
286
330
|
|
|
287
|
-
@property
|
|
331
|
+
@_builtins.property
|
|
288
332
|
@pulumi.getter
|
|
289
333
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]]]:
|
|
290
334
|
"""
|
|
@@ -298,109 +342,129 @@ class MonitorArgs:
|
|
|
298
342
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]]]):
|
|
299
343
|
pulumi.set(self, "tags", value)
|
|
300
344
|
|
|
301
|
-
@property
|
|
345
|
+
@_builtins.property
|
|
302
346
|
@pulumi.getter(name="treatRedirectAsFailure")
|
|
303
|
-
def treat_redirect_as_failure(self) -> Optional[pulumi.Input[bool]]:
|
|
347
|
+
def treat_redirect_as_failure(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
304
348
|
"""
|
|
305
349
|
Categorize redirects during a monitor job as a failure.
|
|
306
350
|
"""
|
|
307
351
|
return pulumi.get(self, "treat_redirect_as_failure")
|
|
308
352
|
|
|
309
353
|
@treat_redirect_as_failure.setter
|
|
310
|
-
def treat_redirect_as_failure(self, value: Optional[pulumi.Input[bool]]):
|
|
354
|
+
def treat_redirect_as_failure(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
311
355
|
pulumi.set(self, "treat_redirect_as_failure", value)
|
|
312
356
|
|
|
313
|
-
@property
|
|
357
|
+
@_builtins.property
|
|
314
358
|
@pulumi.getter
|
|
315
|
-
def uri(self) -> Optional[pulumi.Input[str]]:
|
|
359
|
+
def uri(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
316
360
|
"""
|
|
317
361
|
The URI the monitor runs against.
|
|
318
362
|
"""
|
|
319
363
|
return pulumi.get(self, "uri")
|
|
320
364
|
|
|
321
365
|
@uri.setter
|
|
322
|
-
def uri(self, value: Optional[pulumi.Input[str]]):
|
|
366
|
+
def uri(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
323
367
|
pulumi.set(self, "uri", value)
|
|
324
368
|
|
|
325
|
-
@property
|
|
369
|
+
@_builtins.property
|
|
370
|
+
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
371
|
+
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
372
|
+
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
373
|
+
|
|
374
|
+
@use_unsupported_legacy_runtime.setter
|
|
375
|
+
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
376
|
+
pulumi.set(self, "use_unsupported_legacy_runtime", value)
|
|
377
|
+
|
|
378
|
+
@_builtins.property
|
|
326
379
|
@pulumi.getter(name="validationString")
|
|
327
|
-
def validation_string(self) -> Optional[pulumi.Input[str]]:
|
|
380
|
+
def validation_string(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
328
381
|
"""
|
|
329
382
|
Validation text for monitor to search for at given URI.
|
|
330
383
|
"""
|
|
331
384
|
return pulumi.get(self, "validation_string")
|
|
332
385
|
|
|
333
386
|
@validation_string.setter
|
|
334
|
-
def validation_string(self, value: Optional[pulumi.Input[str]]):
|
|
387
|
+
def validation_string(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
335
388
|
pulumi.set(self, "validation_string", value)
|
|
336
389
|
|
|
337
|
-
@property
|
|
390
|
+
@_builtins.property
|
|
338
391
|
@pulumi.getter(name="verifySsl")
|
|
339
|
-
def verify_ssl(self) -> Optional[pulumi.Input[bool]]:
|
|
392
|
+
def verify_ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
340
393
|
"""
|
|
341
394
|
Monitor should validate SSL certificate chain.
|
|
342
395
|
"""
|
|
343
396
|
return pulumi.get(self, "verify_ssl")
|
|
344
397
|
|
|
345
398
|
@verify_ssl.setter
|
|
346
|
-
def verify_ssl(self, value: Optional[pulumi.Input[bool]]):
|
|
399
|
+
def verify_ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
347
400
|
pulumi.set(self, "verify_ssl", value)
|
|
348
401
|
|
|
349
402
|
|
|
350
403
|
@pulumi.input_type
|
|
351
404
|
class _MonitorState:
|
|
352
405
|
def __init__(__self__, *,
|
|
353
|
-
account_id: Optional[pulumi.Input[
|
|
354
|
-
|
|
406
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
407
|
+
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
408
|
+
bypass_head_request: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
355
409
|
custom_headers: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]]] = None,
|
|
356
|
-
device_orientation: Optional[pulumi.Input[str]] = None,
|
|
357
|
-
device_type: Optional[pulumi.Input[str]] = None,
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
410
|
+
device_orientation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
411
|
+
device_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
412
|
+
devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
413
|
+
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
414
|
+
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
415
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
416
|
+
monitor_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
417
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
418
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
419
|
+
period_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
420
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
421
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
422
|
+
script_language: Optional[pulumi.Input[_builtins.str]] = None,
|
|
423
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
368
424
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]]] = None,
|
|
369
|
-
treat_redirect_as_failure: Optional[pulumi.Input[bool]] = None,
|
|
370
|
-
type: Optional[pulumi.Input[str]] = None,
|
|
371
|
-
uri: Optional[pulumi.Input[str]] = None,
|
|
372
|
-
|
|
373
|
-
|
|
425
|
+
treat_redirect_as_failure: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
426
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
427
|
+
uri: Optional[pulumi.Input[_builtins.str]] = None,
|
|
428
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
429
|
+
validation_string: Optional[pulumi.Input[_builtins.str]] = None,
|
|
430
|
+
verify_ssl: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
374
431
|
"""
|
|
375
432
|
Input properties used for looking up and filtering Monitor resources.
|
|
376
|
-
:param pulumi.Input[
|
|
377
|
-
:param pulumi.Input[
|
|
433
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
434
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
435
|
+
:param pulumi.Input[_builtins.bool] bypass_head_request: Monitor should skip default HEAD request and instead use GET verb in check.
|
|
378
436
|
|
|
379
437
|
The `BROWSER` monitor type supports the following additional arguments:
|
|
380
438
|
:param pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]] custom_headers: Custom headers to use in monitor job. See Nested custom_header blocks below for details.
|
|
381
|
-
:param pulumi.Input[str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
382
|
-
|
|
383
|
-
:param pulumi.Input[
|
|
384
|
-
|
|
385
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
386
|
-
:param pulumi.Input[
|
|
387
|
-
:param pulumi.Input[str]
|
|
388
|
-
:param pulumi.Input[
|
|
389
|
-
:param pulumi.Input[str]
|
|
390
|
-
:param pulumi.Input[str]
|
|
391
|
-
:param pulumi.Input[str]
|
|
392
|
-
:param pulumi.Input[
|
|
439
|
+
:param pulumi.Input[_builtins.str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
440
|
+
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
441
|
+
:param pulumi.Input[_builtins.str] device_type: Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
442
|
+
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
443
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] devices: The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
444
|
+
:param pulumi.Input[_builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
445
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
446
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
447
|
+
:param pulumi.Input[_builtins.str] monitor_id: The monitor id of the Synthetics monitor (not to be confused with the GUID of the monitor).
|
|
448
|
+
:param pulumi.Input[_builtins.str] name: The human-readable identifier for the monitor.
|
|
449
|
+
:param pulumi.Input[_builtins.str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
450
|
+
:param pulumi.Input[_builtins.int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
|
|
451
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
452
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific version of the runtime type selected (`100`).
|
|
453
|
+
:param pulumi.Input[_builtins.str] script_language: The programing language that should execute the script.
|
|
454
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
393
455
|
:param pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
394
456
|
|
|
395
457
|
The `SIMPLE` monitor type supports the following additional arguments:
|
|
396
|
-
:param pulumi.Input[bool] treat_redirect_as_failure: Categorize redirects during a monitor job as a failure.
|
|
397
|
-
:param pulumi.Input[str] type: The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
398
|
-
:param pulumi.Input[str] uri: The URI the monitor runs against.
|
|
399
|
-
:param pulumi.Input[str] validation_string: Validation text for monitor to search for at given URI.
|
|
400
|
-
:param pulumi.Input[bool] verify_ssl: Monitor should validate SSL certificate chain.
|
|
458
|
+
:param pulumi.Input[_builtins.bool] treat_redirect_as_failure: Categorize redirects during a monitor job as a failure.
|
|
459
|
+
:param pulumi.Input[_builtins.str] type: The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
460
|
+
:param pulumi.Input[_builtins.str] uri: The URI the monitor runs against.
|
|
461
|
+
:param pulumi.Input[_builtins.str] validation_string: Validation text for monitor to search for at given URI.
|
|
462
|
+
:param pulumi.Input[_builtins.bool] verify_ssl: Monitor should validate SSL certificate chain.
|
|
401
463
|
"""
|
|
402
464
|
if account_id is not None:
|
|
403
465
|
pulumi.set(__self__, "account_id", account_id)
|
|
466
|
+
if browsers is not None:
|
|
467
|
+
pulumi.set(__self__, "browsers", browsers)
|
|
404
468
|
if bypass_head_request is not None:
|
|
405
469
|
pulumi.set(__self__, "bypass_head_request", bypass_head_request)
|
|
406
470
|
if custom_headers is not None:
|
|
@@ -409,12 +473,16 @@ class _MonitorState:
|
|
|
409
473
|
pulumi.set(__self__, "device_orientation", device_orientation)
|
|
410
474
|
if device_type is not None:
|
|
411
475
|
pulumi.set(__self__, "device_type", device_type)
|
|
476
|
+
if devices is not None:
|
|
477
|
+
pulumi.set(__self__, "devices", devices)
|
|
412
478
|
if enable_screenshot_on_failure_and_script is not None:
|
|
413
479
|
pulumi.set(__self__, "enable_screenshot_on_failure_and_script", enable_screenshot_on_failure_and_script)
|
|
414
480
|
if locations_privates is not None:
|
|
415
481
|
pulumi.set(__self__, "locations_privates", locations_privates)
|
|
416
482
|
if locations_publics is not None:
|
|
417
483
|
pulumi.set(__self__, "locations_publics", locations_publics)
|
|
484
|
+
if monitor_id is not None:
|
|
485
|
+
pulumi.set(__self__, "monitor_id", monitor_id)
|
|
418
486
|
if name is not None:
|
|
419
487
|
pulumi.set(__self__, "name", name)
|
|
420
488
|
if period is not None:
|
|
@@ -437,26 +505,40 @@ class _MonitorState:
|
|
|
437
505
|
pulumi.set(__self__, "type", type)
|
|
438
506
|
if uri is not None:
|
|
439
507
|
pulumi.set(__self__, "uri", uri)
|
|
508
|
+
if use_unsupported_legacy_runtime is not None:
|
|
509
|
+
pulumi.set(__self__, "use_unsupported_legacy_runtime", use_unsupported_legacy_runtime)
|
|
440
510
|
if validation_string is not None:
|
|
441
511
|
pulumi.set(__self__, "validation_string", validation_string)
|
|
442
512
|
if verify_ssl is not None:
|
|
443
513
|
pulumi.set(__self__, "verify_ssl", verify_ssl)
|
|
444
514
|
|
|
445
|
-
@property
|
|
515
|
+
@_builtins.property
|
|
446
516
|
@pulumi.getter(name="accountId")
|
|
447
|
-
def account_id(self) -> Optional[pulumi.Input[
|
|
517
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
448
518
|
"""
|
|
449
519
|
The account in which the Synthetics monitor will be created.
|
|
450
520
|
"""
|
|
451
521
|
return pulumi.get(self, "account_id")
|
|
452
522
|
|
|
453
523
|
@account_id.setter
|
|
454
|
-
def account_id(self, value: Optional[pulumi.Input[
|
|
524
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
455
525
|
pulumi.set(self, "account_id", value)
|
|
456
526
|
|
|
457
|
-
@property
|
|
527
|
+
@_builtins.property
|
|
528
|
+
@pulumi.getter
|
|
529
|
+
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
530
|
+
"""
|
|
531
|
+
The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
532
|
+
"""
|
|
533
|
+
return pulumi.get(self, "browsers")
|
|
534
|
+
|
|
535
|
+
@browsers.setter
|
|
536
|
+
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
537
|
+
pulumi.set(self, "browsers", value)
|
|
538
|
+
|
|
539
|
+
@_builtins.property
|
|
458
540
|
@pulumi.getter(name="bypassHeadRequest")
|
|
459
|
-
def bypass_head_request(self) -> Optional[pulumi.Input[bool]]:
|
|
541
|
+
def bypass_head_request(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
460
542
|
"""
|
|
461
543
|
Monitor should skip default HEAD request and instead use GET verb in check.
|
|
462
544
|
|
|
@@ -465,10 +547,10 @@ class _MonitorState:
|
|
|
465
547
|
return pulumi.get(self, "bypass_head_request")
|
|
466
548
|
|
|
467
549
|
@bypass_head_request.setter
|
|
468
|
-
def bypass_head_request(self, value: Optional[pulumi.Input[bool]]):
|
|
550
|
+
def bypass_head_request(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
469
551
|
pulumi.set(self, "bypass_head_request", value)
|
|
470
552
|
|
|
471
|
-
@property
|
|
553
|
+
@_builtins.property
|
|
472
554
|
@pulumi.getter(name="customHeaders")
|
|
473
555
|
def custom_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]]]:
|
|
474
556
|
"""
|
|
@@ -480,151 +562,177 @@ class _MonitorState:
|
|
|
480
562
|
def custom_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]]]):
|
|
481
563
|
pulumi.set(self, "custom_headers", value)
|
|
482
564
|
|
|
483
|
-
@property
|
|
565
|
+
@_builtins.property
|
|
484
566
|
@pulumi.getter(name="deviceOrientation")
|
|
485
|
-
def device_orientation(self) -> Optional[pulumi.Input[str]]:
|
|
567
|
+
def device_orientation(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
486
568
|
"""
|
|
487
|
-
Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
569
|
+
Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
570
|
+
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
488
571
|
"""
|
|
489
572
|
return pulumi.get(self, "device_orientation")
|
|
490
573
|
|
|
491
574
|
@device_orientation.setter
|
|
492
|
-
def device_orientation(self, value: Optional[pulumi.Input[str]]):
|
|
575
|
+
def device_orientation(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
493
576
|
pulumi.set(self, "device_orientation", value)
|
|
494
577
|
|
|
495
|
-
@property
|
|
578
|
+
@_builtins.property
|
|
496
579
|
@pulumi.getter(name="deviceType")
|
|
497
|
-
def device_type(self) -> Optional[pulumi.Input[str]]:
|
|
580
|
+
def device_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
498
581
|
"""
|
|
499
|
-
Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
582
|
+
Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
583
|
+
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
500
584
|
"""
|
|
501
585
|
return pulumi.get(self, "device_type")
|
|
502
586
|
|
|
503
587
|
@device_type.setter
|
|
504
|
-
def device_type(self, value: Optional[pulumi.Input[str]]):
|
|
588
|
+
def device_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
505
589
|
pulumi.set(self, "device_type", value)
|
|
506
590
|
|
|
507
|
-
@property
|
|
591
|
+
@_builtins.property
|
|
592
|
+
@pulumi.getter
|
|
593
|
+
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
594
|
+
"""
|
|
595
|
+
The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
596
|
+
"""
|
|
597
|
+
return pulumi.get(self, "devices")
|
|
598
|
+
|
|
599
|
+
@devices.setter
|
|
600
|
+
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
601
|
+
pulumi.set(self, "devices", value)
|
|
602
|
+
|
|
603
|
+
@_builtins.property
|
|
508
604
|
@pulumi.getter(name="enableScreenshotOnFailureAndScript")
|
|
509
|
-
def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[bool]]:
|
|
605
|
+
def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
510
606
|
"""
|
|
511
607
|
Capture a screenshot during job execution.
|
|
512
608
|
"""
|
|
513
609
|
return pulumi.get(self, "enable_screenshot_on_failure_and_script")
|
|
514
610
|
|
|
515
611
|
@enable_screenshot_on_failure_and_script.setter
|
|
516
|
-
def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[bool]]):
|
|
612
|
+
def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
517
613
|
pulumi.set(self, "enable_screenshot_on_failure_and_script", value)
|
|
518
614
|
|
|
519
|
-
@property
|
|
615
|
+
@_builtins.property
|
|
520
616
|
@pulumi.getter(name="locationsPrivates")
|
|
521
|
-
def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
617
|
+
def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
522
618
|
"""
|
|
523
619
|
The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
524
620
|
"""
|
|
525
621
|
return pulumi.get(self, "locations_privates")
|
|
526
622
|
|
|
527
623
|
@locations_privates.setter
|
|
528
|
-
def locations_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
624
|
+
def locations_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
529
625
|
pulumi.set(self, "locations_privates", value)
|
|
530
626
|
|
|
531
|
-
@property
|
|
627
|
+
@_builtins.property
|
|
532
628
|
@pulumi.getter(name="locationsPublics")
|
|
533
|
-
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
629
|
+
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
534
630
|
"""
|
|
535
|
-
The location the monitor will run from.
|
|
631
|
+
The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
536
632
|
"""
|
|
537
633
|
return pulumi.get(self, "locations_publics")
|
|
538
634
|
|
|
539
635
|
@locations_publics.setter
|
|
540
|
-
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
636
|
+
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
541
637
|
pulumi.set(self, "locations_publics", value)
|
|
542
638
|
|
|
543
|
-
@property
|
|
639
|
+
@_builtins.property
|
|
640
|
+
@pulumi.getter(name="monitorId")
|
|
641
|
+
def monitor_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
642
|
+
"""
|
|
643
|
+
The monitor id of the Synthetics monitor (not to be confused with the GUID of the monitor).
|
|
644
|
+
"""
|
|
645
|
+
return pulumi.get(self, "monitor_id")
|
|
646
|
+
|
|
647
|
+
@monitor_id.setter
|
|
648
|
+
def monitor_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
649
|
+
pulumi.set(self, "monitor_id", value)
|
|
650
|
+
|
|
651
|
+
@_builtins.property
|
|
544
652
|
@pulumi.getter
|
|
545
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
653
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
546
654
|
"""
|
|
547
655
|
The human-readable identifier for the monitor.
|
|
548
656
|
"""
|
|
549
657
|
return pulumi.get(self, "name")
|
|
550
658
|
|
|
551
659
|
@name.setter
|
|
552
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
660
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
553
661
|
pulumi.set(self, "name", value)
|
|
554
662
|
|
|
555
|
-
@property
|
|
663
|
+
@_builtins.property
|
|
556
664
|
@pulumi.getter
|
|
557
|
-
def period(self) -> Optional[pulumi.Input[str]]:
|
|
665
|
+
def period(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
558
666
|
"""
|
|
559
|
-
The interval at which this monitor should run. Valid values are EVERY_MINUTE
|
|
667
|
+
The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
560
668
|
"""
|
|
561
669
|
return pulumi.get(self, "period")
|
|
562
670
|
|
|
563
671
|
@period.setter
|
|
564
|
-
def period(self, value: Optional[pulumi.Input[str]]):
|
|
672
|
+
def period(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
565
673
|
pulumi.set(self, "period", value)
|
|
566
674
|
|
|
567
|
-
@property
|
|
675
|
+
@_builtins.property
|
|
568
676
|
@pulumi.getter(name="periodInMinutes")
|
|
569
|
-
def period_in_minutes(self) -> Optional[pulumi.Input[int]]:
|
|
677
|
+
def period_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
570
678
|
"""
|
|
571
679
|
The interval in minutes at which Synthetic monitor should run.
|
|
572
680
|
"""
|
|
573
681
|
return pulumi.get(self, "period_in_minutes")
|
|
574
682
|
|
|
575
683
|
@period_in_minutes.setter
|
|
576
|
-
def period_in_minutes(self, value: Optional[pulumi.Input[int]]):
|
|
684
|
+
def period_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
577
685
|
pulumi.set(self, "period_in_minutes", value)
|
|
578
686
|
|
|
579
|
-
@property
|
|
687
|
+
@_builtins.property
|
|
580
688
|
@pulumi.getter(name="runtimeType")
|
|
581
|
-
def runtime_type(self) -> Optional[pulumi.Input[str]]:
|
|
689
|
+
def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
582
690
|
"""
|
|
583
|
-
The runtime
|
|
691
|
+
The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
584
692
|
"""
|
|
585
693
|
return pulumi.get(self, "runtime_type")
|
|
586
694
|
|
|
587
695
|
@runtime_type.setter
|
|
588
|
-
def runtime_type(self, value: Optional[pulumi.Input[str]]):
|
|
696
|
+
def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
589
697
|
pulumi.set(self, "runtime_type", value)
|
|
590
698
|
|
|
591
|
-
@property
|
|
699
|
+
@_builtins.property
|
|
592
700
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
593
|
-
def runtime_type_version(self) -> Optional[pulumi.Input[str]]:
|
|
701
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
594
702
|
"""
|
|
595
|
-
The
|
|
703
|
+
The specific version of the runtime type selected (`100`).
|
|
596
704
|
"""
|
|
597
705
|
return pulumi.get(self, "runtime_type_version")
|
|
598
706
|
|
|
599
707
|
@runtime_type_version.setter
|
|
600
|
-
def runtime_type_version(self, value: Optional[pulumi.Input[str]]):
|
|
708
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
601
709
|
pulumi.set(self, "runtime_type_version", value)
|
|
602
710
|
|
|
603
|
-
@property
|
|
711
|
+
@_builtins.property
|
|
604
712
|
@pulumi.getter(name="scriptLanguage")
|
|
605
|
-
def script_language(self) -> Optional[pulumi.Input[str]]:
|
|
713
|
+
def script_language(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
606
714
|
"""
|
|
607
715
|
The programing language that should execute the script.
|
|
608
716
|
"""
|
|
609
717
|
return pulumi.get(self, "script_language")
|
|
610
718
|
|
|
611
719
|
@script_language.setter
|
|
612
|
-
def script_language(self, value: Optional[pulumi.Input[str]]):
|
|
720
|
+
def script_language(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
613
721
|
pulumi.set(self, "script_language", value)
|
|
614
722
|
|
|
615
|
-
@property
|
|
723
|
+
@_builtins.property
|
|
616
724
|
@pulumi.getter
|
|
617
|
-
def status(self) -> Optional[pulumi.Input[str]]:
|
|
725
|
+
def status(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
618
726
|
"""
|
|
619
|
-
The monitor
|
|
727
|
+
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
620
728
|
"""
|
|
621
729
|
return pulumi.get(self, "status")
|
|
622
730
|
|
|
623
731
|
@status.setter
|
|
624
|
-
def status(self, value: Optional[pulumi.Input[str]]):
|
|
732
|
+
def status(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
625
733
|
pulumi.set(self, "status", value)
|
|
626
734
|
|
|
627
|
-
@property
|
|
735
|
+
@_builtins.property
|
|
628
736
|
@pulumi.getter
|
|
629
737
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]]]:
|
|
630
738
|
"""
|
|
@@ -638,149 +746,167 @@ class _MonitorState:
|
|
|
638
746
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]]]):
|
|
639
747
|
pulumi.set(self, "tags", value)
|
|
640
748
|
|
|
641
|
-
@property
|
|
749
|
+
@_builtins.property
|
|
642
750
|
@pulumi.getter(name="treatRedirectAsFailure")
|
|
643
|
-
def treat_redirect_as_failure(self) -> Optional[pulumi.Input[bool]]:
|
|
751
|
+
def treat_redirect_as_failure(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
644
752
|
"""
|
|
645
753
|
Categorize redirects during a monitor job as a failure.
|
|
646
754
|
"""
|
|
647
755
|
return pulumi.get(self, "treat_redirect_as_failure")
|
|
648
756
|
|
|
649
757
|
@treat_redirect_as_failure.setter
|
|
650
|
-
def treat_redirect_as_failure(self, value: Optional[pulumi.Input[bool]]):
|
|
758
|
+
def treat_redirect_as_failure(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
651
759
|
pulumi.set(self, "treat_redirect_as_failure", value)
|
|
652
760
|
|
|
653
|
-
@property
|
|
761
|
+
@_builtins.property
|
|
654
762
|
@pulumi.getter
|
|
655
|
-
def type(self) -> Optional[pulumi.Input[str]]:
|
|
763
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
656
764
|
"""
|
|
657
765
|
The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
658
766
|
"""
|
|
659
767
|
return pulumi.get(self, "type")
|
|
660
768
|
|
|
661
769
|
@type.setter
|
|
662
|
-
def type(self, value: Optional[pulumi.Input[str]]):
|
|
770
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
663
771
|
pulumi.set(self, "type", value)
|
|
664
772
|
|
|
665
|
-
@property
|
|
773
|
+
@_builtins.property
|
|
666
774
|
@pulumi.getter
|
|
667
|
-
def uri(self) -> Optional[pulumi.Input[str]]:
|
|
775
|
+
def uri(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
668
776
|
"""
|
|
669
777
|
The URI the monitor runs against.
|
|
670
778
|
"""
|
|
671
779
|
return pulumi.get(self, "uri")
|
|
672
780
|
|
|
673
781
|
@uri.setter
|
|
674
|
-
def uri(self, value: Optional[pulumi.Input[str]]):
|
|
782
|
+
def uri(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
675
783
|
pulumi.set(self, "uri", value)
|
|
676
784
|
|
|
677
|
-
@property
|
|
785
|
+
@_builtins.property
|
|
786
|
+
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
787
|
+
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
788
|
+
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
789
|
+
|
|
790
|
+
@use_unsupported_legacy_runtime.setter
|
|
791
|
+
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
792
|
+
pulumi.set(self, "use_unsupported_legacy_runtime", value)
|
|
793
|
+
|
|
794
|
+
@_builtins.property
|
|
678
795
|
@pulumi.getter(name="validationString")
|
|
679
|
-
def validation_string(self) -> Optional[pulumi.Input[str]]:
|
|
796
|
+
def validation_string(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
680
797
|
"""
|
|
681
798
|
Validation text for monitor to search for at given URI.
|
|
682
799
|
"""
|
|
683
800
|
return pulumi.get(self, "validation_string")
|
|
684
801
|
|
|
685
802
|
@validation_string.setter
|
|
686
|
-
def validation_string(self, value: Optional[pulumi.Input[str]]):
|
|
803
|
+
def validation_string(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
687
804
|
pulumi.set(self, "validation_string", value)
|
|
688
805
|
|
|
689
|
-
@property
|
|
806
|
+
@_builtins.property
|
|
690
807
|
@pulumi.getter(name="verifySsl")
|
|
691
|
-
def verify_ssl(self) -> Optional[pulumi.Input[bool]]:
|
|
808
|
+
def verify_ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
692
809
|
"""
|
|
693
810
|
Monitor should validate SSL certificate chain.
|
|
694
811
|
"""
|
|
695
812
|
return pulumi.get(self, "verify_ssl")
|
|
696
813
|
|
|
697
814
|
@verify_ssl.setter
|
|
698
|
-
def verify_ssl(self, value: Optional[pulumi.Input[bool]]):
|
|
815
|
+
def verify_ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
699
816
|
pulumi.set(self, "verify_ssl", value)
|
|
700
817
|
|
|
701
818
|
|
|
819
|
+
@pulumi.type_token("newrelic:synthetics/monitor:Monitor")
|
|
702
820
|
class Monitor(pulumi.CustomResource):
|
|
703
821
|
@overload
|
|
704
822
|
def __init__(__self__,
|
|
705
823
|
resource_name: str,
|
|
706
824
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
707
|
-
account_id: Optional[pulumi.Input[
|
|
708
|
-
|
|
709
|
-
|
|
710
|
-
|
|
711
|
-
|
|
712
|
-
|
|
713
|
-
|
|
714
|
-
|
|
715
|
-
|
|
716
|
-
|
|
717
|
-
|
|
718
|
-
|
|
719
|
-
|
|
720
|
-
|
|
721
|
-
|
|
722
|
-
|
|
723
|
-
|
|
724
|
-
|
|
725
|
-
|
|
726
|
-
|
|
825
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
826
|
+
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
827
|
+
bypass_head_request: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
828
|
+
custom_headers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MonitorCustomHeaderArgs', 'MonitorCustomHeaderArgsDict']]]]] = None,
|
|
829
|
+
device_orientation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
830
|
+
device_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
831
|
+
devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
832
|
+
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
833
|
+
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
834
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
835
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
836
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
837
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
838
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
839
|
+
script_language: Optional[pulumi.Input[_builtins.str]] = None,
|
|
840
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
841
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MonitorTagArgs', 'MonitorTagArgsDict']]]]] = None,
|
|
842
|
+
treat_redirect_as_failure: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
843
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
844
|
+
uri: Optional[pulumi.Input[_builtins.str]] = None,
|
|
845
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
846
|
+
validation_string: Optional[pulumi.Input[_builtins.str]] = None,
|
|
847
|
+
verify_ssl: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
727
848
|
__props__=None):
|
|
728
849
|
"""
|
|
729
|
-
Use this resource to create, update, and delete a Simple or Browser Synthetics Monitor in New Relic.
|
|
730
|
-
|
|
731
850
|
## Example Usage
|
|
732
851
|
|
|
733
|
-
<!--Start PulumiCodeChooser -->
|
|
734
852
|
```python
|
|
735
853
|
import pulumi
|
|
736
854
|
import pulumi_newrelic as newrelic
|
|
737
855
|
|
|
738
856
|
monitor = newrelic.synthetics.Monitor("monitor",
|
|
739
|
-
bypass_head_request=True,
|
|
740
|
-
custom_headers=[newrelic.synthetics.MonitorCustomHeaderArgs(
|
|
741
|
-
name="some_name",
|
|
742
|
-
value="some_value",
|
|
743
|
-
)],
|
|
744
|
-
locations_publics=["AP_SOUTH_1"],
|
|
745
|
-
period="EVERY_MINUTE",
|
|
746
857
|
status="ENABLED",
|
|
747
|
-
|
|
748
|
-
|
|
749
|
-
values=["some_value"],
|
|
750
|
-
)],
|
|
751
|
-
treat_redirect_as_failure=True,
|
|
752
|
-
type="SIMPLE",
|
|
858
|
+
name="monitor",
|
|
859
|
+
period="EVERY_MINUTE",
|
|
753
860
|
uri="https://www.one.newrelic.com",
|
|
861
|
+
type="SIMPLE",
|
|
862
|
+
locations_publics=["AP_SOUTH_1"],
|
|
863
|
+
custom_headers=[{
|
|
864
|
+
"name": "some_name",
|
|
865
|
+
"value": "some_value",
|
|
866
|
+
}],
|
|
867
|
+
treat_redirect_as_failure=True,
|
|
754
868
|
validation_string="success",
|
|
755
|
-
|
|
869
|
+
bypass_head_request=True,
|
|
870
|
+
verify_ssl=True,
|
|
871
|
+
tags=[{
|
|
872
|
+
"key": "some_key",
|
|
873
|
+
"values": ["some_value"],
|
|
874
|
+
}])
|
|
756
875
|
```
|
|
757
|
-
<!--End PulumiCodeChooser -->
|
|
758
876
|
##### Type: `SIMPLE BROWSER`
|
|
759
877
|
|
|
760
|
-
<!--Start PulumiCodeChooser -->
|
|
761
878
|
```python
|
|
762
879
|
import pulumi
|
|
763
880
|
import pulumi_newrelic as newrelic
|
|
764
881
|
|
|
765
882
|
monitor = newrelic.synthetics.Monitor("monitor",
|
|
766
|
-
custom_headers=[newrelic.synthetics.MonitorCustomHeaderArgs(
|
|
767
|
-
name="some_name",
|
|
768
|
-
value="some_value",
|
|
769
|
-
)],
|
|
770
|
-
enable_screenshot_on_failure_and_script=True,
|
|
771
|
-
locations_publics=["AP_SOUTH_1"],
|
|
772
|
-
period="EVERY_MINUTE",
|
|
773
883
|
status="ENABLED",
|
|
774
|
-
|
|
775
|
-
|
|
776
|
-
values=["some_value"],
|
|
777
|
-
)],
|
|
778
|
-
type="BROWSER",
|
|
884
|
+
name="monitor",
|
|
885
|
+
period="EVERY_MINUTE",
|
|
779
886
|
uri="https://www.one.newrelic.com",
|
|
887
|
+
type="BROWSER",
|
|
888
|
+
locations_publics=["AP_SOUTH_1"],
|
|
889
|
+
enable_screenshot_on_failure_and_script=True,
|
|
780
890
|
validation_string="success",
|
|
781
|
-
verify_ssl=True
|
|
891
|
+
verify_ssl=True,
|
|
892
|
+
runtime_type="CHROME_BROWSER",
|
|
893
|
+
runtime_type_version="100",
|
|
894
|
+
script_language="JAVASCRIPT",
|
|
895
|
+
devices=[
|
|
896
|
+
"DESKTOP",
|
|
897
|
+
"TABLET_LANDSCAPE",
|
|
898
|
+
"MOBILE_PORTRAIT",
|
|
899
|
+
],
|
|
900
|
+
browsers=["CHROME"],
|
|
901
|
+
custom_headers=[{
|
|
902
|
+
"name": "some_name",
|
|
903
|
+
"value": "some_value",
|
|
904
|
+
}],
|
|
905
|
+
tags=[{
|
|
906
|
+
"key": "some_key",
|
|
907
|
+
"values": ["some_value"],
|
|
908
|
+
}])
|
|
782
909
|
```
|
|
783
|
-
<!--End PulumiCodeChooser -->
|
|
784
910
|
See additional examples.
|
|
785
911
|
|
|
786
912
|
## Additional Examples
|
|
@@ -793,66 +919,72 @@ class Monitor(pulumi.CustomResource):
|
|
|
793
919
|
|
|
794
920
|
##### Type: `SIMPLE`
|
|
795
921
|
|
|
796
|
-
<!--Start PulumiCodeChooser -->
|
|
797
922
|
```python
|
|
798
923
|
import pulumi
|
|
799
924
|
import pulumi_newrelic as newrelic
|
|
800
925
|
|
|
801
926
|
location = newrelic.synthetics.PrivateLocation("location",
|
|
802
927
|
description="Example private location",
|
|
928
|
+
name="private_location",
|
|
803
929
|
verified_script_execution=False)
|
|
804
930
|
monitor = newrelic.synthetics.Monitor("monitor",
|
|
805
931
|
status="ENABLED",
|
|
932
|
+
name="monitor",
|
|
806
933
|
period="EVERY_MINUTE",
|
|
807
934
|
uri="https://www.one.newrelic.com",
|
|
808
935
|
type="SIMPLE",
|
|
809
936
|
locations_privates=[location.id],
|
|
810
|
-
custom_headers=[
|
|
811
|
-
name
|
|
812
|
-
value
|
|
813
|
-
|
|
937
|
+
custom_headers=[{
|
|
938
|
+
"name": "some_name",
|
|
939
|
+
"value": "some_value",
|
|
940
|
+
}],
|
|
814
941
|
treat_redirect_as_failure=True,
|
|
815
942
|
validation_string="success",
|
|
816
943
|
bypass_head_request=True,
|
|
817
944
|
verify_ssl=True,
|
|
818
|
-
tags=[
|
|
819
|
-
key
|
|
820
|
-
values
|
|
821
|
-
|
|
945
|
+
tags=[{
|
|
946
|
+
"key": "some_key",
|
|
947
|
+
"values": ["some_value"],
|
|
948
|
+
}])
|
|
822
949
|
```
|
|
823
|
-
<!--End PulumiCodeChooser -->
|
|
824
950
|
##### Type: `BROWSER`
|
|
825
951
|
|
|
826
|
-
<!--Start PulumiCodeChooser -->
|
|
827
952
|
```python
|
|
828
953
|
import pulumi
|
|
829
954
|
import pulumi_newrelic as newrelic
|
|
830
955
|
|
|
831
956
|
location = newrelic.synthetics.PrivateLocation("location",
|
|
832
957
|
description="Example private location",
|
|
958
|
+
name="private-location",
|
|
833
959
|
verified_script_execution=False)
|
|
834
960
|
monitor = newrelic.synthetics.Monitor("monitor",
|
|
835
961
|
status="ENABLED",
|
|
836
962
|
type="BROWSER",
|
|
837
963
|
uri="https://www.one.newrelic.com",
|
|
964
|
+
name="monitor",
|
|
838
965
|
period="EVERY_MINUTE",
|
|
839
966
|
locations_privates=[location.id],
|
|
840
|
-
custom_headers=[newrelic.synthetics.MonitorCustomHeaderArgs(
|
|
841
|
-
name="some_name",
|
|
842
|
-
value="some_value",
|
|
843
|
-
)],
|
|
844
967
|
enable_screenshot_on_failure_and_script=True,
|
|
845
968
|
validation_string="success",
|
|
846
969
|
verify_ssl=True,
|
|
847
970
|
runtime_type_version="100",
|
|
848
971
|
runtime_type="CHROME_BROWSER",
|
|
849
972
|
script_language="JAVASCRIPT",
|
|
850
|
-
|
|
851
|
-
|
|
852
|
-
|
|
853
|
-
|
|
973
|
+
devices=[
|
|
974
|
+
"DESKTOP",
|
|
975
|
+
"TABLET_LANDSCAPE",
|
|
976
|
+
"MOBILE_PORTRAIT",
|
|
977
|
+
],
|
|
978
|
+
browsers=["CHROME"],
|
|
979
|
+
custom_headers=[{
|
|
980
|
+
"name": "some_name",
|
|
981
|
+
"value": "some_value",
|
|
982
|
+
}],
|
|
983
|
+
tags=[{
|
|
984
|
+
"key": "some_key",
|
|
985
|
+
"values": ["some_value"],
|
|
986
|
+
}])
|
|
854
987
|
```
|
|
855
|
-
<!--End PulumiCodeChooser -->
|
|
856
988
|
|
|
857
989
|
## Import
|
|
858
990
|
|
|
@@ -866,30 +998,34 @@ class Monitor(pulumi.CustomResource):
|
|
|
866
998
|
|
|
867
999
|
:param str resource_name: The name of the resource.
|
|
868
1000
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
869
|
-
:param pulumi.Input[
|
|
870
|
-
:param pulumi.Input[
|
|
1001
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
1002
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
1003
|
+
:param pulumi.Input[_builtins.bool] bypass_head_request: Monitor should skip default HEAD request and instead use GET verb in check.
|
|
871
1004
|
|
|
872
1005
|
The `BROWSER` monitor type supports the following additional arguments:
|
|
873
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
874
|
-
:param pulumi.Input[str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
875
|
-
|
|
876
|
-
:param pulumi.Input[
|
|
877
|
-
|
|
878
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
879
|
-
:param pulumi.Input[
|
|
880
|
-
:param pulumi.Input[str]
|
|
881
|
-
:param pulumi.Input[str]
|
|
882
|
-
:param pulumi.Input[str]
|
|
883
|
-
:param pulumi.Input[str]
|
|
884
|
-
:param pulumi.Input[str]
|
|
885
|
-
:param pulumi.Input[
|
|
1006
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['MonitorCustomHeaderArgs', 'MonitorCustomHeaderArgsDict']]]] custom_headers: Custom headers to use in monitor job. See Nested custom_header blocks below for details.
|
|
1007
|
+
:param pulumi.Input[_builtins.str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
1008
|
+
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
1009
|
+
:param pulumi.Input[_builtins.str] device_type: Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
1010
|
+
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
1011
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] devices: The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
1012
|
+
:param pulumi.Input[_builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
1013
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
1014
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
1015
|
+
:param pulumi.Input[_builtins.str] name: The human-readable identifier for the monitor.
|
|
1016
|
+
:param pulumi.Input[_builtins.str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
1017
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
1018
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific version of the runtime type selected (`100`).
|
|
1019
|
+
:param pulumi.Input[_builtins.str] script_language: The programing language that should execute the script.
|
|
1020
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
1021
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['MonitorTagArgs', 'MonitorTagArgsDict']]]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
886
1022
|
|
|
887
1023
|
The `SIMPLE` monitor type supports the following additional arguments:
|
|
888
|
-
:param pulumi.Input[bool] treat_redirect_as_failure: Categorize redirects during a monitor job as a failure.
|
|
889
|
-
:param pulumi.Input[str] type: The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
890
|
-
:param pulumi.Input[str] uri: The URI the monitor runs against.
|
|
891
|
-
:param pulumi.Input[str] validation_string: Validation text for monitor to search for at given URI.
|
|
892
|
-
:param pulumi.Input[bool] verify_ssl: Monitor should validate SSL certificate chain.
|
|
1024
|
+
:param pulumi.Input[_builtins.bool] treat_redirect_as_failure: Categorize redirects during a monitor job as a failure.
|
|
1025
|
+
:param pulumi.Input[_builtins.str] type: The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
1026
|
+
:param pulumi.Input[_builtins.str] uri: The URI the monitor runs against.
|
|
1027
|
+
:param pulumi.Input[_builtins.str] validation_string: Validation text for monitor to search for at given URI.
|
|
1028
|
+
:param pulumi.Input[_builtins.bool] verify_ssl: Monitor should validate SSL certificate chain.
|
|
893
1029
|
"""
|
|
894
1030
|
...
|
|
895
1031
|
@overload
|
|
@@ -898,61 +1034,66 @@ class Monitor(pulumi.CustomResource):
|
|
|
898
1034
|
args: MonitorArgs,
|
|
899
1035
|
opts: Optional[pulumi.ResourceOptions] = None):
|
|
900
1036
|
"""
|
|
901
|
-
Use this resource to create, update, and delete a Simple or Browser Synthetics Monitor in New Relic.
|
|
902
|
-
|
|
903
1037
|
## Example Usage
|
|
904
1038
|
|
|
905
|
-
<!--Start PulumiCodeChooser -->
|
|
906
1039
|
```python
|
|
907
1040
|
import pulumi
|
|
908
1041
|
import pulumi_newrelic as newrelic
|
|
909
1042
|
|
|
910
1043
|
monitor = newrelic.synthetics.Monitor("monitor",
|
|
911
|
-
bypass_head_request=True,
|
|
912
|
-
custom_headers=[newrelic.synthetics.MonitorCustomHeaderArgs(
|
|
913
|
-
name="some_name",
|
|
914
|
-
value="some_value",
|
|
915
|
-
)],
|
|
916
|
-
locations_publics=["AP_SOUTH_1"],
|
|
917
|
-
period="EVERY_MINUTE",
|
|
918
1044
|
status="ENABLED",
|
|
919
|
-
|
|
920
|
-
|
|
921
|
-
values=["some_value"],
|
|
922
|
-
)],
|
|
923
|
-
treat_redirect_as_failure=True,
|
|
924
|
-
type="SIMPLE",
|
|
1045
|
+
name="monitor",
|
|
1046
|
+
period="EVERY_MINUTE",
|
|
925
1047
|
uri="https://www.one.newrelic.com",
|
|
1048
|
+
type="SIMPLE",
|
|
1049
|
+
locations_publics=["AP_SOUTH_1"],
|
|
1050
|
+
custom_headers=[{
|
|
1051
|
+
"name": "some_name",
|
|
1052
|
+
"value": "some_value",
|
|
1053
|
+
}],
|
|
1054
|
+
treat_redirect_as_failure=True,
|
|
926
1055
|
validation_string="success",
|
|
927
|
-
|
|
1056
|
+
bypass_head_request=True,
|
|
1057
|
+
verify_ssl=True,
|
|
1058
|
+
tags=[{
|
|
1059
|
+
"key": "some_key",
|
|
1060
|
+
"values": ["some_value"],
|
|
1061
|
+
}])
|
|
928
1062
|
```
|
|
929
|
-
<!--End PulumiCodeChooser -->
|
|
930
1063
|
##### Type: `SIMPLE BROWSER`
|
|
931
1064
|
|
|
932
|
-
<!--Start PulumiCodeChooser -->
|
|
933
1065
|
```python
|
|
934
1066
|
import pulumi
|
|
935
1067
|
import pulumi_newrelic as newrelic
|
|
936
1068
|
|
|
937
1069
|
monitor = newrelic.synthetics.Monitor("monitor",
|
|
938
|
-
custom_headers=[newrelic.synthetics.MonitorCustomHeaderArgs(
|
|
939
|
-
name="some_name",
|
|
940
|
-
value="some_value",
|
|
941
|
-
)],
|
|
942
|
-
enable_screenshot_on_failure_and_script=True,
|
|
943
|
-
locations_publics=["AP_SOUTH_1"],
|
|
944
|
-
period="EVERY_MINUTE",
|
|
945
1070
|
status="ENABLED",
|
|
946
|
-
|
|
947
|
-
|
|
948
|
-
values=["some_value"],
|
|
949
|
-
)],
|
|
950
|
-
type="BROWSER",
|
|
1071
|
+
name="monitor",
|
|
1072
|
+
period="EVERY_MINUTE",
|
|
951
1073
|
uri="https://www.one.newrelic.com",
|
|
1074
|
+
type="BROWSER",
|
|
1075
|
+
locations_publics=["AP_SOUTH_1"],
|
|
1076
|
+
enable_screenshot_on_failure_and_script=True,
|
|
952
1077
|
validation_string="success",
|
|
953
|
-
verify_ssl=True
|
|
1078
|
+
verify_ssl=True,
|
|
1079
|
+
runtime_type="CHROME_BROWSER",
|
|
1080
|
+
runtime_type_version="100",
|
|
1081
|
+
script_language="JAVASCRIPT",
|
|
1082
|
+
devices=[
|
|
1083
|
+
"DESKTOP",
|
|
1084
|
+
"TABLET_LANDSCAPE",
|
|
1085
|
+
"MOBILE_PORTRAIT",
|
|
1086
|
+
],
|
|
1087
|
+
browsers=["CHROME"],
|
|
1088
|
+
custom_headers=[{
|
|
1089
|
+
"name": "some_name",
|
|
1090
|
+
"value": "some_value",
|
|
1091
|
+
}],
|
|
1092
|
+
tags=[{
|
|
1093
|
+
"key": "some_key",
|
|
1094
|
+
"values": ["some_value"],
|
|
1095
|
+
}])
|
|
954
1096
|
```
|
|
955
|
-
<!--End PulumiCodeChooser -->
|
|
956
1097
|
See additional examples.
|
|
957
1098
|
|
|
958
1099
|
## Additional Examples
|
|
@@ -965,66 +1106,72 @@ class Monitor(pulumi.CustomResource):
|
|
|
965
1106
|
|
|
966
1107
|
##### Type: `SIMPLE`
|
|
967
1108
|
|
|
968
|
-
<!--Start PulumiCodeChooser -->
|
|
969
1109
|
```python
|
|
970
1110
|
import pulumi
|
|
971
1111
|
import pulumi_newrelic as newrelic
|
|
972
1112
|
|
|
973
1113
|
location = newrelic.synthetics.PrivateLocation("location",
|
|
974
1114
|
description="Example private location",
|
|
1115
|
+
name="private_location",
|
|
975
1116
|
verified_script_execution=False)
|
|
976
1117
|
monitor = newrelic.synthetics.Monitor("monitor",
|
|
977
1118
|
status="ENABLED",
|
|
1119
|
+
name="monitor",
|
|
978
1120
|
period="EVERY_MINUTE",
|
|
979
1121
|
uri="https://www.one.newrelic.com",
|
|
980
1122
|
type="SIMPLE",
|
|
981
1123
|
locations_privates=[location.id],
|
|
982
|
-
custom_headers=[
|
|
983
|
-
name
|
|
984
|
-
value
|
|
985
|
-
|
|
1124
|
+
custom_headers=[{
|
|
1125
|
+
"name": "some_name",
|
|
1126
|
+
"value": "some_value",
|
|
1127
|
+
}],
|
|
986
1128
|
treat_redirect_as_failure=True,
|
|
987
1129
|
validation_string="success",
|
|
988
1130
|
bypass_head_request=True,
|
|
989
1131
|
verify_ssl=True,
|
|
990
|
-
tags=[
|
|
991
|
-
key
|
|
992
|
-
values
|
|
993
|
-
|
|
1132
|
+
tags=[{
|
|
1133
|
+
"key": "some_key",
|
|
1134
|
+
"values": ["some_value"],
|
|
1135
|
+
}])
|
|
994
1136
|
```
|
|
995
|
-
<!--End PulumiCodeChooser -->
|
|
996
1137
|
##### Type: `BROWSER`
|
|
997
1138
|
|
|
998
|
-
<!--Start PulumiCodeChooser -->
|
|
999
1139
|
```python
|
|
1000
1140
|
import pulumi
|
|
1001
1141
|
import pulumi_newrelic as newrelic
|
|
1002
1142
|
|
|
1003
1143
|
location = newrelic.synthetics.PrivateLocation("location",
|
|
1004
1144
|
description="Example private location",
|
|
1145
|
+
name="private-location",
|
|
1005
1146
|
verified_script_execution=False)
|
|
1006
1147
|
monitor = newrelic.synthetics.Monitor("monitor",
|
|
1007
1148
|
status="ENABLED",
|
|
1008
1149
|
type="BROWSER",
|
|
1009
1150
|
uri="https://www.one.newrelic.com",
|
|
1151
|
+
name="monitor",
|
|
1010
1152
|
period="EVERY_MINUTE",
|
|
1011
1153
|
locations_privates=[location.id],
|
|
1012
|
-
custom_headers=[newrelic.synthetics.MonitorCustomHeaderArgs(
|
|
1013
|
-
name="some_name",
|
|
1014
|
-
value="some_value",
|
|
1015
|
-
)],
|
|
1016
1154
|
enable_screenshot_on_failure_and_script=True,
|
|
1017
1155
|
validation_string="success",
|
|
1018
1156
|
verify_ssl=True,
|
|
1019
1157
|
runtime_type_version="100",
|
|
1020
1158
|
runtime_type="CHROME_BROWSER",
|
|
1021
1159
|
script_language="JAVASCRIPT",
|
|
1022
|
-
|
|
1023
|
-
|
|
1024
|
-
|
|
1025
|
-
|
|
1160
|
+
devices=[
|
|
1161
|
+
"DESKTOP",
|
|
1162
|
+
"TABLET_LANDSCAPE",
|
|
1163
|
+
"MOBILE_PORTRAIT",
|
|
1164
|
+
],
|
|
1165
|
+
browsers=["CHROME"],
|
|
1166
|
+
custom_headers=[{
|
|
1167
|
+
"name": "some_name",
|
|
1168
|
+
"value": "some_value",
|
|
1169
|
+
}],
|
|
1170
|
+
tags=[{
|
|
1171
|
+
"key": "some_key",
|
|
1172
|
+
"values": ["some_value"],
|
|
1173
|
+
}])
|
|
1026
1174
|
```
|
|
1027
|
-
<!--End PulumiCodeChooser -->
|
|
1028
1175
|
|
|
1029
1176
|
## Import
|
|
1030
1177
|
|
|
@@ -1051,26 +1198,29 @@ class Monitor(pulumi.CustomResource):
|
|
|
1051
1198
|
def _internal_init(__self__,
|
|
1052
1199
|
resource_name: str,
|
|
1053
1200
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1054
|
-
account_id: Optional[pulumi.Input[
|
|
1055
|
-
|
|
1056
|
-
|
|
1057
|
-
|
|
1058
|
-
|
|
1059
|
-
|
|
1060
|
-
|
|
1061
|
-
|
|
1062
|
-
|
|
1063
|
-
|
|
1064
|
-
|
|
1065
|
-
|
|
1066
|
-
|
|
1067
|
-
|
|
1068
|
-
|
|
1069
|
-
|
|
1070
|
-
|
|
1071
|
-
|
|
1072
|
-
|
|
1073
|
-
|
|
1201
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1202
|
+
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1203
|
+
bypass_head_request: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1204
|
+
custom_headers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MonitorCustomHeaderArgs', 'MonitorCustomHeaderArgsDict']]]]] = None,
|
|
1205
|
+
device_orientation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1206
|
+
device_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1207
|
+
devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1208
|
+
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1209
|
+
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1210
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1211
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1212
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1213
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1214
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1215
|
+
script_language: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1216
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1217
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MonitorTagArgs', 'MonitorTagArgsDict']]]]] = None,
|
|
1218
|
+
treat_redirect_as_failure: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1219
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1220
|
+
uri: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1221
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1222
|
+
validation_string: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1223
|
+
verify_ssl: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1074
1224
|
__props__=None):
|
|
1075
1225
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1076
1226
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -1081,10 +1231,12 @@ class Monitor(pulumi.CustomResource):
|
|
|
1081
1231
|
__props__ = MonitorArgs.__new__(MonitorArgs)
|
|
1082
1232
|
|
|
1083
1233
|
__props__.__dict__["account_id"] = account_id
|
|
1234
|
+
__props__.__dict__["browsers"] = browsers
|
|
1084
1235
|
__props__.__dict__["bypass_head_request"] = bypass_head_request
|
|
1085
1236
|
__props__.__dict__["custom_headers"] = custom_headers
|
|
1086
1237
|
__props__.__dict__["device_orientation"] = device_orientation
|
|
1087
1238
|
__props__.__dict__["device_type"] = device_type
|
|
1239
|
+
__props__.__dict__["devices"] = devices
|
|
1088
1240
|
__props__.__dict__["enable_screenshot_on_failure_and_script"] = enable_screenshot_on_failure_and_script
|
|
1089
1241
|
__props__.__dict__["locations_privates"] = locations_privates
|
|
1090
1242
|
__props__.__dict__["locations_publics"] = locations_publics
|
|
@@ -1102,8 +1254,10 @@ class Monitor(pulumi.CustomResource):
|
|
|
1102
1254
|
raise TypeError("Missing required property 'type'")
|
|
1103
1255
|
__props__.__dict__["type"] = type
|
|
1104
1256
|
__props__.__dict__["uri"] = uri
|
|
1257
|
+
__props__.__dict__["use_unsupported_legacy_runtime"] = use_unsupported_legacy_runtime
|
|
1105
1258
|
__props__.__dict__["validation_string"] = validation_string
|
|
1106
1259
|
__props__.__dict__["verify_ssl"] = verify_ssl
|
|
1260
|
+
__props__.__dict__["monitor_id"] = None
|
|
1107
1261
|
__props__.__dict__["period_in_minutes"] = None
|
|
1108
1262
|
super(Monitor, __self__).__init__(
|
|
1109
1263
|
'newrelic:synthetics/monitor:Monitor',
|
|
@@ -1115,27 +1269,31 @@ class Monitor(pulumi.CustomResource):
|
|
|
1115
1269
|
def get(resource_name: str,
|
|
1116
1270
|
id: pulumi.Input[str],
|
|
1117
1271
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1118
|
-
account_id: Optional[pulumi.Input[
|
|
1119
|
-
|
|
1120
|
-
|
|
1121
|
-
|
|
1122
|
-
|
|
1123
|
-
|
|
1124
|
-
|
|
1125
|
-
|
|
1126
|
-
|
|
1127
|
-
|
|
1128
|
-
|
|
1129
|
-
|
|
1130
|
-
|
|
1131
|
-
|
|
1132
|
-
|
|
1133
|
-
|
|
1134
|
-
|
|
1135
|
-
|
|
1136
|
-
|
|
1137
|
-
|
|
1138
|
-
|
|
1272
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1273
|
+
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1274
|
+
bypass_head_request: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1275
|
+
custom_headers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MonitorCustomHeaderArgs', 'MonitorCustomHeaderArgsDict']]]]] = None,
|
|
1276
|
+
device_orientation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1277
|
+
device_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1278
|
+
devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1279
|
+
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1280
|
+
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1281
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1282
|
+
monitor_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1283
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1284
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1285
|
+
period_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1286
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1287
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1288
|
+
script_language: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1289
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1290
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MonitorTagArgs', 'MonitorTagArgsDict']]]]] = None,
|
|
1291
|
+
treat_redirect_as_failure: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1292
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1293
|
+
uri: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1294
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1295
|
+
validation_string: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1296
|
+
verify_ssl: Optional[pulumi.Input[_builtins.bool]] = None) -> 'Monitor':
|
|
1139
1297
|
"""
|
|
1140
1298
|
Get an existing Monitor resource's state with the given name, id, and optional extra
|
|
1141
1299
|
properties used to qualify the lookup.
|
|
@@ -1143,44 +1301,52 @@ class Monitor(pulumi.CustomResource):
|
|
|
1143
1301
|
:param str resource_name: The unique name of the resulting resource.
|
|
1144
1302
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1145
1303
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1146
|
-
:param pulumi.Input[
|
|
1147
|
-
:param pulumi.Input[
|
|
1304
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
1305
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
1306
|
+
:param pulumi.Input[_builtins.bool] bypass_head_request: Monitor should skip default HEAD request and instead use GET verb in check.
|
|
1148
1307
|
|
|
1149
1308
|
The `BROWSER` monitor type supports the following additional arguments:
|
|
1150
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1151
|
-
:param pulumi.Input[str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
1152
|
-
|
|
1153
|
-
:param pulumi.Input[
|
|
1154
|
-
|
|
1155
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
1156
|
-
:param pulumi.Input[
|
|
1157
|
-
:param pulumi.Input[str]
|
|
1158
|
-
:param pulumi.Input[
|
|
1159
|
-
:param pulumi.Input[str]
|
|
1160
|
-
:param pulumi.Input[str]
|
|
1161
|
-
:param pulumi.Input[str]
|
|
1162
|
-
:param pulumi.Input[
|
|
1163
|
-
:param pulumi.Input[
|
|
1309
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['MonitorCustomHeaderArgs', 'MonitorCustomHeaderArgsDict']]]] custom_headers: Custom headers to use in monitor job. See Nested custom_header blocks below for details.
|
|
1310
|
+
:param pulumi.Input[_builtins.str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
1311
|
+
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
1312
|
+
:param pulumi.Input[_builtins.str] device_type: Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
1313
|
+
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
1314
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] devices: The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
1315
|
+
:param pulumi.Input[_builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
1316
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
1317
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
1318
|
+
:param pulumi.Input[_builtins.str] monitor_id: The monitor id of the Synthetics monitor (not to be confused with the GUID of the monitor).
|
|
1319
|
+
:param pulumi.Input[_builtins.str] name: The human-readable identifier for the monitor.
|
|
1320
|
+
:param pulumi.Input[_builtins.str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
1321
|
+
:param pulumi.Input[_builtins.int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
|
|
1322
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
1323
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific version of the runtime type selected (`100`).
|
|
1324
|
+
:param pulumi.Input[_builtins.str] script_language: The programing language that should execute the script.
|
|
1325
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
1326
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['MonitorTagArgs', 'MonitorTagArgsDict']]]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
1164
1327
|
|
|
1165
1328
|
The `SIMPLE` monitor type supports the following additional arguments:
|
|
1166
|
-
:param pulumi.Input[bool] treat_redirect_as_failure: Categorize redirects during a monitor job as a failure.
|
|
1167
|
-
:param pulumi.Input[str] type: The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
1168
|
-
:param pulumi.Input[str] uri: The URI the monitor runs against.
|
|
1169
|
-
:param pulumi.Input[str] validation_string: Validation text for monitor to search for at given URI.
|
|
1170
|
-
:param pulumi.Input[bool] verify_ssl: Monitor should validate SSL certificate chain.
|
|
1329
|
+
:param pulumi.Input[_builtins.bool] treat_redirect_as_failure: Categorize redirects during a monitor job as a failure.
|
|
1330
|
+
:param pulumi.Input[_builtins.str] type: The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
1331
|
+
:param pulumi.Input[_builtins.str] uri: The URI the monitor runs against.
|
|
1332
|
+
:param pulumi.Input[_builtins.str] validation_string: Validation text for monitor to search for at given URI.
|
|
1333
|
+
:param pulumi.Input[_builtins.bool] verify_ssl: Monitor should validate SSL certificate chain.
|
|
1171
1334
|
"""
|
|
1172
1335
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
1173
1336
|
|
|
1174
1337
|
__props__ = _MonitorState.__new__(_MonitorState)
|
|
1175
1338
|
|
|
1176
1339
|
__props__.__dict__["account_id"] = account_id
|
|
1340
|
+
__props__.__dict__["browsers"] = browsers
|
|
1177
1341
|
__props__.__dict__["bypass_head_request"] = bypass_head_request
|
|
1178
1342
|
__props__.__dict__["custom_headers"] = custom_headers
|
|
1179
1343
|
__props__.__dict__["device_orientation"] = device_orientation
|
|
1180
1344
|
__props__.__dict__["device_type"] = device_type
|
|
1345
|
+
__props__.__dict__["devices"] = devices
|
|
1181
1346
|
__props__.__dict__["enable_screenshot_on_failure_and_script"] = enable_screenshot_on_failure_and_script
|
|
1182
1347
|
__props__.__dict__["locations_privates"] = locations_privates
|
|
1183
1348
|
__props__.__dict__["locations_publics"] = locations_publics
|
|
1349
|
+
__props__.__dict__["monitor_id"] = monitor_id
|
|
1184
1350
|
__props__.__dict__["name"] = name
|
|
1185
1351
|
__props__.__dict__["period"] = period
|
|
1186
1352
|
__props__.__dict__["period_in_minutes"] = period_in_minutes
|
|
@@ -1192,21 +1358,30 @@ class Monitor(pulumi.CustomResource):
|
|
|
1192
1358
|
__props__.__dict__["treat_redirect_as_failure"] = treat_redirect_as_failure
|
|
1193
1359
|
__props__.__dict__["type"] = type
|
|
1194
1360
|
__props__.__dict__["uri"] = uri
|
|
1361
|
+
__props__.__dict__["use_unsupported_legacy_runtime"] = use_unsupported_legacy_runtime
|
|
1195
1362
|
__props__.__dict__["validation_string"] = validation_string
|
|
1196
1363
|
__props__.__dict__["verify_ssl"] = verify_ssl
|
|
1197
1364
|
return Monitor(resource_name, opts=opts, __props__=__props__)
|
|
1198
1365
|
|
|
1199
|
-
@property
|
|
1366
|
+
@_builtins.property
|
|
1200
1367
|
@pulumi.getter(name="accountId")
|
|
1201
|
-
def account_id(self) -> pulumi.Output[
|
|
1368
|
+
def account_id(self) -> pulumi.Output[_builtins.str]:
|
|
1202
1369
|
"""
|
|
1203
1370
|
The account in which the Synthetics monitor will be created.
|
|
1204
1371
|
"""
|
|
1205
1372
|
return pulumi.get(self, "account_id")
|
|
1206
1373
|
|
|
1207
|
-
@property
|
|
1374
|
+
@_builtins.property
|
|
1375
|
+
@pulumi.getter
|
|
1376
|
+
def browsers(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1377
|
+
"""
|
|
1378
|
+
The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
1379
|
+
"""
|
|
1380
|
+
return pulumi.get(self, "browsers")
|
|
1381
|
+
|
|
1382
|
+
@_builtins.property
|
|
1208
1383
|
@pulumi.getter(name="bypassHeadRequest")
|
|
1209
|
-
def bypass_head_request(self) -> pulumi.Output[Optional[bool]]:
|
|
1384
|
+
def bypass_head_request(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1210
1385
|
"""
|
|
1211
1386
|
Monitor should skip default HEAD request and instead use GET verb in check.
|
|
1212
1387
|
|
|
@@ -1214,7 +1389,7 @@ class Monitor(pulumi.CustomResource):
|
|
|
1214
1389
|
"""
|
|
1215
1390
|
return pulumi.get(self, "bypass_head_request")
|
|
1216
1391
|
|
|
1217
|
-
@property
|
|
1392
|
+
@_builtins.property
|
|
1218
1393
|
@pulumi.getter(name="customHeaders")
|
|
1219
1394
|
def custom_headers(self) -> pulumi.Output[Optional[Sequence['outputs.MonitorCustomHeader']]]:
|
|
1220
1395
|
"""
|
|
@@ -1222,103 +1397,121 @@ class Monitor(pulumi.CustomResource):
|
|
|
1222
1397
|
"""
|
|
1223
1398
|
return pulumi.get(self, "custom_headers")
|
|
1224
1399
|
|
|
1225
|
-
@property
|
|
1400
|
+
@_builtins.property
|
|
1226
1401
|
@pulumi.getter(name="deviceOrientation")
|
|
1227
|
-
def device_orientation(self) -> pulumi.Output[Optional[str]]:
|
|
1402
|
+
def device_orientation(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1228
1403
|
"""
|
|
1229
|
-
Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
1404
|
+
Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
1405
|
+
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
1230
1406
|
"""
|
|
1231
1407
|
return pulumi.get(self, "device_orientation")
|
|
1232
1408
|
|
|
1233
|
-
@property
|
|
1409
|
+
@_builtins.property
|
|
1234
1410
|
@pulumi.getter(name="deviceType")
|
|
1235
|
-
def device_type(self) -> pulumi.Output[Optional[str]]:
|
|
1411
|
+
def device_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1236
1412
|
"""
|
|
1237
|
-
Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
1413
|
+
Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
1414
|
+
* We recommend you to use `devices` field instead of `device_type`,`device_orientation` fields, as it allows you to select multiple combinations of device types and orientations.
|
|
1238
1415
|
"""
|
|
1239
1416
|
return pulumi.get(self, "device_type")
|
|
1240
1417
|
|
|
1241
|
-
@property
|
|
1418
|
+
@_builtins.property
|
|
1419
|
+
@pulumi.getter
|
|
1420
|
+
def devices(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1421
|
+
"""
|
|
1422
|
+
The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
1423
|
+
"""
|
|
1424
|
+
return pulumi.get(self, "devices")
|
|
1425
|
+
|
|
1426
|
+
@_builtins.property
|
|
1242
1427
|
@pulumi.getter(name="enableScreenshotOnFailureAndScript")
|
|
1243
|
-
def enable_screenshot_on_failure_and_script(self) -> pulumi.Output[Optional[bool]]:
|
|
1428
|
+
def enable_screenshot_on_failure_and_script(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1244
1429
|
"""
|
|
1245
1430
|
Capture a screenshot during job execution.
|
|
1246
1431
|
"""
|
|
1247
1432
|
return pulumi.get(self, "enable_screenshot_on_failure_and_script")
|
|
1248
1433
|
|
|
1249
|
-
@property
|
|
1434
|
+
@_builtins.property
|
|
1250
1435
|
@pulumi.getter(name="locationsPrivates")
|
|
1251
|
-
def locations_privates(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1436
|
+
def locations_privates(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1252
1437
|
"""
|
|
1253
1438
|
The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
1254
1439
|
"""
|
|
1255
1440
|
return pulumi.get(self, "locations_privates")
|
|
1256
1441
|
|
|
1257
|
-
@property
|
|
1442
|
+
@_builtins.property
|
|
1258
1443
|
@pulumi.getter(name="locationsPublics")
|
|
1259
|
-
def locations_publics(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1444
|
+
def locations_publics(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1260
1445
|
"""
|
|
1261
|
-
The location the monitor will run from.
|
|
1446
|
+
The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
1262
1447
|
"""
|
|
1263
1448
|
return pulumi.get(self, "locations_publics")
|
|
1264
1449
|
|
|
1265
|
-
@property
|
|
1450
|
+
@_builtins.property
|
|
1451
|
+
@pulumi.getter(name="monitorId")
|
|
1452
|
+
def monitor_id(self) -> pulumi.Output[_builtins.str]:
|
|
1453
|
+
"""
|
|
1454
|
+
The monitor id of the Synthetics monitor (not to be confused with the GUID of the monitor).
|
|
1455
|
+
"""
|
|
1456
|
+
return pulumi.get(self, "monitor_id")
|
|
1457
|
+
|
|
1458
|
+
@_builtins.property
|
|
1266
1459
|
@pulumi.getter
|
|
1267
|
-
def name(self) -> pulumi.Output[str]:
|
|
1460
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
1268
1461
|
"""
|
|
1269
1462
|
The human-readable identifier for the monitor.
|
|
1270
1463
|
"""
|
|
1271
1464
|
return pulumi.get(self, "name")
|
|
1272
1465
|
|
|
1273
|
-
@property
|
|
1466
|
+
@_builtins.property
|
|
1274
1467
|
@pulumi.getter
|
|
1275
|
-
def period(self) -> pulumi.Output[str]:
|
|
1468
|
+
def period(self) -> pulumi.Output[_builtins.str]:
|
|
1276
1469
|
"""
|
|
1277
|
-
The interval at which this monitor should run. Valid values are EVERY_MINUTE
|
|
1470
|
+
The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
1278
1471
|
"""
|
|
1279
1472
|
return pulumi.get(self, "period")
|
|
1280
1473
|
|
|
1281
|
-
@property
|
|
1474
|
+
@_builtins.property
|
|
1282
1475
|
@pulumi.getter(name="periodInMinutes")
|
|
1283
|
-
def period_in_minutes(self) -> pulumi.Output[int]:
|
|
1476
|
+
def period_in_minutes(self) -> pulumi.Output[_builtins.int]:
|
|
1284
1477
|
"""
|
|
1285
1478
|
The interval in minutes at which Synthetic monitor should run.
|
|
1286
1479
|
"""
|
|
1287
1480
|
return pulumi.get(self, "period_in_minutes")
|
|
1288
1481
|
|
|
1289
|
-
@property
|
|
1482
|
+
@_builtins.property
|
|
1290
1483
|
@pulumi.getter(name="runtimeType")
|
|
1291
|
-
def runtime_type(self) -> pulumi.Output[Optional[str]]:
|
|
1484
|
+
def runtime_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1292
1485
|
"""
|
|
1293
|
-
The runtime
|
|
1486
|
+
The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
1294
1487
|
"""
|
|
1295
1488
|
return pulumi.get(self, "runtime_type")
|
|
1296
1489
|
|
|
1297
|
-
@property
|
|
1490
|
+
@_builtins.property
|
|
1298
1491
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
1299
|
-
def runtime_type_version(self) -> pulumi.Output[Optional[str]]:
|
|
1492
|
+
def runtime_type_version(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1300
1493
|
"""
|
|
1301
|
-
The
|
|
1494
|
+
The specific version of the runtime type selected (`100`).
|
|
1302
1495
|
"""
|
|
1303
1496
|
return pulumi.get(self, "runtime_type_version")
|
|
1304
1497
|
|
|
1305
|
-
@property
|
|
1498
|
+
@_builtins.property
|
|
1306
1499
|
@pulumi.getter(name="scriptLanguage")
|
|
1307
|
-
def script_language(self) -> pulumi.Output[Optional[str]]:
|
|
1500
|
+
def script_language(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1308
1501
|
"""
|
|
1309
1502
|
The programing language that should execute the script.
|
|
1310
1503
|
"""
|
|
1311
1504
|
return pulumi.get(self, "script_language")
|
|
1312
1505
|
|
|
1313
|
-
@property
|
|
1506
|
+
@_builtins.property
|
|
1314
1507
|
@pulumi.getter
|
|
1315
|
-
def status(self) -> pulumi.Output[str]:
|
|
1508
|
+
def status(self) -> pulumi.Output[_builtins.str]:
|
|
1316
1509
|
"""
|
|
1317
|
-
The monitor
|
|
1510
|
+
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
1318
1511
|
"""
|
|
1319
1512
|
return pulumi.get(self, "status")
|
|
1320
1513
|
|
|
1321
|
-
@property
|
|
1514
|
+
@_builtins.property
|
|
1322
1515
|
@pulumi.getter
|
|
1323
1516
|
def tags(self) -> pulumi.Output[Optional[Sequence['outputs.MonitorTag']]]:
|
|
1324
1517
|
"""
|
|
@@ -1328,41 +1521,46 @@ class Monitor(pulumi.CustomResource):
|
|
|
1328
1521
|
"""
|
|
1329
1522
|
return pulumi.get(self, "tags")
|
|
1330
1523
|
|
|
1331
|
-
@property
|
|
1524
|
+
@_builtins.property
|
|
1332
1525
|
@pulumi.getter(name="treatRedirectAsFailure")
|
|
1333
|
-
def treat_redirect_as_failure(self) -> pulumi.Output[Optional[bool]]:
|
|
1526
|
+
def treat_redirect_as_failure(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1334
1527
|
"""
|
|
1335
1528
|
Categorize redirects during a monitor job as a failure.
|
|
1336
1529
|
"""
|
|
1337
1530
|
return pulumi.get(self, "treat_redirect_as_failure")
|
|
1338
1531
|
|
|
1339
|
-
@property
|
|
1532
|
+
@_builtins.property
|
|
1340
1533
|
@pulumi.getter
|
|
1341
|
-
def type(self) -> pulumi.Output[str]:
|
|
1534
|
+
def type(self) -> pulumi.Output[_builtins.str]:
|
|
1342
1535
|
"""
|
|
1343
1536
|
The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
1344
1537
|
"""
|
|
1345
1538
|
return pulumi.get(self, "type")
|
|
1346
1539
|
|
|
1347
|
-
@property
|
|
1540
|
+
@_builtins.property
|
|
1348
1541
|
@pulumi.getter
|
|
1349
|
-
def uri(self) -> pulumi.Output[Optional[str]]:
|
|
1542
|
+
def uri(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1350
1543
|
"""
|
|
1351
1544
|
The URI the monitor runs against.
|
|
1352
1545
|
"""
|
|
1353
1546
|
return pulumi.get(self, "uri")
|
|
1354
1547
|
|
|
1355
|
-
@property
|
|
1548
|
+
@_builtins.property
|
|
1549
|
+
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
1550
|
+
def use_unsupported_legacy_runtime(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1551
|
+
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
1552
|
+
|
|
1553
|
+
@_builtins.property
|
|
1356
1554
|
@pulumi.getter(name="validationString")
|
|
1357
|
-
def validation_string(self) -> pulumi.Output[Optional[str]]:
|
|
1555
|
+
def validation_string(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1358
1556
|
"""
|
|
1359
1557
|
Validation text for monitor to search for at given URI.
|
|
1360
1558
|
"""
|
|
1361
1559
|
return pulumi.get(self, "validation_string")
|
|
1362
1560
|
|
|
1363
|
-
@property
|
|
1561
|
+
@_builtins.property
|
|
1364
1562
|
@pulumi.getter(name="verifySsl")
|
|
1365
|
-
def verify_ssl(self) -> pulumi.Output[Optional[bool]]:
|
|
1563
|
+
def verify_ssl(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1366
1564
|
"""
|
|
1367
1565
|
Monitor should validate SSL certificate chain.
|
|
1368
1566
|
"""
|