pulumi-newrelic 5.42.1__py3-none-any.whl → 5.58.0a1766556761__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- pulumi_newrelic/__init__.py +19 -1
- pulumi_newrelic/_inputs.py +4314 -3779
- pulumi_newrelic/_utilities.py +1 -1
- pulumi_newrelic/account_management.py +37 -36
- pulumi_newrelic/alert_channel.py +63 -62
- pulumi_newrelic/alert_condition.py +219 -218
- pulumi_newrelic/alert_muting_rule.py +96 -95
- pulumi_newrelic/alert_policy.py +71 -70
- pulumi_newrelic/alert_policy_channel.py +54 -53
- pulumi_newrelic/api_access_key.py +186 -201
- pulumi_newrelic/browser_application.py +115 -114
- pulumi_newrelic/cloud/__init__.py +3 -1
- pulumi_newrelic/cloud/_inputs.py +2226 -2118
- pulumi_newrelic/cloud/aws_govcloud_integrations.py +101 -96
- pulumi_newrelic/cloud/aws_govcloud_link_account.py +71 -70
- pulumi_newrelic/cloud/aws_integrations.py +240 -192
- pulumi_newrelic/cloud/aws_link_account.py +71 -70
- pulumi_newrelic/cloud/azure_integrations.py +180 -132
- pulumi_newrelic/cloud/azure_link_account.py +105 -104
- pulumi_newrelic/cloud/gcp_integrations.py +115 -114
- pulumi_newrelic/cloud/gcp_link_account.py +56 -55
- pulumi_newrelic/cloud/oci_link_account.py +926 -0
- pulumi_newrelic/cloud/outputs.py +1512 -1410
- pulumi_newrelic/config/__init__.py +2 -1
- pulumi_newrelic/config/__init__.pyi +2 -2
- pulumi_newrelic/config/vars.py +15 -15
- pulumi_newrelic/data_partition_rule.py +114 -113
- pulumi_newrelic/entity_tags.py +79 -22
- pulumi_newrelic/events_to_metrics_rule.py +97 -96
- pulumi_newrelic/get_account.py +22 -22
- pulumi_newrelic/get_alert_channel.py +53 -21
- pulumi_newrelic/get_alert_policy.py +52 -26
- pulumi_newrelic/get_application.py +14 -14
- pulumi_newrelic/get_authentication_domain.py +10 -10
- pulumi_newrelic/get_cloud_account.py +22 -22
- pulumi_newrelic/get_entity.py +53 -53
- pulumi_newrelic/get_group.py +22 -22
- pulumi_newrelic/get_key_transaction.py +26 -26
- pulumi_newrelic/get_notification_destination.py +31 -31
- pulumi_newrelic/get_obfuscation_expression.py +16 -16
- pulumi_newrelic/get_service_level_alert_helper.py +54 -54
- pulumi_newrelic/get_test_grok_pattern.py +23 -23
- pulumi_newrelic/get_user.py +22 -22
- pulumi_newrelic/group.py +54 -53
- pulumi_newrelic/infra_alert_condition.py +257 -256
- pulumi_newrelic/insights/__init__.py +2 -1
- pulumi_newrelic/insights/_inputs.py +33 -33
- pulumi_newrelic/insights/event.py +6 -5
- pulumi_newrelic/insights/outputs.py +23 -23
- pulumi_newrelic/key_transaction.py +106 -105
- pulumi_newrelic/log_parsing_rule.py +148 -147
- pulumi_newrelic/monitor_downtime.py +148 -154
- pulumi_newrelic/notification_channel.py +218 -163
- pulumi_newrelic/notification_destination.py +123 -136
- pulumi_newrelic/nrql_alert_condition.py +513 -414
- pulumi_newrelic/nrql_drop_rule.py +108 -147
- pulumi_newrelic/obfuscation_expression.py +71 -70
- pulumi_newrelic/obfuscation_rule.py +91 -90
- pulumi_newrelic/one_dashboard.py +95 -94
- pulumi_newrelic/one_dashboard_json.py +64 -63
- pulumi_newrelic/one_dashboard_raw.py +116 -115
- pulumi_newrelic/outputs.py +3026 -2665
- pulumi_newrelic/pipeline_cloud_rule.py +335 -0
- pulumi_newrelic/plugins/__init__.py +2 -1
- pulumi_newrelic/plugins/_inputs.py +159 -159
- pulumi_newrelic/plugins/application_settings.py +186 -171
- pulumi_newrelic/plugins/outputs.py +109 -109
- pulumi_newrelic/plugins/workload.py +133 -132
- pulumi_newrelic/provider.py +136 -116
- pulumi_newrelic/pulumi-plugin.json +1 -1
- pulumi_newrelic/service_level.py +78 -77
- pulumi_newrelic/synthetics/__init__.py +2 -1
- pulumi_newrelic/synthetics/_inputs.py +128 -128
- pulumi_newrelic/synthetics/alert_condition.py +97 -96
- pulumi_newrelic/synthetics/broken_links_monitor.py +218 -189
- pulumi_newrelic/synthetics/cert_check_monitor.py +226 -197
- pulumi_newrelic/synthetics/get_private_location.py +22 -22
- pulumi_newrelic/synthetics/get_secure_credential.py +20 -20
- pulumi_newrelic/synthetics/monitor.py +399 -370
- pulumi_newrelic/synthetics/multi_location_alert_condition.py +120 -119
- pulumi_newrelic/synthetics/outputs.py +86 -86
- pulumi_newrelic/synthetics/private_location.py +107 -106
- pulumi_newrelic/synthetics/script_monitor.py +385 -294
- pulumi_newrelic/synthetics/secure_credential.py +88 -87
- pulumi_newrelic/synthetics/step_monitor.py +241 -212
- pulumi_newrelic/user.py +71 -70
- pulumi_newrelic/workflow.py +141 -140
- {pulumi_newrelic-5.42.1.dist-info → pulumi_newrelic-5.58.0a1766556761.dist-info}/METADATA +4 -4
- pulumi_newrelic-5.58.0a1766556761.dist-info/RECORD +92 -0
- {pulumi_newrelic-5.42.1.dist-info → pulumi_newrelic-5.58.0a1766556761.dist-info}/WHEEL +1 -1
- pulumi_newrelic-5.42.1.dist-info/RECORD +0 -90
- {pulumi_newrelic-5.42.1.dist-info → pulumi_newrelic-5.58.0a1766556761.dist-info}/top_level.txt +0 -0
|
@@ -1,8 +1,8 @@
|
|
|
1
1
|
# coding=utf-8
|
|
2
|
-
# *** WARNING: this file was generated by
|
|
2
|
+
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
-
import
|
|
5
|
+
import builtins as _builtins
|
|
6
6
|
import warnings
|
|
7
7
|
import sys
|
|
8
8
|
import pulumi
|
|
@@ -21,59 +21,59 @@ __all__ = ['MonitorArgs', 'Monitor']
|
|
|
21
21
|
@pulumi.input_type
|
|
22
22
|
class MonitorArgs:
|
|
23
23
|
def __init__(__self__, *,
|
|
24
|
-
status: pulumi.Input[str],
|
|
25
|
-
type: pulumi.Input[str],
|
|
26
|
-
account_id: Optional[pulumi.Input[str]] = None,
|
|
27
|
-
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
28
|
-
bypass_head_request: Optional[pulumi.Input[bool]] = None,
|
|
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,
|
|
29
29
|
custom_headers: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]]] = None,
|
|
30
|
-
device_orientation: Optional[pulumi.Input[str]] = None,
|
|
31
|
-
device_type: Optional[pulumi.Input[str]] = None,
|
|
32
|
-
devices: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
33
|
-
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[bool]] = None,
|
|
34
|
-
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
35
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
36
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
37
|
-
period: Optional[pulumi.Input[str]] = None,
|
|
38
|
-
runtime_type: Optional[pulumi.Input[str]] = None,
|
|
39
|
-
runtime_type_version: Optional[pulumi.Input[str]] = None,
|
|
40
|
-
script_language: Optional[pulumi.Input[str]] = None,
|
|
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,
|
|
41
41
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]]] = None,
|
|
42
|
-
treat_redirect_as_failure: Optional[pulumi.Input[bool]] = None,
|
|
43
|
-
uri: Optional[pulumi.Input[str]] = None,
|
|
44
|
-
use_unsupported_legacy_runtime: Optional[pulumi.Input[bool]] = None,
|
|
45
|
-
validation_string: Optional[pulumi.Input[str]] = None,
|
|
46
|
-
verify_ssl: Optional[pulumi.Input[bool]] = None):
|
|
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):
|
|
47
47
|
"""
|
|
48
48
|
The set of arguments for constructing a Monitor resource.
|
|
49
|
-
:param pulumi.Input[str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
50
|
-
:param pulumi.Input[str] type: The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
51
|
-
:param pulumi.Input[str] account_id: The account in which the Synthetics monitor will be created.
|
|
52
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
53
|
-
: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.
|
|
54
54
|
|
|
55
55
|
The `BROWSER` monitor type supports the following additional arguments:
|
|
56
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.
|
|
57
|
-
:param pulumi.Input[str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
57
|
+
:param pulumi.Input[_builtins.str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
58
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[str] device_type: Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
59
|
+
:param pulumi.Input[_builtins.str] device_type: Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
60
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[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[bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
63
|
-
:param pulumi.Input[Sequence[pulumi.Input[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[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[str] name: The human-readable identifier for the monitor.
|
|
66
|
-
:param pulumi.Input[str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
67
|
-
:param pulumi.Input[str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
68
|
-
:param pulumi.Input[str] runtime_type_version: The specific version of the runtime type selected (`100`).
|
|
69
|
-
:param pulumi.Input[str] script_language: The programing language that should execute the script.
|
|
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.
|
|
70
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.
|
|
71
71
|
|
|
72
72
|
The `SIMPLE` monitor type supports the following additional arguments:
|
|
73
|
-
:param pulumi.Input[bool] treat_redirect_as_failure: Categorize redirects during a monitor job as a failure.
|
|
74
|
-
:param pulumi.Input[str] uri: The URI the monitor runs against.
|
|
75
|
-
:param pulumi.Input[str] validation_string: Validation text for monitor to search for at given URI.
|
|
76
|
-
: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.
|
|
77
77
|
"""
|
|
78
78
|
pulumi.set(__self__, "status", status)
|
|
79
79
|
pulumi.set(__self__, "type", type)
|
|
@@ -120,57 +120,57 @@ class MonitorArgs:
|
|
|
120
120
|
if verify_ssl is not None:
|
|
121
121
|
pulumi.set(__self__, "verify_ssl", verify_ssl)
|
|
122
122
|
|
|
123
|
-
@property
|
|
123
|
+
@_builtins.property
|
|
124
124
|
@pulumi.getter
|
|
125
|
-
def status(self) -> pulumi.Input[str]:
|
|
125
|
+
def status(self) -> pulumi.Input[_builtins.str]:
|
|
126
126
|
"""
|
|
127
127
|
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
128
128
|
"""
|
|
129
129
|
return pulumi.get(self, "status")
|
|
130
130
|
|
|
131
131
|
@status.setter
|
|
132
|
-
def status(self, value: pulumi.Input[str]):
|
|
132
|
+
def status(self, value: pulumi.Input[_builtins.str]):
|
|
133
133
|
pulumi.set(self, "status", value)
|
|
134
134
|
|
|
135
|
-
@property
|
|
135
|
+
@_builtins.property
|
|
136
136
|
@pulumi.getter
|
|
137
|
-
def type(self) -> pulumi.Input[str]:
|
|
137
|
+
def type(self) -> pulumi.Input[_builtins.str]:
|
|
138
138
|
"""
|
|
139
139
|
The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
140
140
|
"""
|
|
141
141
|
return pulumi.get(self, "type")
|
|
142
142
|
|
|
143
143
|
@type.setter
|
|
144
|
-
def type(self, value: pulumi.Input[str]):
|
|
144
|
+
def type(self, value: pulumi.Input[_builtins.str]):
|
|
145
145
|
pulumi.set(self, "type", value)
|
|
146
146
|
|
|
147
|
-
@property
|
|
147
|
+
@_builtins.property
|
|
148
148
|
@pulumi.getter(name="accountId")
|
|
149
|
-
def account_id(self) -> Optional[pulumi.Input[str]]:
|
|
149
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
150
150
|
"""
|
|
151
151
|
The account in which the Synthetics monitor will be created.
|
|
152
152
|
"""
|
|
153
153
|
return pulumi.get(self, "account_id")
|
|
154
154
|
|
|
155
155
|
@account_id.setter
|
|
156
|
-
def account_id(self, value: Optional[pulumi.Input[str]]):
|
|
156
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
157
157
|
pulumi.set(self, "account_id", value)
|
|
158
158
|
|
|
159
|
-
@property
|
|
159
|
+
@_builtins.property
|
|
160
160
|
@pulumi.getter
|
|
161
|
-
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
161
|
+
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
162
162
|
"""
|
|
163
163
|
The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
164
164
|
"""
|
|
165
165
|
return pulumi.get(self, "browsers")
|
|
166
166
|
|
|
167
167
|
@browsers.setter
|
|
168
|
-
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
168
|
+
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
169
169
|
pulumi.set(self, "browsers", value)
|
|
170
170
|
|
|
171
|
-
@property
|
|
171
|
+
@_builtins.property
|
|
172
172
|
@pulumi.getter(name="bypassHeadRequest")
|
|
173
|
-
def bypass_head_request(self) -> Optional[pulumi.Input[bool]]:
|
|
173
|
+
def bypass_head_request(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
174
174
|
"""
|
|
175
175
|
Monitor should skip default HEAD request and instead use GET verb in check.
|
|
176
176
|
|
|
@@ -179,10 +179,10 @@ class MonitorArgs:
|
|
|
179
179
|
return pulumi.get(self, "bypass_head_request")
|
|
180
180
|
|
|
181
181
|
@bypass_head_request.setter
|
|
182
|
-
def bypass_head_request(self, value: Optional[pulumi.Input[bool]]):
|
|
182
|
+
def bypass_head_request(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
183
183
|
pulumi.set(self, "bypass_head_request", value)
|
|
184
184
|
|
|
185
|
-
@property
|
|
185
|
+
@_builtins.property
|
|
186
186
|
@pulumi.getter(name="customHeaders")
|
|
187
187
|
def custom_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]]]:
|
|
188
188
|
"""
|
|
@@ -194,9 +194,9 @@ class MonitorArgs:
|
|
|
194
194
|
def custom_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]]]):
|
|
195
195
|
pulumi.set(self, "custom_headers", value)
|
|
196
196
|
|
|
197
|
-
@property
|
|
197
|
+
@_builtins.property
|
|
198
198
|
@pulumi.getter(name="deviceOrientation")
|
|
199
|
-
def device_orientation(self) -> Optional[pulumi.Input[str]]:
|
|
199
|
+
def device_orientation(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
200
200
|
"""
|
|
201
201
|
Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
202
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.
|
|
@@ -204,12 +204,12 @@ class MonitorArgs:
|
|
|
204
204
|
return pulumi.get(self, "device_orientation")
|
|
205
205
|
|
|
206
206
|
@device_orientation.setter
|
|
207
|
-
def device_orientation(self, value: Optional[pulumi.Input[str]]):
|
|
207
|
+
def device_orientation(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
208
208
|
pulumi.set(self, "device_orientation", value)
|
|
209
209
|
|
|
210
|
-
@property
|
|
210
|
+
@_builtins.property
|
|
211
211
|
@pulumi.getter(name="deviceType")
|
|
212
|
-
def device_type(self) -> Optional[pulumi.Input[str]]:
|
|
212
|
+
def device_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
213
213
|
"""
|
|
214
214
|
Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
215
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.
|
|
@@ -217,118 +217,118 @@ class MonitorArgs:
|
|
|
217
217
|
return pulumi.get(self, "device_type")
|
|
218
218
|
|
|
219
219
|
@device_type.setter
|
|
220
|
-
def device_type(self, value: Optional[pulumi.Input[str]]):
|
|
220
|
+
def device_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
221
221
|
pulumi.set(self, "device_type", value)
|
|
222
222
|
|
|
223
|
-
@property
|
|
223
|
+
@_builtins.property
|
|
224
224
|
@pulumi.getter
|
|
225
|
-
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
225
|
+
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
226
226
|
"""
|
|
227
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
228
|
"""
|
|
229
229
|
return pulumi.get(self, "devices")
|
|
230
230
|
|
|
231
231
|
@devices.setter
|
|
232
|
-
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
232
|
+
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
233
233
|
pulumi.set(self, "devices", value)
|
|
234
234
|
|
|
235
|
-
@property
|
|
235
|
+
@_builtins.property
|
|
236
236
|
@pulumi.getter(name="enableScreenshotOnFailureAndScript")
|
|
237
|
-
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]]:
|
|
238
238
|
"""
|
|
239
239
|
Capture a screenshot during job execution.
|
|
240
240
|
"""
|
|
241
241
|
return pulumi.get(self, "enable_screenshot_on_failure_and_script")
|
|
242
242
|
|
|
243
243
|
@enable_screenshot_on_failure_and_script.setter
|
|
244
|
-
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]]):
|
|
245
245
|
pulumi.set(self, "enable_screenshot_on_failure_and_script", value)
|
|
246
246
|
|
|
247
|
-
@property
|
|
247
|
+
@_builtins.property
|
|
248
248
|
@pulumi.getter(name="locationsPrivates")
|
|
249
|
-
def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
249
|
+
def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
250
250
|
"""
|
|
251
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.
|
|
252
252
|
"""
|
|
253
253
|
return pulumi.get(self, "locations_privates")
|
|
254
254
|
|
|
255
255
|
@locations_privates.setter
|
|
256
|
-
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]]]]):
|
|
257
257
|
pulumi.set(self, "locations_privates", value)
|
|
258
258
|
|
|
259
|
-
@property
|
|
259
|
+
@_builtins.property
|
|
260
260
|
@pulumi.getter(name="locationsPublics")
|
|
261
|
-
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
261
|
+
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
262
262
|
"""
|
|
263
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.
|
|
264
264
|
"""
|
|
265
265
|
return pulumi.get(self, "locations_publics")
|
|
266
266
|
|
|
267
267
|
@locations_publics.setter
|
|
268
|
-
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]]]]):
|
|
269
269
|
pulumi.set(self, "locations_publics", value)
|
|
270
270
|
|
|
271
|
-
@property
|
|
271
|
+
@_builtins.property
|
|
272
272
|
@pulumi.getter
|
|
273
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
273
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
274
274
|
"""
|
|
275
275
|
The human-readable identifier for the monitor.
|
|
276
276
|
"""
|
|
277
277
|
return pulumi.get(self, "name")
|
|
278
278
|
|
|
279
279
|
@name.setter
|
|
280
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
280
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
281
281
|
pulumi.set(self, "name", value)
|
|
282
282
|
|
|
283
|
-
@property
|
|
283
|
+
@_builtins.property
|
|
284
284
|
@pulumi.getter
|
|
285
|
-
def period(self) -> Optional[pulumi.Input[str]]:
|
|
285
|
+
def period(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
286
286
|
"""
|
|
287
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`.
|
|
288
288
|
"""
|
|
289
289
|
return pulumi.get(self, "period")
|
|
290
290
|
|
|
291
291
|
@period.setter
|
|
292
|
-
def period(self, value: Optional[pulumi.Input[str]]):
|
|
292
|
+
def period(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
293
293
|
pulumi.set(self, "period", value)
|
|
294
294
|
|
|
295
|
-
@property
|
|
295
|
+
@_builtins.property
|
|
296
296
|
@pulumi.getter(name="runtimeType")
|
|
297
|
-
def runtime_type(self) -> Optional[pulumi.Input[str]]:
|
|
297
|
+
def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
298
298
|
"""
|
|
299
299
|
The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
300
300
|
"""
|
|
301
301
|
return pulumi.get(self, "runtime_type")
|
|
302
302
|
|
|
303
303
|
@runtime_type.setter
|
|
304
|
-
def runtime_type(self, value: Optional[pulumi.Input[str]]):
|
|
304
|
+
def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
305
305
|
pulumi.set(self, "runtime_type", value)
|
|
306
306
|
|
|
307
|
-
@property
|
|
307
|
+
@_builtins.property
|
|
308
308
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
309
|
-
def runtime_type_version(self) -> Optional[pulumi.Input[str]]:
|
|
309
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
310
310
|
"""
|
|
311
311
|
The specific version of the runtime type selected (`100`).
|
|
312
312
|
"""
|
|
313
313
|
return pulumi.get(self, "runtime_type_version")
|
|
314
314
|
|
|
315
315
|
@runtime_type_version.setter
|
|
316
|
-
def runtime_type_version(self, value: Optional[pulumi.Input[str]]):
|
|
316
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
317
317
|
pulumi.set(self, "runtime_type_version", value)
|
|
318
318
|
|
|
319
|
-
@property
|
|
319
|
+
@_builtins.property
|
|
320
320
|
@pulumi.getter(name="scriptLanguage")
|
|
321
|
-
def script_language(self) -> Optional[pulumi.Input[str]]:
|
|
321
|
+
def script_language(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
322
322
|
"""
|
|
323
323
|
The programing language that should execute the script.
|
|
324
324
|
"""
|
|
325
325
|
return pulumi.get(self, "script_language")
|
|
326
326
|
|
|
327
327
|
@script_language.setter
|
|
328
|
-
def script_language(self, value: Optional[pulumi.Input[str]]):
|
|
328
|
+
def script_language(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
329
329
|
pulumi.set(self, "script_language", value)
|
|
330
330
|
|
|
331
|
-
@property
|
|
331
|
+
@_builtins.property
|
|
332
332
|
@pulumi.getter
|
|
333
333
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]]]:
|
|
334
334
|
"""
|
|
@@ -342,122 +342,124 @@ class MonitorArgs:
|
|
|
342
342
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]]]):
|
|
343
343
|
pulumi.set(self, "tags", value)
|
|
344
344
|
|
|
345
|
-
@property
|
|
345
|
+
@_builtins.property
|
|
346
346
|
@pulumi.getter(name="treatRedirectAsFailure")
|
|
347
|
-
def treat_redirect_as_failure(self) -> Optional[pulumi.Input[bool]]:
|
|
347
|
+
def treat_redirect_as_failure(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
348
348
|
"""
|
|
349
349
|
Categorize redirects during a monitor job as a failure.
|
|
350
350
|
"""
|
|
351
351
|
return pulumi.get(self, "treat_redirect_as_failure")
|
|
352
352
|
|
|
353
353
|
@treat_redirect_as_failure.setter
|
|
354
|
-
def treat_redirect_as_failure(self, value: Optional[pulumi.Input[bool]]):
|
|
354
|
+
def treat_redirect_as_failure(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
355
355
|
pulumi.set(self, "treat_redirect_as_failure", value)
|
|
356
356
|
|
|
357
|
-
@property
|
|
357
|
+
@_builtins.property
|
|
358
358
|
@pulumi.getter
|
|
359
|
-
def uri(self) -> Optional[pulumi.Input[str]]:
|
|
359
|
+
def uri(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
360
360
|
"""
|
|
361
361
|
The URI the monitor runs against.
|
|
362
362
|
"""
|
|
363
363
|
return pulumi.get(self, "uri")
|
|
364
364
|
|
|
365
365
|
@uri.setter
|
|
366
|
-
def uri(self, value: Optional[pulumi.Input[str]]):
|
|
366
|
+
def uri(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
367
367
|
pulumi.set(self, "uri", value)
|
|
368
368
|
|
|
369
|
-
@property
|
|
369
|
+
@_builtins.property
|
|
370
370
|
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
371
|
-
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[bool]]:
|
|
371
|
+
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
372
372
|
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
373
373
|
|
|
374
374
|
@use_unsupported_legacy_runtime.setter
|
|
375
|
-
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[bool]]):
|
|
375
|
+
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
376
376
|
pulumi.set(self, "use_unsupported_legacy_runtime", value)
|
|
377
377
|
|
|
378
|
-
@property
|
|
378
|
+
@_builtins.property
|
|
379
379
|
@pulumi.getter(name="validationString")
|
|
380
|
-
def validation_string(self) -> Optional[pulumi.Input[str]]:
|
|
380
|
+
def validation_string(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
381
381
|
"""
|
|
382
382
|
Validation text for monitor to search for at given URI.
|
|
383
383
|
"""
|
|
384
384
|
return pulumi.get(self, "validation_string")
|
|
385
385
|
|
|
386
386
|
@validation_string.setter
|
|
387
|
-
def validation_string(self, value: Optional[pulumi.Input[str]]):
|
|
387
|
+
def validation_string(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
388
388
|
pulumi.set(self, "validation_string", value)
|
|
389
389
|
|
|
390
|
-
@property
|
|
390
|
+
@_builtins.property
|
|
391
391
|
@pulumi.getter(name="verifySsl")
|
|
392
|
-
def verify_ssl(self) -> Optional[pulumi.Input[bool]]:
|
|
392
|
+
def verify_ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
393
393
|
"""
|
|
394
394
|
Monitor should validate SSL certificate chain.
|
|
395
395
|
"""
|
|
396
396
|
return pulumi.get(self, "verify_ssl")
|
|
397
397
|
|
|
398
398
|
@verify_ssl.setter
|
|
399
|
-
def verify_ssl(self, value: Optional[pulumi.Input[bool]]):
|
|
399
|
+
def verify_ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
400
400
|
pulumi.set(self, "verify_ssl", value)
|
|
401
401
|
|
|
402
402
|
|
|
403
403
|
@pulumi.input_type
|
|
404
404
|
class _MonitorState:
|
|
405
405
|
def __init__(__self__, *,
|
|
406
|
-
account_id: Optional[pulumi.Input[str]] = None,
|
|
407
|
-
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
408
|
-
bypass_head_request: Optional[pulumi.Input[bool]] = None,
|
|
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,
|
|
409
409
|
custom_headers: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]]] = None,
|
|
410
|
-
device_orientation: Optional[pulumi.Input[str]] = None,
|
|
411
|
-
device_type: Optional[pulumi.Input[str]] = None,
|
|
412
|
-
devices: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
413
|
-
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[bool]] = None,
|
|
414
|
-
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
415
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
416
|
-
|
|
417
|
-
|
|
418
|
-
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
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,
|
|
423
424
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]]] = None,
|
|
424
|
-
treat_redirect_as_failure: Optional[pulumi.Input[bool]] = None,
|
|
425
|
-
type: Optional[pulumi.Input[str]] = None,
|
|
426
|
-
uri: Optional[pulumi.Input[str]] = None,
|
|
427
|
-
use_unsupported_legacy_runtime: Optional[pulumi.Input[bool]] = None,
|
|
428
|
-
validation_string: Optional[pulumi.Input[str]] = None,
|
|
429
|
-
verify_ssl: Optional[pulumi.Input[bool]] = None):
|
|
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):
|
|
430
431
|
"""
|
|
431
432
|
Input properties used for looking up and filtering Monitor resources.
|
|
432
|
-
:param pulumi.Input[str] account_id: The account in which the Synthetics monitor will be created.
|
|
433
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
434
|
-
:param pulumi.Input[bool] bypass_head_request: Monitor should skip default HEAD request and instead use GET verb in check.
|
|
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.
|
|
435
436
|
|
|
436
437
|
The `BROWSER` monitor type supports the following additional arguments:
|
|
437
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.
|
|
438
|
-
:param pulumi.Input[str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
439
|
+
:param pulumi.Input[_builtins.str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
439
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.
|
|
440
|
-
:param pulumi.Input[str] device_type: Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
441
|
+
:param pulumi.Input[_builtins.str] device_type: Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
441
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.
|
|
442
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] devices: The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
443
|
-
:param pulumi.Input[bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
444
|
-
:param pulumi.Input[Sequence[pulumi.Input[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.
|
|
445
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
446
|
-
:param pulumi.Input[str]
|
|
447
|
-
:param pulumi.Input[str]
|
|
448
|
-
:param pulumi.Input[
|
|
449
|
-
:param pulumi.Input[
|
|
450
|
-
:param pulumi.Input[str]
|
|
451
|
-
:param pulumi.Input[str]
|
|
452
|
-
:param pulumi.Input[str]
|
|
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`).
|
|
453
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.
|
|
454
456
|
|
|
455
457
|
The `SIMPLE` monitor type supports the following additional arguments:
|
|
456
|
-
:param pulumi.Input[bool] treat_redirect_as_failure: Categorize redirects during a monitor job as a failure.
|
|
457
|
-
:param pulumi.Input[str] type: The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
458
|
-
:param pulumi.Input[str] uri: The URI the monitor runs against.
|
|
459
|
-
:param pulumi.Input[str] validation_string: Validation text for monitor to search for at given URI.
|
|
460
|
-
: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.
|
|
461
463
|
"""
|
|
462
464
|
if account_id is not None:
|
|
463
465
|
pulumi.set(__self__, "account_id", account_id)
|
|
@@ -479,6 +481,8 @@ class _MonitorState:
|
|
|
479
481
|
pulumi.set(__self__, "locations_privates", locations_privates)
|
|
480
482
|
if locations_publics is not None:
|
|
481
483
|
pulumi.set(__self__, "locations_publics", locations_publics)
|
|
484
|
+
if monitor_id is not None:
|
|
485
|
+
pulumi.set(__self__, "monitor_id", monitor_id)
|
|
482
486
|
if name is not None:
|
|
483
487
|
pulumi.set(__self__, "name", name)
|
|
484
488
|
if period is not None:
|
|
@@ -508,33 +512,33 @@ class _MonitorState:
|
|
|
508
512
|
if verify_ssl is not None:
|
|
509
513
|
pulumi.set(__self__, "verify_ssl", verify_ssl)
|
|
510
514
|
|
|
511
|
-
@property
|
|
515
|
+
@_builtins.property
|
|
512
516
|
@pulumi.getter(name="accountId")
|
|
513
|
-
def account_id(self) -> Optional[pulumi.Input[str]]:
|
|
517
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
514
518
|
"""
|
|
515
519
|
The account in which the Synthetics monitor will be created.
|
|
516
520
|
"""
|
|
517
521
|
return pulumi.get(self, "account_id")
|
|
518
522
|
|
|
519
523
|
@account_id.setter
|
|
520
|
-
def account_id(self, value: Optional[pulumi.Input[str]]):
|
|
524
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
521
525
|
pulumi.set(self, "account_id", value)
|
|
522
526
|
|
|
523
|
-
@property
|
|
527
|
+
@_builtins.property
|
|
524
528
|
@pulumi.getter
|
|
525
|
-
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
529
|
+
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
526
530
|
"""
|
|
527
531
|
The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
528
532
|
"""
|
|
529
533
|
return pulumi.get(self, "browsers")
|
|
530
534
|
|
|
531
535
|
@browsers.setter
|
|
532
|
-
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
536
|
+
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
533
537
|
pulumi.set(self, "browsers", value)
|
|
534
538
|
|
|
535
|
-
@property
|
|
539
|
+
@_builtins.property
|
|
536
540
|
@pulumi.getter(name="bypassHeadRequest")
|
|
537
|
-
def bypass_head_request(self) -> Optional[pulumi.Input[bool]]:
|
|
541
|
+
def bypass_head_request(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
538
542
|
"""
|
|
539
543
|
Monitor should skip default HEAD request and instead use GET verb in check.
|
|
540
544
|
|
|
@@ -543,10 +547,10 @@ class _MonitorState:
|
|
|
543
547
|
return pulumi.get(self, "bypass_head_request")
|
|
544
548
|
|
|
545
549
|
@bypass_head_request.setter
|
|
546
|
-
def bypass_head_request(self, value: Optional[pulumi.Input[bool]]):
|
|
550
|
+
def bypass_head_request(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
547
551
|
pulumi.set(self, "bypass_head_request", value)
|
|
548
552
|
|
|
549
|
-
@property
|
|
553
|
+
@_builtins.property
|
|
550
554
|
@pulumi.getter(name="customHeaders")
|
|
551
555
|
def custom_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]]]:
|
|
552
556
|
"""
|
|
@@ -558,9 +562,9 @@ class _MonitorState:
|
|
|
558
562
|
def custom_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorCustomHeaderArgs']]]]):
|
|
559
563
|
pulumi.set(self, "custom_headers", value)
|
|
560
564
|
|
|
561
|
-
@property
|
|
565
|
+
@_builtins.property
|
|
562
566
|
@pulumi.getter(name="deviceOrientation")
|
|
563
|
-
def device_orientation(self) -> Optional[pulumi.Input[str]]:
|
|
567
|
+
def device_orientation(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
564
568
|
"""
|
|
565
569
|
Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
566
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.
|
|
@@ -568,12 +572,12 @@ class _MonitorState:
|
|
|
568
572
|
return pulumi.get(self, "device_orientation")
|
|
569
573
|
|
|
570
574
|
@device_orientation.setter
|
|
571
|
-
def device_orientation(self, value: Optional[pulumi.Input[str]]):
|
|
575
|
+
def device_orientation(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
572
576
|
pulumi.set(self, "device_orientation", value)
|
|
573
577
|
|
|
574
|
-
@property
|
|
578
|
+
@_builtins.property
|
|
575
579
|
@pulumi.getter(name="deviceType")
|
|
576
|
-
def device_type(self) -> Optional[pulumi.Input[str]]:
|
|
580
|
+
def device_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
577
581
|
"""
|
|
578
582
|
Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
579
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.
|
|
@@ -581,142 +585,154 @@ class _MonitorState:
|
|
|
581
585
|
return pulumi.get(self, "device_type")
|
|
582
586
|
|
|
583
587
|
@device_type.setter
|
|
584
|
-
def device_type(self, value: Optional[pulumi.Input[str]]):
|
|
588
|
+
def device_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
585
589
|
pulumi.set(self, "device_type", value)
|
|
586
590
|
|
|
587
|
-
@property
|
|
591
|
+
@_builtins.property
|
|
588
592
|
@pulumi.getter
|
|
589
|
-
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
593
|
+
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
590
594
|
"""
|
|
591
595
|
The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
592
596
|
"""
|
|
593
597
|
return pulumi.get(self, "devices")
|
|
594
598
|
|
|
595
599
|
@devices.setter
|
|
596
|
-
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
600
|
+
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
597
601
|
pulumi.set(self, "devices", value)
|
|
598
602
|
|
|
599
|
-
@property
|
|
603
|
+
@_builtins.property
|
|
600
604
|
@pulumi.getter(name="enableScreenshotOnFailureAndScript")
|
|
601
|
-
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]]:
|
|
602
606
|
"""
|
|
603
607
|
Capture a screenshot during job execution.
|
|
604
608
|
"""
|
|
605
609
|
return pulumi.get(self, "enable_screenshot_on_failure_and_script")
|
|
606
610
|
|
|
607
611
|
@enable_screenshot_on_failure_and_script.setter
|
|
608
|
-
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]]):
|
|
609
613
|
pulumi.set(self, "enable_screenshot_on_failure_and_script", value)
|
|
610
614
|
|
|
611
|
-
@property
|
|
615
|
+
@_builtins.property
|
|
612
616
|
@pulumi.getter(name="locationsPrivates")
|
|
613
|
-
def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
617
|
+
def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
614
618
|
"""
|
|
615
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.
|
|
616
620
|
"""
|
|
617
621
|
return pulumi.get(self, "locations_privates")
|
|
618
622
|
|
|
619
623
|
@locations_privates.setter
|
|
620
|
-
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]]]]):
|
|
621
625
|
pulumi.set(self, "locations_privates", value)
|
|
622
626
|
|
|
623
|
-
@property
|
|
627
|
+
@_builtins.property
|
|
624
628
|
@pulumi.getter(name="locationsPublics")
|
|
625
|
-
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
629
|
+
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
626
630
|
"""
|
|
627
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.
|
|
628
632
|
"""
|
|
629
633
|
return pulumi.get(self, "locations_publics")
|
|
630
634
|
|
|
631
635
|
@locations_publics.setter
|
|
632
|
-
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]]]]):
|
|
633
637
|
pulumi.set(self, "locations_publics", value)
|
|
634
638
|
|
|
635
|
-
@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
|
|
636
652
|
@pulumi.getter
|
|
637
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
653
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
638
654
|
"""
|
|
639
655
|
The human-readable identifier for the monitor.
|
|
640
656
|
"""
|
|
641
657
|
return pulumi.get(self, "name")
|
|
642
658
|
|
|
643
659
|
@name.setter
|
|
644
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
660
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
645
661
|
pulumi.set(self, "name", value)
|
|
646
662
|
|
|
647
|
-
@property
|
|
663
|
+
@_builtins.property
|
|
648
664
|
@pulumi.getter
|
|
649
|
-
def period(self) -> Optional[pulumi.Input[str]]:
|
|
665
|
+
def period(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
650
666
|
"""
|
|
651
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`.
|
|
652
668
|
"""
|
|
653
669
|
return pulumi.get(self, "period")
|
|
654
670
|
|
|
655
671
|
@period.setter
|
|
656
|
-
def period(self, value: Optional[pulumi.Input[str]]):
|
|
672
|
+
def period(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
657
673
|
pulumi.set(self, "period", value)
|
|
658
674
|
|
|
659
|
-
@property
|
|
675
|
+
@_builtins.property
|
|
660
676
|
@pulumi.getter(name="periodInMinutes")
|
|
661
|
-
def period_in_minutes(self) -> Optional[pulumi.Input[int]]:
|
|
677
|
+
def period_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
662
678
|
"""
|
|
663
679
|
The interval in minutes at which Synthetic monitor should run.
|
|
664
680
|
"""
|
|
665
681
|
return pulumi.get(self, "period_in_minutes")
|
|
666
682
|
|
|
667
683
|
@period_in_minutes.setter
|
|
668
|
-
def period_in_minutes(self, value: Optional[pulumi.Input[int]]):
|
|
684
|
+
def period_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
669
685
|
pulumi.set(self, "period_in_minutes", value)
|
|
670
686
|
|
|
671
|
-
@property
|
|
687
|
+
@_builtins.property
|
|
672
688
|
@pulumi.getter(name="runtimeType")
|
|
673
|
-
def runtime_type(self) -> Optional[pulumi.Input[str]]:
|
|
689
|
+
def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
674
690
|
"""
|
|
675
691
|
The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
676
692
|
"""
|
|
677
693
|
return pulumi.get(self, "runtime_type")
|
|
678
694
|
|
|
679
695
|
@runtime_type.setter
|
|
680
|
-
def runtime_type(self, value: Optional[pulumi.Input[str]]):
|
|
696
|
+
def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
681
697
|
pulumi.set(self, "runtime_type", value)
|
|
682
698
|
|
|
683
|
-
@property
|
|
699
|
+
@_builtins.property
|
|
684
700
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
685
|
-
def runtime_type_version(self) -> Optional[pulumi.Input[str]]:
|
|
701
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
686
702
|
"""
|
|
687
703
|
The specific version of the runtime type selected (`100`).
|
|
688
704
|
"""
|
|
689
705
|
return pulumi.get(self, "runtime_type_version")
|
|
690
706
|
|
|
691
707
|
@runtime_type_version.setter
|
|
692
|
-
def runtime_type_version(self, value: Optional[pulumi.Input[str]]):
|
|
708
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
693
709
|
pulumi.set(self, "runtime_type_version", value)
|
|
694
710
|
|
|
695
|
-
@property
|
|
711
|
+
@_builtins.property
|
|
696
712
|
@pulumi.getter(name="scriptLanguage")
|
|
697
|
-
def script_language(self) -> Optional[pulumi.Input[str]]:
|
|
713
|
+
def script_language(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
698
714
|
"""
|
|
699
715
|
The programing language that should execute the script.
|
|
700
716
|
"""
|
|
701
717
|
return pulumi.get(self, "script_language")
|
|
702
718
|
|
|
703
719
|
@script_language.setter
|
|
704
|
-
def script_language(self, value: Optional[pulumi.Input[str]]):
|
|
720
|
+
def script_language(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
705
721
|
pulumi.set(self, "script_language", value)
|
|
706
722
|
|
|
707
|
-
@property
|
|
723
|
+
@_builtins.property
|
|
708
724
|
@pulumi.getter
|
|
709
|
-
def status(self) -> Optional[pulumi.Input[str]]:
|
|
725
|
+
def status(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
710
726
|
"""
|
|
711
727
|
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
712
728
|
"""
|
|
713
729
|
return pulumi.get(self, "status")
|
|
714
730
|
|
|
715
731
|
@status.setter
|
|
716
|
-
def status(self, value: Optional[pulumi.Input[str]]):
|
|
732
|
+
def status(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
717
733
|
pulumi.set(self, "status", value)
|
|
718
734
|
|
|
719
|
-
@property
|
|
735
|
+
@_builtins.property
|
|
720
736
|
@pulumi.getter
|
|
721
737
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]]]:
|
|
722
738
|
"""
|
|
@@ -730,104 +746,105 @@ class _MonitorState:
|
|
|
730
746
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorTagArgs']]]]):
|
|
731
747
|
pulumi.set(self, "tags", value)
|
|
732
748
|
|
|
733
|
-
@property
|
|
749
|
+
@_builtins.property
|
|
734
750
|
@pulumi.getter(name="treatRedirectAsFailure")
|
|
735
|
-
def treat_redirect_as_failure(self) -> Optional[pulumi.Input[bool]]:
|
|
751
|
+
def treat_redirect_as_failure(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
736
752
|
"""
|
|
737
753
|
Categorize redirects during a monitor job as a failure.
|
|
738
754
|
"""
|
|
739
755
|
return pulumi.get(self, "treat_redirect_as_failure")
|
|
740
756
|
|
|
741
757
|
@treat_redirect_as_failure.setter
|
|
742
|
-
def treat_redirect_as_failure(self, value: Optional[pulumi.Input[bool]]):
|
|
758
|
+
def treat_redirect_as_failure(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
743
759
|
pulumi.set(self, "treat_redirect_as_failure", value)
|
|
744
760
|
|
|
745
|
-
@property
|
|
761
|
+
@_builtins.property
|
|
746
762
|
@pulumi.getter
|
|
747
|
-
def type(self) -> Optional[pulumi.Input[str]]:
|
|
763
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
748
764
|
"""
|
|
749
765
|
The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
750
766
|
"""
|
|
751
767
|
return pulumi.get(self, "type")
|
|
752
768
|
|
|
753
769
|
@type.setter
|
|
754
|
-
def type(self, value: Optional[pulumi.Input[str]]):
|
|
770
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
755
771
|
pulumi.set(self, "type", value)
|
|
756
772
|
|
|
757
|
-
@property
|
|
773
|
+
@_builtins.property
|
|
758
774
|
@pulumi.getter
|
|
759
|
-
def uri(self) -> Optional[pulumi.Input[str]]:
|
|
775
|
+
def uri(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
760
776
|
"""
|
|
761
777
|
The URI the monitor runs against.
|
|
762
778
|
"""
|
|
763
779
|
return pulumi.get(self, "uri")
|
|
764
780
|
|
|
765
781
|
@uri.setter
|
|
766
|
-
def uri(self, value: Optional[pulumi.Input[str]]):
|
|
782
|
+
def uri(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
767
783
|
pulumi.set(self, "uri", value)
|
|
768
784
|
|
|
769
|
-
@property
|
|
785
|
+
@_builtins.property
|
|
770
786
|
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
771
|
-
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[bool]]:
|
|
787
|
+
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
772
788
|
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
773
789
|
|
|
774
790
|
@use_unsupported_legacy_runtime.setter
|
|
775
|
-
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[bool]]):
|
|
791
|
+
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
776
792
|
pulumi.set(self, "use_unsupported_legacy_runtime", value)
|
|
777
793
|
|
|
778
|
-
@property
|
|
794
|
+
@_builtins.property
|
|
779
795
|
@pulumi.getter(name="validationString")
|
|
780
|
-
def validation_string(self) -> Optional[pulumi.Input[str]]:
|
|
796
|
+
def validation_string(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
781
797
|
"""
|
|
782
798
|
Validation text for monitor to search for at given URI.
|
|
783
799
|
"""
|
|
784
800
|
return pulumi.get(self, "validation_string")
|
|
785
801
|
|
|
786
802
|
@validation_string.setter
|
|
787
|
-
def validation_string(self, value: Optional[pulumi.Input[str]]):
|
|
803
|
+
def validation_string(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
788
804
|
pulumi.set(self, "validation_string", value)
|
|
789
805
|
|
|
790
|
-
@property
|
|
806
|
+
@_builtins.property
|
|
791
807
|
@pulumi.getter(name="verifySsl")
|
|
792
|
-
def verify_ssl(self) -> Optional[pulumi.Input[bool]]:
|
|
808
|
+
def verify_ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
793
809
|
"""
|
|
794
810
|
Monitor should validate SSL certificate chain.
|
|
795
811
|
"""
|
|
796
812
|
return pulumi.get(self, "verify_ssl")
|
|
797
813
|
|
|
798
814
|
@verify_ssl.setter
|
|
799
|
-
def verify_ssl(self, value: Optional[pulumi.Input[bool]]):
|
|
815
|
+
def verify_ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
800
816
|
pulumi.set(self, "verify_ssl", value)
|
|
801
817
|
|
|
802
818
|
|
|
819
|
+
@pulumi.type_token("newrelic:synthetics/monitor:Monitor")
|
|
803
820
|
class Monitor(pulumi.CustomResource):
|
|
804
821
|
@overload
|
|
805
822
|
def __init__(__self__,
|
|
806
823
|
resource_name: str,
|
|
807
824
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
808
|
-
account_id: Optional[pulumi.Input[str]] = None,
|
|
809
|
-
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
810
|
-
bypass_head_request: Optional[pulumi.Input[bool]] = None,
|
|
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,
|
|
811
828
|
custom_headers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MonitorCustomHeaderArgs', 'MonitorCustomHeaderArgsDict']]]]] = None,
|
|
812
|
-
device_orientation: Optional[pulumi.Input[str]] = None,
|
|
813
|
-
device_type: Optional[pulumi.Input[str]] = None,
|
|
814
|
-
devices: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
815
|
-
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[bool]] = None,
|
|
816
|
-
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
817
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
818
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
819
|
-
period: Optional[pulumi.Input[str]] = None,
|
|
820
|
-
runtime_type: Optional[pulumi.Input[str]] = None,
|
|
821
|
-
runtime_type_version: Optional[pulumi.Input[str]] = None,
|
|
822
|
-
script_language: Optional[pulumi.Input[str]] = None,
|
|
823
|
-
status: Optional[pulumi.Input[str]] = 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,
|
|
824
841
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MonitorTagArgs', 'MonitorTagArgsDict']]]]] = None,
|
|
825
|
-
treat_redirect_as_failure: Optional[pulumi.Input[bool]] = None,
|
|
826
|
-
type: Optional[pulumi.Input[str]] = None,
|
|
827
|
-
uri: Optional[pulumi.Input[str]] = None,
|
|
828
|
-
use_unsupported_legacy_runtime: Optional[pulumi.Input[bool]] = None,
|
|
829
|
-
validation_string: Optional[pulumi.Input[str]] = None,
|
|
830
|
-
verify_ssl: Optional[pulumi.Input[bool]] = 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,
|
|
831
848
|
__props__=None):
|
|
832
849
|
"""
|
|
833
850
|
## Example Usage
|
|
@@ -981,34 +998,34 @@ class Monitor(pulumi.CustomResource):
|
|
|
981
998
|
|
|
982
999
|
:param str resource_name: The name of the resource.
|
|
983
1000
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
984
|
-
:param pulumi.Input[str] account_id: The account in which the Synthetics monitor will be created.
|
|
985
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
986
|
-
:param pulumi.Input[bool] bypass_head_request: Monitor should skip default HEAD request and instead use GET verb in check.
|
|
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.
|
|
987
1004
|
|
|
988
1005
|
The `BROWSER` monitor type supports the following additional arguments:
|
|
989
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.
|
|
990
|
-
:param pulumi.Input[str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
1007
|
+
:param pulumi.Input[_builtins.str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
991
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.
|
|
992
|
-
:param pulumi.Input[str] device_type: Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
1009
|
+
:param pulumi.Input[_builtins.str] device_type: Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
993
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.
|
|
994
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] devices: The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
995
|
-
:param pulumi.Input[bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
996
|
-
:param pulumi.Input[Sequence[pulumi.Input[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.
|
|
997
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
998
|
-
:param pulumi.Input[str] name: The human-readable identifier for the monitor.
|
|
999
|
-
:param pulumi.Input[str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
1000
|
-
:param pulumi.Input[str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
1001
|
-
:param pulumi.Input[str] runtime_type_version: The specific version of the runtime type selected (`100`).
|
|
1002
|
-
:param pulumi.Input[str] script_language: The programing language that should execute the script.
|
|
1003
|
-
:param pulumi.Input[str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
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`).
|
|
1004
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.
|
|
1005
1022
|
|
|
1006
1023
|
The `SIMPLE` monitor type supports the following additional arguments:
|
|
1007
|
-
:param pulumi.Input[bool] treat_redirect_as_failure: Categorize redirects during a monitor job as a failure.
|
|
1008
|
-
:param pulumi.Input[str] type: The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
1009
|
-
:param pulumi.Input[str] uri: The URI the monitor runs against.
|
|
1010
|
-
:param pulumi.Input[str] validation_string: Validation text for monitor to search for at given URI.
|
|
1011
|
-
: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.
|
|
1012
1029
|
"""
|
|
1013
1030
|
...
|
|
1014
1031
|
@overload
|
|
@@ -1181,29 +1198,29 @@ class Monitor(pulumi.CustomResource):
|
|
|
1181
1198
|
def _internal_init(__self__,
|
|
1182
1199
|
resource_name: str,
|
|
1183
1200
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1184
|
-
account_id: Optional[pulumi.Input[str]] = None,
|
|
1185
|
-
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1186
|
-
bypass_head_request: Optional[pulumi.Input[bool]] = None,
|
|
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,
|
|
1187
1204
|
custom_headers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MonitorCustomHeaderArgs', 'MonitorCustomHeaderArgsDict']]]]] = None,
|
|
1188
|
-
device_orientation: Optional[pulumi.Input[str]] = None,
|
|
1189
|
-
device_type: Optional[pulumi.Input[str]] = None,
|
|
1190
|
-
devices: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1191
|
-
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[bool]] = None,
|
|
1192
|
-
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1193
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1194
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
1195
|
-
period: Optional[pulumi.Input[str]] = None,
|
|
1196
|
-
runtime_type: Optional[pulumi.Input[str]] = None,
|
|
1197
|
-
runtime_type_version: Optional[pulumi.Input[str]] = None,
|
|
1198
|
-
script_language: Optional[pulumi.Input[str]] = None,
|
|
1199
|
-
status: Optional[pulumi.Input[str]] = 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,
|
|
1200
1217
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MonitorTagArgs', 'MonitorTagArgsDict']]]]] = None,
|
|
1201
|
-
treat_redirect_as_failure: Optional[pulumi.Input[bool]] = None,
|
|
1202
|
-
type: Optional[pulumi.Input[str]] = None,
|
|
1203
|
-
uri: Optional[pulumi.Input[str]] = None,
|
|
1204
|
-
use_unsupported_legacy_runtime: Optional[pulumi.Input[bool]] = None,
|
|
1205
|
-
validation_string: Optional[pulumi.Input[str]] = None,
|
|
1206
|
-
verify_ssl: Optional[pulumi.Input[bool]] = 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,
|
|
1207
1224
|
__props__=None):
|
|
1208
1225
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1209
1226
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -1240,6 +1257,7 @@ class Monitor(pulumi.CustomResource):
|
|
|
1240
1257
|
__props__.__dict__["use_unsupported_legacy_runtime"] = use_unsupported_legacy_runtime
|
|
1241
1258
|
__props__.__dict__["validation_string"] = validation_string
|
|
1242
1259
|
__props__.__dict__["verify_ssl"] = verify_ssl
|
|
1260
|
+
__props__.__dict__["monitor_id"] = None
|
|
1243
1261
|
__props__.__dict__["period_in_minutes"] = None
|
|
1244
1262
|
super(Monitor, __self__).__init__(
|
|
1245
1263
|
'newrelic:synthetics/monitor:Monitor',
|
|
@@ -1251,30 +1269,31 @@ class Monitor(pulumi.CustomResource):
|
|
|
1251
1269
|
def get(resource_name: str,
|
|
1252
1270
|
id: pulumi.Input[str],
|
|
1253
1271
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1254
|
-
account_id: Optional[pulumi.Input[str]] = None,
|
|
1255
|
-
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1256
|
-
bypass_head_request: Optional[pulumi.Input[bool]] = None,
|
|
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,
|
|
1257
1275
|
custom_headers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MonitorCustomHeaderArgs', 'MonitorCustomHeaderArgsDict']]]]] = None,
|
|
1258
|
-
device_orientation: Optional[pulumi.Input[str]] = None,
|
|
1259
|
-
device_type: Optional[pulumi.Input[str]] = None,
|
|
1260
|
-
devices: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1261
|
-
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[bool]] = None,
|
|
1262
|
-
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1263
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1264
|
-
|
|
1265
|
-
|
|
1266
|
-
|
|
1267
|
-
|
|
1268
|
-
|
|
1269
|
-
|
|
1270
|
-
|
|
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,
|
|
1271
1290
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['MonitorTagArgs', 'MonitorTagArgsDict']]]]] = None,
|
|
1272
|
-
treat_redirect_as_failure: Optional[pulumi.Input[bool]] = None,
|
|
1273
|
-
type: Optional[pulumi.Input[str]] = None,
|
|
1274
|
-
uri: Optional[pulumi.Input[str]] = None,
|
|
1275
|
-
use_unsupported_legacy_runtime: Optional[pulumi.Input[bool]] = None,
|
|
1276
|
-
validation_string: Optional[pulumi.Input[str]] = None,
|
|
1277
|
-
verify_ssl: Optional[pulumi.Input[bool]] = None) -> 'Monitor':
|
|
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':
|
|
1278
1297
|
"""
|
|
1279
1298
|
Get an existing Monitor resource's state with the given name, id, and optional extra
|
|
1280
1299
|
properties used to qualify the lookup.
|
|
@@ -1282,35 +1301,36 @@ class Monitor(pulumi.CustomResource):
|
|
|
1282
1301
|
:param str resource_name: The unique name of the resulting resource.
|
|
1283
1302
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1284
1303
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1285
|
-
:param pulumi.Input[str] account_id: The account in which the Synthetics monitor will be created.
|
|
1286
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
1287
|
-
:param pulumi.Input[bool] bypass_head_request: Monitor should skip default HEAD request and instead use GET verb in check.
|
|
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.
|
|
1288
1307
|
|
|
1289
1308
|
The `BROWSER` monitor type supports the following additional arguments:
|
|
1290
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.
|
|
1291
|
-
:param pulumi.Input[str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
1310
|
+
:param pulumi.Input[_builtins.str] device_orientation: Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
1292
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.
|
|
1293
|
-
:param pulumi.Input[str] device_type: Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
1312
|
+
:param pulumi.Input[_builtins.str] device_type: Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
1294
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.
|
|
1295
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] devices: The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
1296
|
-
:param pulumi.Input[bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
1297
|
-
:param pulumi.Input[Sequence[pulumi.Input[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.
|
|
1298
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
1299
|
-
:param pulumi.Input[str]
|
|
1300
|
-
:param pulumi.Input[str]
|
|
1301
|
-
:param pulumi.Input[
|
|
1302
|
-
:param pulumi.Input[
|
|
1303
|
-
:param pulumi.Input[str]
|
|
1304
|
-
:param pulumi.Input[str]
|
|
1305
|
-
:param pulumi.Input[str]
|
|
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`).
|
|
1306
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.
|
|
1307
1327
|
|
|
1308
1328
|
The `SIMPLE` monitor type supports the following additional arguments:
|
|
1309
|
-
:param pulumi.Input[bool] treat_redirect_as_failure: Categorize redirects during a monitor job as a failure.
|
|
1310
|
-
:param pulumi.Input[str] type: The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
1311
|
-
:param pulumi.Input[str] uri: The URI the monitor runs against.
|
|
1312
|
-
:param pulumi.Input[str] validation_string: Validation text for monitor to search for at given URI.
|
|
1313
|
-
: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.
|
|
1314
1334
|
"""
|
|
1315
1335
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
1316
1336
|
|
|
@@ -1326,6 +1346,7 @@ class Monitor(pulumi.CustomResource):
|
|
|
1326
1346
|
__props__.__dict__["enable_screenshot_on_failure_and_script"] = enable_screenshot_on_failure_and_script
|
|
1327
1347
|
__props__.__dict__["locations_privates"] = locations_privates
|
|
1328
1348
|
__props__.__dict__["locations_publics"] = locations_publics
|
|
1349
|
+
__props__.__dict__["monitor_id"] = monitor_id
|
|
1329
1350
|
__props__.__dict__["name"] = name
|
|
1330
1351
|
__props__.__dict__["period"] = period
|
|
1331
1352
|
__props__.__dict__["period_in_minutes"] = period_in_minutes
|
|
@@ -1342,25 +1363,25 @@ class Monitor(pulumi.CustomResource):
|
|
|
1342
1363
|
__props__.__dict__["verify_ssl"] = verify_ssl
|
|
1343
1364
|
return Monitor(resource_name, opts=opts, __props__=__props__)
|
|
1344
1365
|
|
|
1345
|
-
@property
|
|
1366
|
+
@_builtins.property
|
|
1346
1367
|
@pulumi.getter(name="accountId")
|
|
1347
|
-
def account_id(self) -> pulumi.Output[str]:
|
|
1368
|
+
def account_id(self) -> pulumi.Output[_builtins.str]:
|
|
1348
1369
|
"""
|
|
1349
1370
|
The account in which the Synthetics monitor will be created.
|
|
1350
1371
|
"""
|
|
1351
1372
|
return pulumi.get(self, "account_id")
|
|
1352
1373
|
|
|
1353
|
-
@property
|
|
1374
|
+
@_builtins.property
|
|
1354
1375
|
@pulumi.getter
|
|
1355
|
-
def browsers(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1376
|
+
def browsers(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1356
1377
|
"""
|
|
1357
1378
|
The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
1358
1379
|
"""
|
|
1359
1380
|
return pulumi.get(self, "browsers")
|
|
1360
1381
|
|
|
1361
|
-
@property
|
|
1382
|
+
@_builtins.property
|
|
1362
1383
|
@pulumi.getter(name="bypassHeadRequest")
|
|
1363
|
-
def bypass_head_request(self) -> pulumi.Output[Optional[bool]]:
|
|
1384
|
+
def bypass_head_request(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1364
1385
|
"""
|
|
1365
1386
|
Monitor should skip default HEAD request and instead use GET verb in check.
|
|
1366
1387
|
|
|
@@ -1368,7 +1389,7 @@ class Monitor(pulumi.CustomResource):
|
|
|
1368
1389
|
"""
|
|
1369
1390
|
return pulumi.get(self, "bypass_head_request")
|
|
1370
1391
|
|
|
1371
|
-
@property
|
|
1392
|
+
@_builtins.property
|
|
1372
1393
|
@pulumi.getter(name="customHeaders")
|
|
1373
1394
|
def custom_headers(self) -> pulumi.Output[Optional[Sequence['outputs.MonitorCustomHeader']]]:
|
|
1374
1395
|
"""
|
|
@@ -1376,113 +1397,121 @@ class Monitor(pulumi.CustomResource):
|
|
|
1376
1397
|
"""
|
|
1377
1398
|
return pulumi.get(self, "custom_headers")
|
|
1378
1399
|
|
|
1379
|
-
@property
|
|
1400
|
+
@_builtins.property
|
|
1380
1401
|
@pulumi.getter(name="deviceOrientation")
|
|
1381
|
-
def device_orientation(self) -> pulumi.Output[Optional[str]]:
|
|
1402
|
+
def device_orientation(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1382
1403
|
"""
|
|
1383
1404
|
Device emulation orientation field. Valid values are `LANDSCAPE` and `PORTRAIT`.
|
|
1384
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.
|
|
1385
1406
|
"""
|
|
1386
1407
|
return pulumi.get(self, "device_orientation")
|
|
1387
1408
|
|
|
1388
|
-
@property
|
|
1409
|
+
@_builtins.property
|
|
1389
1410
|
@pulumi.getter(name="deviceType")
|
|
1390
|
-
def device_type(self) -> pulumi.Output[Optional[str]]:
|
|
1411
|
+
def device_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1391
1412
|
"""
|
|
1392
1413
|
Device emulation type field. Valid values are `MOBILE` and `TABLET`.
|
|
1393
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.
|
|
1394
1415
|
"""
|
|
1395
1416
|
return pulumi.get(self, "device_type")
|
|
1396
1417
|
|
|
1397
|
-
@property
|
|
1418
|
+
@_builtins.property
|
|
1398
1419
|
@pulumi.getter
|
|
1399
|
-
def devices(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1420
|
+
def devices(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1400
1421
|
"""
|
|
1401
1422
|
The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
1402
1423
|
"""
|
|
1403
1424
|
return pulumi.get(self, "devices")
|
|
1404
1425
|
|
|
1405
|
-
@property
|
|
1426
|
+
@_builtins.property
|
|
1406
1427
|
@pulumi.getter(name="enableScreenshotOnFailureAndScript")
|
|
1407
|
-
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]]:
|
|
1408
1429
|
"""
|
|
1409
1430
|
Capture a screenshot during job execution.
|
|
1410
1431
|
"""
|
|
1411
1432
|
return pulumi.get(self, "enable_screenshot_on_failure_and_script")
|
|
1412
1433
|
|
|
1413
|
-
@property
|
|
1434
|
+
@_builtins.property
|
|
1414
1435
|
@pulumi.getter(name="locationsPrivates")
|
|
1415
|
-
def locations_privates(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1436
|
+
def locations_privates(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1416
1437
|
"""
|
|
1417
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.
|
|
1418
1439
|
"""
|
|
1419
1440
|
return pulumi.get(self, "locations_privates")
|
|
1420
1441
|
|
|
1421
|
-
@property
|
|
1442
|
+
@_builtins.property
|
|
1422
1443
|
@pulumi.getter(name="locationsPublics")
|
|
1423
|
-
def locations_publics(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1444
|
+
def locations_publics(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1424
1445
|
"""
|
|
1425
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.
|
|
1426
1447
|
"""
|
|
1427
1448
|
return pulumi.get(self, "locations_publics")
|
|
1428
1449
|
|
|
1429
|
-
@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
|
|
1430
1459
|
@pulumi.getter
|
|
1431
|
-
def name(self) -> pulumi.Output[str]:
|
|
1460
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
1432
1461
|
"""
|
|
1433
1462
|
The human-readable identifier for the monitor.
|
|
1434
1463
|
"""
|
|
1435
1464
|
return pulumi.get(self, "name")
|
|
1436
1465
|
|
|
1437
|
-
@property
|
|
1466
|
+
@_builtins.property
|
|
1438
1467
|
@pulumi.getter
|
|
1439
|
-
def period(self) -> pulumi.Output[str]:
|
|
1468
|
+
def period(self) -> pulumi.Output[_builtins.str]:
|
|
1440
1469
|
"""
|
|
1441
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`.
|
|
1442
1471
|
"""
|
|
1443
1472
|
return pulumi.get(self, "period")
|
|
1444
1473
|
|
|
1445
|
-
@property
|
|
1474
|
+
@_builtins.property
|
|
1446
1475
|
@pulumi.getter(name="periodInMinutes")
|
|
1447
|
-
def period_in_minutes(self) -> pulumi.Output[int]:
|
|
1476
|
+
def period_in_minutes(self) -> pulumi.Output[_builtins.int]:
|
|
1448
1477
|
"""
|
|
1449
1478
|
The interval in minutes at which Synthetic monitor should run.
|
|
1450
1479
|
"""
|
|
1451
1480
|
return pulumi.get(self, "period_in_minutes")
|
|
1452
1481
|
|
|
1453
|
-
@property
|
|
1482
|
+
@_builtins.property
|
|
1454
1483
|
@pulumi.getter(name="runtimeType")
|
|
1455
|
-
def runtime_type(self) -> pulumi.Output[Optional[str]]:
|
|
1484
|
+
def runtime_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1456
1485
|
"""
|
|
1457
1486
|
The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
1458
1487
|
"""
|
|
1459
1488
|
return pulumi.get(self, "runtime_type")
|
|
1460
1489
|
|
|
1461
|
-
@property
|
|
1490
|
+
@_builtins.property
|
|
1462
1491
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
1463
|
-
def runtime_type_version(self) -> pulumi.Output[Optional[str]]:
|
|
1492
|
+
def runtime_type_version(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1464
1493
|
"""
|
|
1465
1494
|
The specific version of the runtime type selected (`100`).
|
|
1466
1495
|
"""
|
|
1467
1496
|
return pulumi.get(self, "runtime_type_version")
|
|
1468
1497
|
|
|
1469
|
-
@property
|
|
1498
|
+
@_builtins.property
|
|
1470
1499
|
@pulumi.getter(name="scriptLanguage")
|
|
1471
|
-
def script_language(self) -> pulumi.Output[Optional[str]]:
|
|
1500
|
+
def script_language(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1472
1501
|
"""
|
|
1473
1502
|
The programing language that should execute the script.
|
|
1474
1503
|
"""
|
|
1475
1504
|
return pulumi.get(self, "script_language")
|
|
1476
1505
|
|
|
1477
|
-
@property
|
|
1506
|
+
@_builtins.property
|
|
1478
1507
|
@pulumi.getter
|
|
1479
|
-
def status(self) -> pulumi.Output[str]:
|
|
1508
|
+
def status(self) -> pulumi.Output[_builtins.str]:
|
|
1480
1509
|
"""
|
|
1481
1510
|
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
1482
1511
|
"""
|
|
1483
1512
|
return pulumi.get(self, "status")
|
|
1484
1513
|
|
|
1485
|
-
@property
|
|
1514
|
+
@_builtins.property
|
|
1486
1515
|
@pulumi.getter
|
|
1487
1516
|
def tags(self) -> pulumi.Output[Optional[Sequence['outputs.MonitorTag']]]:
|
|
1488
1517
|
"""
|
|
@@ -1492,46 +1521,46 @@ class Monitor(pulumi.CustomResource):
|
|
|
1492
1521
|
"""
|
|
1493
1522
|
return pulumi.get(self, "tags")
|
|
1494
1523
|
|
|
1495
|
-
@property
|
|
1524
|
+
@_builtins.property
|
|
1496
1525
|
@pulumi.getter(name="treatRedirectAsFailure")
|
|
1497
|
-
def treat_redirect_as_failure(self) -> pulumi.Output[Optional[bool]]:
|
|
1526
|
+
def treat_redirect_as_failure(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1498
1527
|
"""
|
|
1499
1528
|
Categorize redirects during a monitor job as a failure.
|
|
1500
1529
|
"""
|
|
1501
1530
|
return pulumi.get(self, "treat_redirect_as_failure")
|
|
1502
1531
|
|
|
1503
|
-
@property
|
|
1532
|
+
@_builtins.property
|
|
1504
1533
|
@pulumi.getter
|
|
1505
|
-
def type(self) -> pulumi.Output[str]:
|
|
1534
|
+
def type(self) -> pulumi.Output[_builtins.str]:
|
|
1506
1535
|
"""
|
|
1507
1536
|
The monitor type. Valid values are `SIMPLE` and `BROWSER`.
|
|
1508
1537
|
"""
|
|
1509
1538
|
return pulumi.get(self, "type")
|
|
1510
1539
|
|
|
1511
|
-
@property
|
|
1540
|
+
@_builtins.property
|
|
1512
1541
|
@pulumi.getter
|
|
1513
|
-
def uri(self) -> pulumi.Output[Optional[str]]:
|
|
1542
|
+
def uri(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1514
1543
|
"""
|
|
1515
1544
|
The URI the monitor runs against.
|
|
1516
1545
|
"""
|
|
1517
1546
|
return pulumi.get(self, "uri")
|
|
1518
1547
|
|
|
1519
|
-
@property
|
|
1548
|
+
@_builtins.property
|
|
1520
1549
|
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
1521
|
-
def use_unsupported_legacy_runtime(self) -> pulumi.Output[Optional[bool]]:
|
|
1550
|
+
def use_unsupported_legacy_runtime(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1522
1551
|
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
1523
1552
|
|
|
1524
|
-
@property
|
|
1553
|
+
@_builtins.property
|
|
1525
1554
|
@pulumi.getter(name="validationString")
|
|
1526
|
-
def validation_string(self) -> pulumi.Output[Optional[str]]:
|
|
1555
|
+
def validation_string(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1527
1556
|
"""
|
|
1528
1557
|
Validation text for monitor to search for at given URI.
|
|
1529
1558
|
"""
|
|
1530
1559
|
return pulumi.get(self, "validation_string")
|
|
1531
1560
|
|
|
1532
|
-
@property
|
|
1561
|
+
@_builtins.property
|
|
1533
1562
|
@pulumi.getter(name="verifySsl")
|
|
1534
|
-
def verify_ssl(self) -> pulumi.Output[Optional[bool]]:
|
|
1563
|
+
def verify_ssl(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1535
1564
|
"""
|
|
1536
1565
|
Monitor should validate SSL certificate chain.
|
|
1537
1566
|
"""
|