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