pulumi-newrelic 5.22.0__py3-none-any.whl → 5.58.0a1763707205__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of pulumi-newrelic might be problematic. Click here for more details.
- pulumi_newrelic/__init__.py +28 -1
- pulumi_newrelic/_inputs.py +10385 -2976
- pulumi_newrelic/_utilities.py +50 -10
- pulumi_newrelic/account_management.py +48 -42
- pulumi_newrelic/alert_channel.py +165 -175
- pulumi_newrelic/alert_condition.py +307 -319
- pulumi_newrelic/alert_muting_rule.py +193 -140
- pulumi_newrelic/alert_policy.py +121 -117
- pulumi_newrelic/alert_policy_channel.py +89 -79
- pulumi_newrelic/api_access_key.py +195 -193
- pulumi_newrelic/browser_application.py +120 -114
- pulumi_newrelic/cloud/__init__.py +3 -1
- pulumi_newrelic/cloud/_inputs.py +4267 -2714
- pulumi_newrelic/cloud/aws_govcloud_integrations.py +206 -196
- pulumi_newrelic/cloud/aws_govcloud_link_account.py +143 -228
- pulumi_newrelic/cloud/aws_integrations.py +510 -1490
- pulumi_newrelic/cloud/aws_link_account.py +80 -76
- pulumi_newrelic/cloud/azure_integrations.py +673 -587
- pulumi_newrelic/cloud/azure_link_account.py +121 -117
- pulumi_newrelic/cloud/gcp_integrations.py +428 -408
- pulumi_newrelic/cloud/gcp_link_account.py +65 -61
- pulumi_newrelic/cloud/oci_link_account.py +926 -0
- pulumi_newrelic/cloud/outputs.py +1678 -2321
- pulumi_newrelic/config/__init__.py +2 -1
- pulumi_newrelic/config/__init__.pyi +8 -3
- pulumi_newrelic/config/vars.py +22 -17
- pulumi_newrelic/data_partition_rule.py +119 -117
- pulumi_newrelic/entity_tags.py +111 -53
- pulumi_newrelic/events_to_metrics_rule.py +106 -102
- pulumi_newrelic/get_account.py +41 -33
- pulumi_newrelic/get_alert_channel.py +73 -28
- pulumi_newrelic/get_alert_policy.py +82 -33
- pulumi_newrelic/get_application.py +51 -43
- pulumi_newrelic/get_authentication_domain.py +27 -23
- pulumi_newrelic/get_cloud_account.py +43 -35
- pulumi_newrelic/get_entity.py +126 -183
- pulumi_newrelic/get_group.py +76 -31
- pulumi_newrelic/get_key_transaction.py +117 -42
- pulumi_newrelic/get_notification_destination.py +75 -38
- pulumi_newrelic/get_obfuscation_expression.py +47 -39
- pulumi_newrelic/get_service_level_alert_helper.py +189 -171
- pulumi_newrelic/get_test_grok_pattern.py +47 -36
- pulumi_newrelic/get_user.py +39 -31
- pulumi_newrelic/group.py +59 -199
- pulumi_newrelic/infra_alert_condition.py +399 -405
- pulumi_newrelic/insights/__init__.py +2 -1
- pulumi_newrelic/insights/_inputs.py +71 -28
- pulumi_newrelic/insights/event.py +54 -52
- pulumi_newrelic/insights/outputs.py +28 -23
- pulumi_newrelic/key_transaction.py +465 -0
- pulumi_newrelic/log_parsing_rule.py +159 -157
- pulumi_newrelic/monitor_downtime.py +311 -331
- pulumi_newrelic/notification_channel.py +534 -464
- pulumi_newrelic/notification_destination.py +238 -141
- pulumi_newrelic/nrql_alert_condition.py +820 -614
- pulumi_newrelic/nrql_drop_rule.py +113 -151
- pulumi_newrelic/obfuscation_expression.py +80 -76
- pulumi_newrelic/obfuscation_rule.py +115 -109
- pulumi_newrelic/one_dashboard.py +110 -104
- pulumi_newrelic/one_dashboard_json.py +69 -63
- pulumi_newrelic/one_dashboard_raw.py +212 -206
- pulumi_newrelic/outputs.py +4936 -2234
- pulumi_newrelic/pipeline_cloud_rule.py +335 -0
- pulumi_newrelic/plugins/__init__.py +2 -1
- pulumi_newrelic/plugins/_inputs.py +519 -89
- pulumi_newrelic/plugins/application_settings.py +463 -187
- pulumi_newrelic/plugins/outputs.py +336 -74
- pulumi_newrelic/plugins/workload.py +313 -189
- pulumi_newrelic/provider.py +156 -142
- pulumi_newrelic/pulumi-plugin.json +2 -1
- pulumi_newrelic/service_level.py +263 -263
- pulumi_newrelic/synthetics/__init__.py +2 -1
- pulumi_newrelic/synthetics/_inputs.py +265 -108
- pulumi_newrelic/synthetics/alert_condition.py +170 -180
- pulumi_newrelic/synthetics/broken_links_monitor.py +297 -249
- pulumi_newrelic/synthetics/cert_check_monitor.py +306 -258
- pulumi_newrelic/synthetics/get_private_location.py +51 -47
- pulumi_newrelic/synthetics/get_secure_credential.py +39 -31
- pulumi_newrelic/synthetics/monitor.py +658 -460
- pulumi_newrelic/synthetics/multi_location_alert_condition.py +211 -205
- pulumi_newrelic/synthetics/outputs.py +92 -87
- pulumi_newrelic/synthetics/private_location.py +118 -112
- pulumi_newrelic/synthetics/script_monitor.py +613 -373
- pulumi_newrelic/synthetics/secure_credential.py +97 -95
- pulumi_newrelic/synthetics/step_monitor.py +445 -275
- pulumi_newrelic/user.py +84 -80
- pulumi_newrelic/workflow.py +336 -322
- {pulumi_newrelic-5.22.0.dist-info → pulumi_newrelic-5.58.0a1763707205.dist-info}/METADATA +7 -6
- pulumi_newrelic-5.58.0a1763707205.dist-info/RECORD +92 -0
- {pulumi_newrelic-5.22.0.dist-info → pulumi_newrelic-5.58.0a1763707205.dist-info}/WHEEL +1 -1
- pulumi_newrelic-5.22.0.dist-info/RECORD +0 -89
- {pulumi_newrelic-5.22.0.dist-info → pulumi_newrelic-5.58.0a1763707205.dist-info}/top_level.txt +0 -0
|
@@ -1,12 +1,17 @@
|
|
|
1
1
|
# coding=utf-8
|
|
2
|
-
# *** WARNING: this file was generated by
|
|
2
|
+
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
-
import
|
|
5
|
+
import builtins as _builtins
|
|
6
6
|
import warnings
|
|
7
|
+
import sys
|
|
7
8
|
import pulumi
|
|
8
9
|
import pulumi.runtime
|
|
9
10
|
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
10
15
|
from .. import _utilities
|
|
11
16
|
from . import outputs
|
|
12
17
|
from ._inputs import *
|
|
@@ -16,31 +21,34 @@ __all__ = ['StepMonitorArgs', 'StepMonitor']
|
|
|
16
21
|
@pulumi.input_type
|
|
17
22
|
class StepMonitorArgs:
|
|
18
23
|
def __init__(__self__, *,
|
|
19
|
-
period: pulumi.Input[str],
|
|
20
|
-
status: pulumi.Input[str],
|
|
24
|
+
period: pulumi.Input[_builtins.str],
|
|
25
|
+
status: pulumi.Input[_builtins.str],
|
|
21
26
|
steps: pulumi.Input[Sequence[pulumi.Input['StepMonitorStepArgs']]],
|
|
22
|
-
account_id: Optional[pulumi.Input[
|
|
23
|
-
|
|
27
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
28
|
+
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
29
|
+
devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
30
|
+
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
24
31
|
location_privates: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorLocationPrivateArgs']]]] = None,
|
|
25
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
26
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
27
|
-
runtime_type: Optional[pulumi.Input[str]] = None,
|
|
28
|
-
runtime_type_version: Optional[pulumi.Input[str]] = None,
|
|
29
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]]] = None
|
|
32
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
33
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
34
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
35
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
36
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]]] = None,
|
|
37
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
30
38
|
"""
|
|
31
39
|
The set of arguments for constructing a StepMonitor resource.
|
|
32
|
-
:param pulumi.Input[str] period: The interval at which this monitor should run. Valid values are EVERY_MINUTE
|
|
33
|
-
:param pulumi.Input[str] status: The monitor
|
|
40
|
+
: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`.
|
|
41
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
34
42
|
:param pulumi.Input[Sequence[pulumi.Input['StepMonitorStepArgs']]] steps: The steps that make up the script the monitor will run. See Nested steps blocks below for details.
|
|
35
|
-
:param pulumi.Input[
|
|
36
|
-
:param pulumi.Input[
|
|
43
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
44
|
+
: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`.
|
|
45
|
+
: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`.
|
|
46
|
+
:param pulumi.Input[_builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
37
47
|
:param pulumi.Input[Sequence[pulumi.Input['StepMonitorLocationPrivateArgs']]] location_privates: The location the monitor will run from. At least one of `locations_public` or `location_private` is required. See Nested locations_private blocks below for details.
|
|
38
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_publics: The location the monitor will run from.
|
|
39
|
-
:param pulumi.Input[str] name: The name for the monitor.
|
|
40
|
-
:param pulumi.Input[str] runtime_type: The runtime that the monitor will use to run jobs.
|
|
41
|
-
:param pulumi.Input[str] runtime_type_version: The specific version of the runtime type
|
|
42
|
-
|
|
43
|
-
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `CHROME_BROWSER` and `100` respectively. In order to run the monitor in the new runtime, both `runtime_type` and `runtime_type_version` need to be specified; however, specifying neither of these attributes would set this monitor to use the legacy runtime. It may also be noted that the runtime opted for would only be effective with private locations. For public locations, all traffic has been shifted to the new runtime, irrespective of the selection made.
|
|
48
|
+
: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.
|
|
49
|
+
:param pulumi.Input[_builtins.str] name: The name for the monitor.
|
|
50
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
51
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific semver version of the runtime type.
|
|
44
52
|
:param pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
45
53
|
"""
|
|
46
54
|
pulumi.set(__self__, "period", period)
|
|
@@ -48,6 +56,10 @@ class StepMonitorArgs:
|
|
|
48
56
|
pulumi.set(__self__, "steps", steps)
|
|
49
57
|
if account_id is not None:
|
|
50
58
|
pulumi.set(__self__, "account_id", account_id)
|
|
59
|
+
if browsers is not None:
|
|
60
|
+
pulumi.set(__self__, "browsers", browsers)
|
|
61
|
+
if devices is not None:
|
|
62
|
+
pulumi.set(__self__, "devices", devices)
|
|
51
63
|
if enable_screenshot_on_failure_and_script is not None:
|
|
52
64
|
pulumi.set(__self__, "enable_screenshot_on_failure_and_script", enable_screenshot_on_failure_and_script)
|
|
53
65
|
if location_privates is not None:
|
|
@@ -62,32 +74,34 @@ class StepMonitorArgs:
|
|
|
62
74
|
pulumi.set(__self__, "runtime_type_version", runtime_type_version)
|
|
63
75
|
if tags is not None:
|
|
64
76
|
pulumi.set(__self__, "tags", tags)
|
|
77
|
+
if use_unsupported_legacy_runtime is not None:
|
|
78
|
+
pulumi.set(__self__, "use_unsupported_legacy_runtime", use_unsupported_legacy_runtime)
|
|
65
79
|
|
|
66
|
-
@property
|
|
80
|
+
@_builtins.property
|
|
67
81
|
@pulumi.getter
|
|
68
|
-
def period(self) -> pulumi.Input[str]:
|
|
82
|
+
def period(self) -> pulumi.Input[_builtins.str]:
|
|
69
83
|
"""
|
|
70
|
-
The interval at which this monitor should run. Valid values are EVERY_MINUTE
|
|
84
|
+
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`.
|
|
71
85
|
"""
|
|
72
86
|
return pulumi.get(self, "period")
|
|
73
87
|
|
|
74
88
|
@period.setter
|
|
75
|
-
def period(self, value: pulumi.Input[str]):
|
|
89
|
+
def period(self, value: pulumi.Input[_builtins.str]):
|
|
76
90
|
pulumi.set(self, "period", value)
|
|
77
91
|
|
|
78
|
-
@property
|
|
92
|
+
@_builtins.property
|
|
79
93
|
@pulumi.getter
|
|
80
|
-
def status(self) -> pulumi.Input[str]:
|
|
94
|
+
def status(self) -> pulumi.Input[_builtins.str]:
|
|
81
95
|
"""
|
|
82
|
-
The monitor
|
|
96
|
+
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
83
97
|
"""
|
|
84
98
|
return pulumi.get(self, "status")
|
|
85
99
|
|
|
86
100
|
@status.setter
|
|
87
|
-
def status(self, value: pulumi.Input[str]):
|
|
101
|
+
def status(self, value: pulumi.Input[_builtins.str]):
|
|
88
102
|
pulumi.set(self, "status", value)
|
|
89
103
|
|
|
90
|
-
@property
|
|
104
|
+
@_builtins.property
|
|
91
105
|
@pulumi.getter
|
|
92
106
|
def steps(self) -> pulumi.Input[Sequence[pulumi.Input['StepMonitorStepArgs']]]:
|
|
93
107
|
"""
|
|
@@ -99,31 +113,55 @@ class StepMonitorArgs:
|
|
|
99
113
|
def steps(self, value: pulumi.Input[Sequence[pulumi.Input['StepMonitorStepArgs']]]):
|
|
100
114
|
pulumi.set(self, "steps", value)
|
|
101
115
|
|
|
102
|
-
@property
|
|
116
|
+
@_builtins.property
|
|
103
117
|
@pulumi.getter(name="accountId")
|
|
104
|
-
def account_id(self) -> Optional[pulumi.Input[
|
|
118
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
105
119
|
"""
|
|
106
120
|
The account in which the Synthetics monitor will be created.
|
|
107
121
|
"""
|
|
108
122
|
return pulumi.get(self, "account_id")
|
|
109
123
|
|
|
110
124
|
@account_id.setter
|
|
111
|
-
def account_id(self, value: Optional[pulumi.Input[
|
|
125
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
112
126
|
pulumi.set(self, "account_id", value)
|
|
113
127
|
|
|
114
|
-
@property
|
|
128
|
+
@_builtins.property
|
|
129
|
+
@pulumi.getter
|
|
130
|
+
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
131
|
+
"""
|
|
132
|
+
The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
133
|
+
"""
|
|
134
|
+
return pulumi.get(self, "browsers")
|
|
135
|
+
|
|
136
|
+
@browsers.setter
|
|
137
|
+
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
138
|
+
pulumi.set(self, "browsers", value)
|
|
139
|
+
|
|
140
|
+
@_builtins.property
|
|
141
|
+
@pulumi.getter
|
|
142
|
+
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
143
|
+
"""
|
|
144
|
+
The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
145
|
+
"""
|
|
146
|
+
return pulumi.get(self, "devices")
|
|
147
|
+
|
|
148
|
+
@devices.setter
|
|
149
|
+
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
150
|
+
pulumi.set(self, "devices", value)
|
|
151
|
+
|
|
152
|
+
@_builtins.property
|
|
115
153
|
@pulumi.getter(name="enableScreenshotOnFailureAndScript")
|
|
116
|
-
def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[bool]]:
|
|
154
|
+
def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
117
155
|
"""
|
|
118
156
|
Capture a screenshot during job execution.
|
|
119
157
|
"""
|
|
120
158
|
return pulumi.get(self, "enable_screenshot_on_failure_and_script")
|
|
121
159
|
|
|
122
160
|
@enable_screenshot_on_failure_and_script.setter
|
|
123
|
-
def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[bool]]):
|
|
161
|
+
def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
124
162
|
pulumi.set(self, "enable_screenshot_on_failure_and_script", value)
|
|
125
163
|
|
|
126
|
-
@property
|
|
164
|
+
@_builtins.property
|
|
127
165
|
@pulumi.getter(name="locationPrivates")
|
|
128
166
|
def location_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorLocationPrivateArgs']]]]:
|
|
129
167
|
"""
|
|
@@ -135,57 +173,55 @@ class StepMonitorArgs:
|
|
|
135
173
|
def location_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorLocationPrivateArgs']]]]):
|
|
136
174
|
pulumi.set(self, "location_privates", value)
|
|
137
175
|
|
|
138
|
-
@property
|
|
176
|
+
@_builtins.property
|
|
139
177
|
@pulumi.getter(name="locationsPublics")
|
|
140
|
-
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
178
|
+
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
141
179
|
"""
|
|
142
|
-
The location the monitor will run from.
|
|
180
|
+
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.
|
|
143
181
|
"""
|
|
144
182
|
return pulumi.get(self, "locations_publics")
|
|
145
183
|
|
|
146
184
|
@locations_publics.setter
|
|
147
|
-
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
185
|
+
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
148
186
|
pulumi.set(self, "locations_publics", value)
|
|
149
187
|
|
|
150
|
-
@property
|
|
188
|
+
@_builtins.property
|
|
151
189
|
@pulumi.getter
|
|
152
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
190
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
153
191
|
"""
|
|
154
192
|
The name for the monitor.
|
|
155
193
|
"""
|
|
156
194
|
return pulumi.get(self, "name")
|
|
157
195
|
|
|
158
196
|
@name.setter
|
|
159
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
197
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
160
198
|
pulumi.set(self, "name", value)
|
|
161
199
|
|
|
162
|
-
@property
|
|
200
|
+
@_builtins.property
|
|
163
201
|
@pulumi.getter(name="runtimeType")
|
|
164
|
-
def runtime_type(self) -> Optional[pulumi.Input[str]]:
|
|
202
|
+
def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
165
203
|
"""
|
|
166
|
-
The runtime that the monitor will use to run jobs.
|
|
204
|
+
The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
167
205
|
"""
|
|
168
206
|
return pulumi.get(self, "runtime_type")
|
|
169
207
|
|
|
170
208
|
@runtime_type.setter
|
|
171
|
-
def runtime_type(self, value: Optional[pulumi.Input[str]]):
|
|
209
|
+
def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
172
210
|
pulumi.set(self, "runtime_type", value)
|
|
173
211
|
|
|
174
|
-
@property
|
|
212
|
+
@_builtins.property
|
|
175
213
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
176
|
-
def runtime_type_version(self) -> Optional[pulumi.Input[str]]:
|
|
214
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
177
215
|
"""
|
|
178
|
-
The specific version of the runtime type
|
|
179
|
-
|
|
180
|
-
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `CHROME_BROWSER` and `100` respectively. In order to run the monitor in the new runtime, both `runtime_type` and `runtime_type_version` need to be specified; however, specifying neither of these attributes would set this monitor to use the legacy runtime. It may also be noted that the runtime opted for would only be effective with private locations. For public locations, all traffic has been shifted to the new runtime, irrespective of the selection made.
|
|
216
|
+
The specific semver version of the runtime type.
|
|
181
217
|
"""
|
|
182
218
|
return pulumi.get(self, "runtime_type_version")
|
|
183
219
|
|
|
184
220
|
@runtime_type_version.setter
|
|
185
|
-
def runtime_type_version(self, value: Optional[pulumi.Input[str]]):
|
|
221
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
186
222
|
pulumi.set(self, "runtime_type_version", value)
|
|
187
223
|
|
|
188
|
-
@property
|
|
224
|
+
@_builtins.property
|
|
189
225
|
@pulumi.getter
|
|
190
226
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]]]:
|
|
191
227
|
"""
|
|
@@ -197,43 +233,61 @@ class StepMonitorArgs:
|
|
|
197
233
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]]]):
|
|
198
234
|
pulumi.set(self, "tags", value)
|
|
199
235
|
|
|
236
|
+
@_builtins.property
|
|
237
|
+
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
238
|
+
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
239
|
+
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
240
|
+
|
|
241
|
+
@use_unsupported_legacy_runtime.setter
|
|
242
|
+
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
243
|
+
pulumi.set(self, "use_unsupported_legacy_runtime", value)
|
|
244
|
+
|
|
200
245
|
|
|
201
246
|
@pulumi.input_type
|
|
202
247
|
class _StepMonitorState:
|
|
203
248
|
def __init__(__self__, *,
|
|
204
|
-
account_id: Optional[pulumi.Input[
|
|
205
|
-
|
|
206
|
-
|
|
249
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
250
|
+
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
251
|
+
devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
252
|
+
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
253
|
+
guid: Optional[pulumi.Input[_builtins.str]] = None,
|
|
207
254
|
location_privates: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorLocationPrivateArgs']]]] = None,
|
|
208
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
255
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
256
|
+
monitor_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
257
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
258
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
259
|
+
period_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
260
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
261
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
262
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
215
263
|
steps: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorStepArgs']]]] = None,
|
|
216
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]]] = None
|
|
264
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]]] = None,
|
|
265
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
217
266
|
"""
|
|
218
267
|
Input properties used for looking up and filtering StepMonitor resources.
|
|
219
|
-
:param pulumi.Input[
|
|
220
|
-
:param pulumi.Input[
|
|
221
|
-
:param pulumi.Input[str]
|
|
268
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
269
|
+
: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`.
|
|
270
|
+
: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`.
|
|
271
|
+
:param pulumi.Input[_builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
272
|
+
:param pulumi.Input[_builtins.str] guid: The unique entity identifier of the monitor in New Relic.
|
|
222
273
|
:param pulumi.Input[Sequence[pulumi.Input['StepMonitorLocationPrivateArgs']]] location_privates: The location the monitor will run from. At least one of `locations_public` or `location_private` is required. See Nested locations_private blocks below for details.
|
|
223
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_publics: The location the monitor will run from.
|
|
224
|
-
:param pulumi.Input[str]
|
|
225
|
-
:param pulumi.Input[str]
|
|
226
|
-
:param pulumi.Input[
|
|
227
|
-
:param pulumi.Input[
|
|
228
|
-
:param pulumi.Input[str]
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
:param pulumi.Input[str] status: The monitor status (ENABLED or DISABLED).
|
|
274
|
+
: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.
|
|
275
|
+
:param pulumi.Input[_builtins.str] monitor_id: The monitor id of the synthetics step monitor (not to be confused with the GUID of the monitor).
|
|
276
|
+
:param pulumi.Input[_builtins.str] name: The name for the monitor.
|
|
277
|
+
: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`.
|
|
278
|
+
:param pulumi.Input[_builtins.int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
|
|
279
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
280
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific semver version of the runtime type.
|
|
281
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
232
282
|
:param pulumi.Input[Sequence[pulumi.Input['StepMonitorStepArgs']]] steps: The steps that make up the script the monitor will run. See Nested steps blocks below for details.
|
|
233
283
|
:param pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
234
284
|
"""
|
|
235
285
|
if account_id is not None:
|
|
236
286
|
pulumi.set(__self__, "account_id", account_id)
|
|
287
|
+
if browsers is not None:
|
|
288
|
+
pulumi.set(__self__, "browsers", browsers)
|
|
289
|
+
if devices is not None:
|
|
290
|
+
pulumi.set(__self__, "devices", devices)
|
|
237
291
|
if enable_screenshot_on_failure_and_script is not None:
|
|
238
292
|
pulumi.set(__self__, "enable_screenshot_on_failure_and_script", enable_screenshot_on_failure_and_script)
|
|
239
293
|
if guid is not None:
|
|
@@ -242,6 +296,8 @@ class _StepMonitorState:
|
|
|
242
296
|
pulumi.set(__self__, "location_privates", location_privates)
|
|
243
297
|
if locations_publics is not None:
|
|
244
298
|
pulumi.set(__self__, "locations_publics", locations_publics)
|
|
299
|
+
if monitor_id is not None:
|
|
300
|
+
pulumi.set(__self__, "monitor_id", monitor_id)
|
|
245
301
|
if name is not None:
|
|
246
302
|
pulumi.set(__self__, "name", name)
|
|
247
303
|
if period is not None:
|
|
@@ -258,44 +314,70 @@ class _StepMonitorState:
|
|
|
258
314
|
pulumi.set(__self__, "steps", steps)
|
|
259
315
|
if tags is not None:
|
|
260
316
|
pulumi.set(__self__, "tags", tags)
|
|
317
|
+
if use_unsupported_legacy_runtime is not None:
|
|
318
|
+
pulumi.set(__self__, "use_unsupported_legacy_runtime", use_unsupported_legacy_runtime)
|
|
261
319
|
|
|
262
|
-
@property
|
|
320
|
+
@_builtins.property
|
|
263
321
|
@pulumi.getter(name="accountId")
|
|
264
|
-
def account_id(self) -> Optional[pulumi.Input[
|
|
322
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
265
323
|
"""
|
|
266
324
|
The account in which the Synthetics monitor will be created.
|
|
267
325
|
"""
|
|
268
326
|
return pulumi.get(self, "account_id")
|
|
269
327
|
|
|
270
328
|
@account_id.setter
|
|
271
|
-
def account_id(self, value: Optional[pulumi.Input[
|
|
329
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
272
330
|
pulumi.set(self, "account_id", value)
|
|
273
331
|
|
|
274
|
-
@property
|
|
332
|
+
@_builtins.property
|
|
333
|
+
@pulumi.getter
|
|
334
|
+
def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
335
|
+
"""
|
|
336
|
+
The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
337
|
+
"""
|
|
338
|
+
return pulumi.get(self, "browsers")
|
|
339
|
+
|
|
340
|
+
@browsers.setter
|
|
341
|
+
def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
342
|
+
pulumi.set(self, "browsers", value)
|
|
343
|
+
|
|
344
|
+
@_builtins.property
|
|
345
|
+
@pulumi.getter
|
|
346
|
+
def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
347
|
+
"""
|
|
348
|
+
The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
349
|
+
"""
|
|
350
|
+
return pulumi.get(self, "devices")
|
|
351
|
+
|
|
352
|
+
@devices.setter
|
|
353
|
+
def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
354
|
+
pulumi.set(self, "devices", value)
|
|
355
|
+
|
|
356
|
+
@_builtins.property
|
|
275
357
|
@pulumi.getter(name="enableScreenshotOnFailureAndScript")
|
|
276
|
-
def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[bool]]:
|
|
358
|
+
def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
277
359
|
"""
|
|
278
360
|
Capture a screenshot during job execution.
|
|
279
361
|
"""
|
|
280
362
|
return pulumi.get(self, "enable_screenshot_on_failure_and_script")
|
|
281
363
|
|
|
282
364
|
@enable_screenshot_on_failure_and_script.setter
|
|
283
|
-
def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[bool]]):
|
|
365
|
+
def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
284
366
|
pulumi.set(self, "enable_screenshot_on_failure_and_script", value)
|
|
285
367
|
|
|
286
|
-
@property
|
|
368
|
+
@_builtins.property
|
|
287
369
|
@pulumi.getter
|
|
288
|
-
def guid(self) -> Optional[pulumi.Input[str]]:
|
|
370
|
+
def guid(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
289
371
|
"""
|
|
290
|
-
The unique identifier
|
|
372
|
+
The unique entity identifier of the monitor in New Relic.
|
|
291
373
|
"""
|
|
292
374
|
return pulumi.get(self, "guid")
|
|
293
375
|
|
|
294
376
|
@guid.setter
|
|
295
|
-
def guid(self, value: Optional[pulumi.Input[str]]):
|
|
377
|
+
def guid(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
296
378
|
pulumi.set(self, "guid", value)
|
|
297
379
|
|
|
298
|
-
@property
|
|
380
|
+
@_builtins.property
|
|
299
381
|
@pulumi.getter(name="locationPrivates")
|
|
300
382
|
def location_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorLocationPrivateArgs']]]]:
|
|
301
383
|
"""
|
|
@@ -307,93 +389,103 @@ class _StepMonitorState:
|
|
|
307
389
|
def location_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorLocationPrivateArgs']]]]):
|
|
308
390
|
pulumi.set(self, "location_privates", value)
|
|
309
391
|
|
|
310
|
-
@property
|
|
392
|
+
@_builtins.property
|
|
311
393
|
@pulumi.getter(name="locationsPublics")
|
|
312
|
-
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
394
|
+
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
313
395
|
"""
|
|
314
|
-
The location the monitor will run from.
|
|
396
|
+
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.
|
|
315
397
|
"""
|
|
316
398
|
return pulumi.get(self, "locations_publics")
|
|
317
399
|
|
|
318
400
|
@locations_publics.setter
|
|
319
|
-
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
401
|
+
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
320
402
|
pulumi.set(self, "locations_publics", value)
|
|
321
403
|
|
|
322
|
-
@property
|
|
404
|
+
@_builtins.property
|
|
405
|
+
@pulumi.getter(name="monitorId")
|
|
406
|
+
def monitor_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
407
|
+
"""
|
|
408
|
+
The monitor id of the synthetics step monitor (not to be confused with the GUID of the monitor).
|
|
409
|
+
"""
|
|
410
|
+
return pulumi.get(self, "monitor_id")
|
|
411
|
+
|
|
412
|
+
@monitor_id.setter
|
|
413
|
+
def monitor_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
414
|
+
pulumi.set(self, "monitor_id", value)
|
|
415
|
+
|
|
416
|
+
@_builtins.property
|
|
323
417
|
@pulumi.getter
|
|
324
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
418
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
325
419
|
"""
|
|
326
420
|
The name for the monitor.
|
|
327
421
|
"""
|
|
328
422
|
return pulumi.get(self, "name")
|
|
329
423
|
|
|
330
424
|
@name.setter
|
|
331
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
425
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
332
426
|
pulumi.set(self, "name", value)
|
|
333
427
|
|
|
334
|
-
@property
|
|
428
|
+
@_builtins.property
|
|
335
429
|
@pulumi.getter
|
|
336
|
-
def period(self) -> Optional[pulumi.Input[str]]:
|
|
430
|
+
def period(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
337
431
|
"""
|
|
338
|
-
The interval at which this monitor should run. Valid values are EVERY_MINUTE
|
|
432
|
+
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`.
|
|
339
433
|
"""
|
|
340
434
|
return pulumi.get(self, "period")
|
|
341
435
|
|
|
342
436
|
@period.setter
|
|
343
|
-
def period(self, value: Optional[pulumi.Input[str]]):
|
|
437
|
+
def period(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
344
438
|
pulumi.set(self, "period", value)
|
|
345
439
|
|
|
346
|
-
@property
|
|
440
|
+
@_builtins.property
|
|
347
441
|
@pulumi.getter(name="periodInMinutes")
|
|
348
|
-
def period_in_minutes(self) -> Optional[pulumi.Input[int]]:
|
|
442
|
+
def period_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
349
443
|
"""
|
|
350
444
|
The interval in minutes at which Synthetic monitor should run.
|
|
351
445
|
"""
|
|
352
446
|
return pulumi.get(self, "period_in_minutes")
|
|
353
447
|
|
|
354
448
|
@period_in_minutes.setter
|
|
355
|
-
def period_in_minutes(self, value: Optional[pulumi.Input[int]]):
|
|
449
|
+
def period_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
356
450
|
pulumi.set(self, "period_in_minutes", value)
|
|
357
451
|
|
|
358
|
-
@property
|
|
452
|
+
@_builtins.property
|
|
359
453
|
@pulumi.getter(name="runtimeType")
|
|
360
|
-
def runtime_type(self) -> Optional[pulumi.Input[str]]:
|
|
454
|
+
def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
361
455
|
"""
|
|
362
|
-
The runtime that the monitor will use to run jobs.
|
|
456
|
+
The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
363
457
|
"""
|
|
364
458
|
return pulumi.get(self, "runtime_type")
|
|
365
459
|
|
|
366
460
|
@runtime_type.setter
|
|
367
|
-
def runtime_type(self, value: Optional[pulumi.Input[str]]):
|
|
461
|
+
def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
368
462
|
pulumi.set(self, "runtime_type", value)
|
|
369
463
|
|
|
370
|
-
@property
|
|
464
|
+
@_builtins.property
|
|
371
465
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
372
|
-
def runtime_type_version(self) -> Optional[pulumi.Input[str]]:
|
|
466
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
373
467
|
"""
|
|
374
|
-
The specific version of the runtime type
|
|
375
|
-
|
|
376
|
-
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `CHROME_BROWSER` and `100` respectively. In order to run the monitor in the new runtime, both `runtime_type` and `runtime_type_version` need to be specified; however, specifying neither of these attributes would set this monitor to use the legacy runtime. It may also be noted that the runtime opted for would only be effective with private locations. For public locations, all traffic has been shifted to the new runtime, irrespective of the selection made.
|
|
468
|
+
The specific semver version of the runtime type.
|
|
377
469
|
"""
|
|
378
470
|
return pulumi.get(self, "runtime_type_version")
|
|
379
471
|
|
|
380
472
|
@runtime_type_version.setter
|
|
381
|
-
def runtime_type_version(self, value: Optional[pulumi.Input[str]]):
|
|
473
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
382
474
|
pulumi.set(self, "runtime_type_version", value)
|
|
383
475
|
|
|
384
|
-
@property
|
|
476
|
+
@_builtins.property
|
|
385
477
|
@pulumi.getter
|
|
386
|
-
def status(self) -> Optional[pulumi.Input[str]]:
|
|
478
|
+
def status(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
387
479
|
"""
|
|
388
|
-
The monitor
|
|
480
|
+
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
389
481
|
"""
|
|
390
482
|
return pulumi.get(self, "status")
|
|
391
483
|
|
|
392
484
|
@status.setter
|
|
393
|
-
def status(self, value: Optional[pulumi.Input[str]]):
|
|
485
|
+
def status(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
394
486
|
pulumi.set(self, "status", value)
|
|
395
487
|
|
|
396
|
-
@property
|
|
488
|
+
@_builtins.property
|
|
397
489
|
@pulumi.getter
|
|
398
490
|
def steps(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorStepArgs']]]]:
|
|
399
491
|
"""
|
|
@@ -405,7 +497,7 @@ class _StepMonitorState:
|
|
|
405
497
|
def steps(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorStepArgs']]]]):
|
|
406
498
|
pulumi.set(self, "steps", value)
|
|
407
499
|
|
|
408
|
-
@property
|
|
500
|
+
@_builtins.property
|
|
409
501
|
@pulumi.getter
|
|
410
502
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]]]:
|
|
411
503
|
"""
|
|
@@ -417,55 +509,71 @@ class _StepMonitorState:
|
|
|
417
509
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]]]):
|
|
418
510
|
pulumi.set(self, "tags", value)
|
|
419
511
|
|
|
512
|
+
@_builtins.property
|
|
513
|
+
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
514
|
+
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
515
|
+
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
516
|
+
|
|
517
|
+
@use_unsupported_legacy_runtime.setter
|
|
518
|
+
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
519
|
+
pulumi.set(self, "use_unsupported_legacy_runtime", value)
|
|
420
520
|
|
|
521
|
+
|
|
522
|
+
@pulumi.type_token("newrelic:synthetics/stepMonitor:StepMonitor")
|
|
421
523
|
class StepMonitor(pulumi.CustomResource):
|
|
422
524
|
@overload
|
|
423
525
|
def __init__(__self__,
|
|
424
526
|
resource_name: str,
|
|
425
527
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
426
|
-
account_id: Optional[pulumi.Input[
|
|
427
|
-
|
|
428
|
-
|
|
429
|
-
|
|
430
|
-
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
|
|
435
|
-
|
|
436
|
-
|
|
528
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
529
|
+
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
530
|
+
devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
531
|
+
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
532
|
+
location_privates: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorLocationPrivateArgs', 'StepMonitorLocationPrivateArgsDict']]]]] = None,
|
|
533
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
534
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
535
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
536
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
537
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
538
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
539
|
+
steps: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorStepArgs', 'StepMonitorStepArgsDict']]]]] = None,
|
|
540
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorTagArgs', 'StepMonitorTagArgsDict']]]]] = None,
|
|
541
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
437
542
|
__props__=None):
|
|
438
543
|
"""
|
|
439
|
-
Use this resource to create, update, and delete a Synthetics Step monitor in New Relic.
|
|
440
|
-
|
|
441
544
|
## Example Usage
|
|
442
545
|
|
|
443
|
-
<!--Start PulumiCodeChooser -->
|
|
444
546
|
```python
|
|
445
547
|
import pulumi
|
|
446
548
|
import pulumi_newrelic as newrelic
|
|
447
549
|
|
|
448
550
|
foo = newrelic.synthetics.StepMonitor("foo",
|
|
551
|
+
name="Sample Step Monitor",
|
|
449
552
|
enable_screenshot_on_failure_and_script=True,
|
|
450
553
|
locations_publics=[
|
|
451
554
|
"US_EAST_1",
|
|
452
555
|
"US_EAST_2",
|
|
453
556
|
],
|
|
454
557
|
period="EVERY_6_HOURS",
|
|
558
|
+
status="ENABLED",
|
|
455
559
|
runtime_type="CHROME_BROWSER",
|
|
456
560
|
runtime_type_version="100",
|
|
457
|
-
|
|
458
|
-
|
|
459
|
-
|
|
460
|
-
|
|
461
|
-
|
|
462
|
-
|
|
463
|
-
|
|
464
|
-
|
|
465
|
-
|
|
466
|
-
|
|
561
|
+
devices=[
|
|
562
|
+
"DESKTOP",
|
|
563
|
+
"MOBILE_PORTRAIT",
|
|
564
|
+
"TABLET_LANDSCAPE",
|
|
565
|
+
],
|
|
566
|
+
browsers=["CHROME"],
|
|
567
|
+
steps=[{
|
|
568
|
+
"ordinal": 0,
|
|
569
|
+
"type": "NAVIGATE",
|
|
570
|
+
"values": ["https://www.newrelic.com"],
|
|
571
|
+
}],
|
|
572
|
+
tags=[{
|
|
573
|
+
"key": "some_key",
|
|
574
|
+
"values": ["some_value"],
|
|
575
|
+
}])
|
|
467
576
|
```
|
|
468
|
-
<!--End PulumiCodeChooser -->
|
|
469
577
|
See additional examples.
|
|
470
578
|
|
|
471
579
|
## Additional Examples
|
|
@@ -476,32 +584,40 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
476
584
|
|
|
477
585
|
> **NOTE:** It can take up to 10 minutes for a private location to become available.
|
|
478
586
|
|
|
479
|
-
<!--Start PulumiCodeChooser -->
|
|
480
587
|
```python
|
|
481
588
|
import pulumi
|
|
482
589
|
import pulumi_newrelic as newrelic
|
|
483
590
|
|
|
484
|
-
|
|
591
|
+
foo = newrelic.synthetics.PrivateLocation("foo",
|
|
592
|
+
name="Sample Private Location",
|
|
485
593
|
description="Sample Private Location Description",
|
|
486
594
|
verified_script_execution=True)
|
|
487
|
-
foo_step_monitor = newrelic.synthetics.StepMonitor("
|
|
595
|
+
foo_step_monitor = newrelic.synthetics.StepMonitor("foo",
|
|
596
|
+
name="Sample Step Monitor",
|
|
488
597
|
period="EVERY_6_HOURS",
|
|
489
598
|
status="ENABLED",
|
|
490
|
-
|
|
491
|
-
|
|
492
|
-
|
|
493
|
-
|
|
494
|
-
|
|
495
|
-
|
|
496
|
-
|
|
497
|
-
|
|
498
|
-
|
|
499
|
-
|
|
500
|
-
|
|
501
|
-
|
|
502
|
-
|
|
599
|
+
runtime_type="CHROME_BROWSER",
|
|
600
|
+
runtime_type_version="100",
|
|
601
|
+
devices=[
|
|
602
|
+
"DESKTOP",
|
|
603
|
+
"MOBILE_PORTRAIT",
|
|
604
|
+
"TABLET_LANDSCAPE",
|
|
605
|
+
],
|
|
606
|
+
browsers=["CHROME"],
|
|
607
|
+
location_privates=[{
|
|
608
|
+
"guid": foo.id,
|
|
609
|
+
"vse_password": "secret",
|
|
610
|
+
}],
|
|
611
|
+
steps=[{
|
|
612
|
+
"ordinal": 0,
|
|
613
|
+
"type": "NAVIGATE",
|
|
614
|
+
"values": ["https://google.com"],
|
|
615
|
+
}],
|
|
616
|
+
tags=[{
|
|
617
|
+
"key": "some_key",
|
|
618
|
+
"values": ["some_value"],
|
|
619
|
+
}])
|
|
503
620
|
```
|
|
504
|
-
<!--End PulumiCodeChooser -->
|
|
505
621
|
|
|
506
622
|
## Import
|
|
507
623
|
|
|
@@ -515,19 +631,19 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
515
631
|
|
|
516
632
|
:param str resource_name: The name of the resource.
|
|
517
633
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
518
|
-
:param pulumi.Input[
|
|
519
|
-
:param pulumi.Input[
|
|
520
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
521
|
-
:param pulumi.Input[
|
|
522
|
-
:param pulumi.Input[
|
|
523
|
-
:param pulumi.Input[str]
|
|
524
|
-
:param pulumi.Input[str]
|
|
525
|
-
:param pulumi.Input[str]
|
|
526
|
-
|
|
527
|
-
|
|
528
|
-
:param pulumi.Input[str] status: The monitor
|
|
529
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
530
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
634
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
635
|
+
: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`.
|
|
636
|
+
: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`.
|
|
637
|
+
:param pulumi.Input[_builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
638
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorLocationPrivateArgs', 'StepMonitorLocationPrivateArgsDict']]]] location_privates: The location the monitor will run from. At least one of `locations_public` or `location_private` is required. See Nested locations_private blocks below for details.
|
|
639
|
+
: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.
|
|
640
|
+
:param pulumi.Input[_builtins.str] name: The name for the monitor.
|
|
641
|
+
: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`.
|
|
642
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
643
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific semver version of the runtime type.
|
|
644
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
645
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorStepArgs', 'StepMonitorStepArgsDict']]]] steps: The steps that make up the script the monitor will run. See Nested steps blocks below for details.
|
|
646
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorTagArgs', 'StepMonitorTagArgsDict']]]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
531
647
|
"""
|
|
532
648
|
...
|
|
533
649
|
@overload
|
|
@@ -536,36 +652,39 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
536
652
|
args: StepMonitorArgs,
|
|
537
653
|
opts: Optional[pulumi.ResourceOptions] = None):
|
|
538
654
|
"""
|
|
539
|
-
Use this resource to create, update, and delete a Synthetics Step monitor in New Relic.
|
|
540
|
-
|
|
541
655
|
## Example Usage
|
|
542
656
|
|
|
543
|
-
<!--Start PulumiCodeChooser -->
|
|
544
657
|
```python
|
|
545
658
|
import pulumi
|
|
546
659
|
import pulumi_newrelic as newrelic
|
|
547
660
|
|
|
548
661
|
foo = newrelic.synthetics.StepMonitor("foo",
|
|
662
|
+
name="Sample Step Monitor",
|
|
549
663
|
enable_screenshot_on_failure_and_script=True,
|
|
550
664
|
locations_publics=[
|
|
551
665
|
"US_EAST_1",
|
|
552
666
|
"US_EAST_2",
|
|
553
667
|
],
|
|
554
668
|
period="EVERY_6_HOURS",
|
|
669
|
+
status="ENABLED",
|
|
555
670
|
runtime_type="CHROME_BROWSER",
|
|
556
671
|
runtime_type_version="100",
|
|
557
|
-
|
|
558
|
-
|
|
559
|
-
|
|
560
|
-
|
|
561
|
-
|
|
562
|
-
|
|
563
|
-
|
|
564
|
-
|
|
565
|
-
|
|
566
|
-
|
|
672
|
+
devices=[
|
|
673
|
+
"DESKTOP",
|
|
674
|
+
"MOBILE_PORTRAIT",
|
|
675
|
+
"TABLET_LANDSCAPE",
|
|
676
|
+
],
|
|
677
|
+
browsers=["CHROME"],
|
|
678
|
+
steps=[{
|
|
679
|
+
"ordinal": 0,
|
|
680
|
+
"type": "NAVIGATE",
|
|
681
|
+
"values": ["https://www.newrelic.com"],
|
|
682
|
+
}],
|
|
683
|
+
tags=[{
|
|
684
|
+
"key": "some_key",
|
|
685
|
+
"values": ["some_value"],
|
|
686
|
+
}])
|
|
567
687
|
```
|
|
568
|
-
<!--End PulumiCodeChooser -->
|
|
569
688
|
See additional examples.
|
|
570
689
|
|
|
571
690
|
## Additional Examples
|
|
@@ -576,32 +695,40 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
576
695
|
|
|
577
696
|
> **NOTE:** It can take up to 10 minutes for a private location to become available.
|
|
578
697
|
|
|
579
|
-
<!--Start PulumiCodeChooser -->
|
|
580
698
|
```python
|
|
581
699
|
import pulumi
|
|
582
700
|
import pulumi_newrelic as newrelic
|
|
583
701
|
|
|
584
|
-
|
|
702
|
+
foo = newrelic.synthetics.PrivateLocation("foo",
|
|
703
|
+
name="Sample Private Location",
|
|
585
704
|
description="Sample Private Location Description",
|
|
586
705
|
verified_script_execution=True)
|
|
587
|
-
foo_step_monitor = newrelic.synthetics.StepMonitor("
|
|
706
|
+
foo_step_monitor = newrelic.synthetics.StepMonitor("foo",
|
|
707
|
+
name="Sample Step Monitor",
|
|
588
708
|
period="EVERY_6_HOURS",
|
|
589
709
|
status="ENABLED",
|
|
590
|
-
|
|
591
|
-
|
|
592
|
-
|
|
593
|
-
|
|
594
|
-
|
|
595
|
-
|
|
596
|
-
|
|
597
|
-
|
|
598
|
-
|
|
599
|
-
|
|
600
|
-
|
|
601
|
-
|
|
602
|
-
|
|
710
|
+
runtime_type="CHROME_BROWSER",
|
|
711
|
+
runtime_type_version="100",
|
|
712
|
+
devices=[
|
|
713
|
+
"DESKTOP",
|
|
714
|
+
"MOBILE_PORTRAIT",
|
|
715
|
+
"TABLET_LANDSCAPE",
|
|
716
|
+
],
|
|
717
|
+
browsers=["CHROME"],
|
|
718
|
+
location_privates=[{
|
|
719
|
+
"guid": foo.id,
|
|
720
|
+
"vse_password": "secret",
|
|
721
|
+
}],
|
|
722
|
+
steps=[{
|
|
723
|
+
"ordinal": 0,
|
|
724
|
+
"type": "NAVIGATE",
|
|
725
|
+
"values": ["https://google.com"],
|
|
726
|
+
}],
|
|
727
|
+
tags=[{
|
|
728
|
+
"key": "some_key",
|
|
729
|
+
"values": ["some_value"],
|
|
730
|
+
}])
|
|
603
731
|
```
|
|
604
|
-
<!--End PulumiCodeChooser -->
|
|
605
732
|
|
|
606
733
|
## Import
|
|
607
734
|
|
|
@@ -628,17 +755,20 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
628
755
|
def _internal_init(__self__,
|
|
629
756
|
resource_name: str,
|
|
630
757
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
631
|
-
account_id: Optional[pulumi.Input[
|
|
632
|
-
|
|
633
|
-
|
|
634
|
-
|
|
635
|
-
|
|
636
|
-
|
|
637
|
-
|
|
638
|
-
|
|
639
|
-
|
|
640
|
-
|
|
641
|
-
|
|
758
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
759
|
+
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
760
|
+
devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
761
|
+
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
762
|
+
location_privates: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorLocationPrivateArgs', 'StepMonitorLocationPrivateArgsDict']]]]] = None,
|
|
763
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
764
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
765
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
766
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
767
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
768
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
769
|
+
steps: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorStepArgs', 'StepMonitorStepArgsDict']]]]] = None,
|
|
770
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorTagArgs', 'StepMonitorTagArgsDict']]]]] = None,
|
|
771
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
642
772
|
__props__=None):
|
|
643
773
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
644
774
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -649,6 +779,8 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
649
779
|
__props__ = StepMonitorArgs.__new__(StepMonitorArgs)
|
|
650
780
|
|
|
651
781
|
__props__.__dict__["account_id"] = account_id
|
|
782
|
+
__props__.__dict__["browsers"] = browsers
|
|
783
|
+
__props__.__dict__["devices"] = devices
|
|
652
784
|
__props__.__dict__["enable_screenshot_on_failure_and_script"] = enable_screenshot_on_failure_and_script
|
|
653
785
|
__props__.__dict__["location_privates"] = location_privates
|
|
654
786
|
__props__.__dict__["locations_publics"] = locations_publics
|
|
@@ -665,7 +797,9 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
665
797
|
raise TypeError("Missing required property 'steps'")
|
|
666
798
|
__props__.__dict__["steps"] = steps
|
|
667
799
|
__props__.__dict__["tags"] = tags
|
|
800
|
+
__props__.__dict__["use_unsupported_legacy_runtime"] = use_unsupported_legacy_runtime
|
|
668
801
|
__props__.__dict__["guid"] = None
|
|
802
|
+
__props__.__dict__["monitor_id"] = None
|
|
669
803
|
__props__.__dict__["period_in_minutes"] = None
|
|
670
804
|
super(StepMonitor, __self__).__init__(
|
|
671
805
|
'newrelic:synthetics/stepMonitor:StepMonitor',
|
|
@@ -677,19 +811,23 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
677
811
|
def get(resource_name: str,
|
|
678
812
|
id: pulumi.Input[str],
|
|
679
813
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
680
|
-
account_id: Optional[pulumi.Input[
|
|
681
|
-
|
|
682
|
-
|
|
683
|
-
|
|
684
|
-
|
|
685
|
-
|
|
686
|
-
|
|
687
|
-
|
|
688
|
-
|
|
689
|
-
|
|
690
|
-
|
|
691
|
-
|
|
692
|
-
|
|
814
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
815
|
+
browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
816
|
+
devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
817
|
+
enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
818
|
+
guid: Optional[pulumi.Input[_builtins.str]] = None,
|
|
819
|
+
location_privates: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorLocationPrivateArgs', 'StepMonitorLocationPrivateArgsDict']]]]] = None,
|
|
820
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
821
|
+
monitor_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
822
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
823
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
824
|
+
period_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
825
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
826
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
827
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
828
|
+
steps: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorStepArgs', 'StepMonitorStepArgsDict']]]]] = None,
|
|
829
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorTagArgs', 'StepMonitorTagArgsDict']]]]] = None,
|
|
830
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None) -> 'StepMonitor':
|
|
693
831
|
"""
|
|
694
832
|
Get an existing StepMonitor resource's state with the given name, id, and optional extra
|
|
695
833
|
properties used to qualify the lookup.
|
|
@@ -697,31 +835,35 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
697
835
|
:param str resource_name: The unique name of the resulting resource.
|
|
698
836
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
699
837
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
700
|
-
:param pulumi.Input[
|
|
701
|
-
:param pulumi.Input[
|
|
702
|
-
:param pulumi.Input[str]
|
|
703
|
-
:param pulumi.Input[
|
|
704
|
-
:param pulumi.Input[
|
|
705
|
-
:param pulumi.Input[
|
|
706
|
-
:param pulumi.Input[str]
|
|
707
|
-
:param pulumi.Input[
|
|
708
|
-
:param pulumi.Input[str]
|
|
709
|
-
:param pulumi.Input[str]
|
|
710
|
-
|
|
711
|
-
|
|
712
|
-
:param pulumi.Input[str]
|
|
713
|
-
:param pulumi.Input[
|
|
714
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
838
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
839
|
+
: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`.
|
|
840
|
+
: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`.
|
|
841
|
+
:param pulumi.Input[_builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
|
|
842
|
+
:param pulumi.Input[_builtins.str] guid: The unique entity identifier of the monitor in New Relic.
|
|
843
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorLocationPrivateArgs', 'StepMonitorLocationPrivateArgsDict']]]] location_privates: The location the monitor will run from. At least one of `locations_public` or `location_private` is required. See Nested locations_private blocks below for details.
|
|
844
|
+
: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.
|
|
845
|
+
:param pulumi.Input[_builtins.str] monitor_id: The monitor id of the synthetics step monitor (not to be confused with the GUID of the monitor).
|
|
846
|
+
:param pulumi.Input[_builtins.str] name: The name for the monitor.
|
|
847
|
+
: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`.
|
|
848
|
+
:param pulumi.Input[_builtins.int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
|
|
849
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
850
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific semver version of the runtime type.
|
|
851
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
852
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorStepArgs', 'StepMonitorStepArgsDict']]]] steps: The steps that make up the script the monitor will run. See Nested steps blocks below for details.
|
|
853
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorTagArgs', 'StepMonitorTagArgsDict']]]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
715
854
|
"""
|
|
716
855
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
717
856
|
|
|
718
857
|
__props__ = _StepMonitorState.__new__(_StepMonitorState)
|
|
719
858
|
|
|
720
859
|
__props__.__dict__["account_id"] = account_id
|
|
860
|
+
__props__.__dict__["browsers"] = browsers
|
|
861
|
+
__props__.__dict__["devices"] = devices
|
|
721
862
|
__props__.__dict__["enable_screenshot_on_failure_and_script"] = enable_screenshot_on_failure_and_script
|
|
722
863
|
__props__.__dict__["guid"] = guid
|
|
723
864
|
__props__.__dict__["location_privates"] = location_privates
|
|
724
865
|
__props__.__dict__["locations_publics"] = locations_publics
|
|
866
|
+
__props__.__dict__["monitor_id"] = monitor_id
|
|
725
867
|
__props__.__dict__["name"] = name
|
|
726
868
|
__props__.__dict__["period"] = period
|
|
727
869
|
__props__.__dict__["period_in_minutes"] = period_in_minutes
|
|
@@ -730,33 +872,50 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
730
872
|
__props__.__dict__["status"] = status
|
|
731
873
|
__props__.__dict__["steps"] = steps
|
|
732
874
|
__props__.__dict__["tags"] = tags
|
|
875
|
+
__props__.__dict__["use_unsupported_legacy_runtime"] = use_unsupported_legacy_runtime
|
|
733
876
|
return StepMonitor(resource_name, opts=opts, __props__=__props__)
|
|
734
877
|
|
|
735
|
-
@property
|
|
878
|
+
@_builtins.property
|
|
736
879
|
@pulumi.getter(name="accountId")
|
|
737
|
-
def account_id(self) -> pulumi.Output[
|
|
880
|
+
def account_id(self) -> pulumi.Output[_builtins.str]:
|
|
738
881
|
"""
|
|
739
882
|
The account in which the Synthetics monitor will be created.
|
|
740
883
|
"""
|
|
741
884
|
return pulumi.get(self, "account_id")
|
|
742
885
|
|
|
743
|
-
@property
|
|
886
|
+
@_builtins.property
|
|
887
|
+
@pulumi.getter
|
|
888
|
+
def browsers(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
889
|
+
"""
|
|
890
|
+
The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
|
|
891
|
+
"""
|
|
892
|
+
return pulumi.get(self, "browsers")
|
|
893
|
+
|
|
894
|
+
@_builtins.property
|
|
895
|
+
@pulumi.getter
|
|
896
|
+
def devices(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
897
|
+
"""
|
|
898
|
+
The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
|
|
899
|
+
"""
|
|
900
|
+
return pulumi.get(self, "devices")
|
|
901
|
+
|
|
902
|
+
@_builtins.property
|
|
744
903
|
@pulumi.getter(name="enableScreenshotOnFailureAndScript")
|
|
745
|
-
def enable_screenshot_on_failure_and_script(self) -> pulumi.Output[Optional[bool]]:
|
|
904
|
+
def enable_screenshot_on_failure_and_script(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
746
905
|
"""
|
|
747
906
|
Capture a screenshot during job execution.
|
|
748
907
|
"""
|
|
749
908
|
return pulumi.get(self, "enable_screenshot_on_failure_and_script")
|
|
750
909
|
|
|
751
|
-
@property
|
|
910
|
+
@_builtins.property
|
|
752
911
|
@pulumi.getter
|
|
753
|
-
def guid(self) -> pulumi.Output[str]:
|
|
912
|
+
def guid(self) -> pulumi.Output[_builtins.str]:
|
|
754
913
|
"""
|
|
755
|
-
The unique identifier
|
|
914
|
+
The unique entity identifier of the monitor in New Relic.
|
|
756
915
|
"""
|
|
757
916
|
return pulumi.get(self, "guid")
|
|
758
917
|
|
|
759
|
-
@property
|
|
918
|
+
@_builtins.property
|
|
760
919
|
@pulumi.getter(name="locationPrivates")
|
|
761
920
|
def location_privates(self) -> pulumi.Output[Optional[Sequence['outputs.StepMonitorLocationPrivate']]]:
|
|
762
921
|
"""
|
|
@@ -764,65 +923,71 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
764
923
|
"""
|
|
765
924
|
return pulumi.get(self, "location_privates")
|
|
766
925
|
|
|
767
|
-
@property
|
|
926
|
+
@_builtins.property
|
|
768
927
|
@pulumi.getter(name="locationsPublics")
|
|
769
|
-
def locations_publics(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
928
|
+
def locations_publics(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
770
929
|
"""
|
|
771
|
-
The location the monitor will run from.
|
|
930
|
+
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.
|
|
772
931
|
"""
|
|
773
932
|
return pulumi.get(self, "locations_publics")
|
|
774
933
|
|
|
775
|
-
@property
|
|
934
|
+
@_builtins.property
|
|
935
|
+
@pulumi.getter(name="monitorId")
|
|
936
|
+
def monitor_id(self) -> pulumi.Output[_builtins.str]:
|
|
937
|
+
"""
|
|
938
|
+
The monitor id of the synthetics step monitor (not to be confused with the GUID of the monitor).
|
|
939
|
+
"""
|
|
940
|
+
return pulumi.get(self, "monitor_id")
|
|
941
|
+
|
|
942
|
+
@_builtins.property
|
|
776
943
|
@pulumi.getter
|
|
777
|
-
def name(self) -> pulumi.Output[str]:
|
|
944
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
778
945
|
"""
|
|
779
946
|
The name for the monitor.
|
|
780
947
|
"""
|
|
781
948
|
return pulumi.get(self, "name")
|
|
782
949
|
|
|
783
|
-
@property
|
|
950
|
+
@_builtins.property
|
|
784
951
|
@pulumi.getter
|
|
785
|
-
def period(self) -> pulumi.Output[str]:
|
|
952
|
+
def period(self) -> pulumi.Output[_builtins.str]:
|
|
786
953
|
"""
|
|
787
|
-
The interval at which this monitor should run. Valid values are EVERY_MINUTE
|
|
954
|
+
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`.
|
|
788
955
|
"""
|
|
789
956
|
return pulumi.get(self, "period")
|
|
790
957
|
|
|
791
|
-
@property
|
|
958
|
+
@_builtins.property
|
|
792
959
|
@pulumi.getter(name="periodInMinutes")
|
|
793
|
-
def period_in_minutes(self) -> pulumi.Output[int]:
|
|
960
|
+
def period_in_minutes(self) -> pulumi.Output[_builtins.int]:
|
|
794
961
|
"""
|
|
795
962
|
The interval in minutes at which Synthetic monitor should run.
|
|
796
963
|
"""
|
|
797
964
|
return pulumi.get(self, "period_in_minutes")
|
|
798
965
|
|
|
799
|
-
@property
|
|
966
|
+
@_builtins.property
|
|
800
967
|
@pulumi.getter(name="runtimeType")
|
|
801
|
-
def runtime_type(self) -> pulumi.Output[Optional[str]]:
|
|
968
|
+
def runtime_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
802
969
|
"""
|
|
803
|
-
The runtime that the monitor will use to run jobs.
|
|
970
|
+
The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
|
|
804
971
|
"""
|
|
805
972
|
return pulumi.get(self, "runtime_type")
|
|
806
973
|
|
|
807
|
-
@property
|
|
974
|
+
@_builtins.property
|
|
808
975
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
809
|
-
def runtime_type_version(self) -> pulumi.Output[Optional[str]]:
|
|
976
|
+
def runtime_type_version(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
810
977
|
"""
|
|
811
|
-
The specific version of the runtime type
|
|
812
|
-
|
|
813
|
-
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `CHROME_BROWSER` and `100` respectively. In order to run the monitor in the new runtime, both `runtime_type` and `runtime_type_version` need to be specified; however, specifying neither of these attributes would set this monitor to use the legacy runtime. It may also be noted that the runtime opted for would only be effective with private locations. For public locations, all traffic has been shifted to the new runtime, irrespective of the selection made.
|
|
978
|
+
The specific semver version of the runtime type.
|
|
814
979
|
"""
|
|
815
980
|
return pulumi.get(self, "runtime_type_version")
|
|
816
981
|
|
|
817
|
-
@property
|
|
982
|
+
@_builtins.property
|
|
818
983
|
@pulumi.getter
|
|
819
|
-
def status(self) -> pulumi.Output[str]:
|
|
984
|
+
def status(self) -> pulumi.Output[_builtins.str]:
|
|
820
985
|
"""
|
|
821
|
-
The monitor
|
|
986
|
+
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
822
987
|
"""
|
|
823
988
|
return pulumi.get(self, "status")
|
|
824
989
|
|
|
825
|
-
@property
|
|
990
|
+
@_builtins.property
|
|
826
991
|
@pulumi.getter
|
|
827
992
|
def steps(self) -> pulumi.Output[Sequence['outputs.StepMonitorStep']]:
|
|
828
993
|
"""
|
|
@@ -830,7 +995,7 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
830
995
|
"""
|
|
831
996
|
return pulumi.get(self, "steps")
|
|
832
997
|
|
|
833
|
-
@property
|
|
998
|
+
@_builtins.property
|
|
834
999
|
@pulumi.getter
|
|
835
1000
|
def tags(self) -> pulumi.Output[Optional[Sequence['outputs.StepMonitorTag']]]:
|
|
836
1001
|
"""
|
|
@@ -838,3 +1003,8 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
838
1003
|
"""
|
|
839
1004
|
return pulumi.get(self, "tags")
|
|
840
1005
|
|
|
1006
|
+
@_builtins.property
|
|
1007
|
+
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
1008
|
+
def use_unsupported_legacy_runtime(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1009
|
+
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
1010
|
+
|