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