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,29 +21,28 @@ __all__ = ['BrokenLinksMonitorArgs', 'BrokenLinksMonitor']
|
|
|
16
21
|
@pulumi.input_type
|
|
17
22
|
class BrokenLinksMonitorArgs:
|
|
18
23
|
def __init__(__self__, *,
|
|
19
|
-
period: pulumi.Input[str],
|
|
20
|
-
status: pulumi.Input[str],
|
|
21
|
-
uri: pulumi.Input[str],
|
|
22
|
-
account_id: Optional[pulumi.Input[
|
|
23
|
-
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
24
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
25
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
26
|
-
runtime_type: Optional[pulumi.Input[str]] = None,
|
|
27
|
-
runtime_type_version: Optional[pulumi.Input[str]] = None,
|
|
28
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input['BrokenLinksMonitorTagArgs']]]] = None
|
|
24
|
+
period: pulumi.Input[_builtins.str],
|
|
25
|
+
status: pulumi.Input[_builtins.str],
|
|
26
|
+
uri: pulumi.Input[_builtins.str],
|
|
27
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
28
|
+
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
29
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
30
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
31
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
32
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
33
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input['BrokenLinksMonitorTagArgs']]]] = None,
|
|
34
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
29
35
|
"""
|
|
30
36
|
The set of arguments for constructing a BrokenLinksMonitor resource.
|
|
31
|
-
:param pulumi.Input[str] period: The interval at which this monitor should run. Valid values are EVERY_MINUTE
|
|
32
|
-
:param pulumi.Input[str] status: The monitor
|
|
33
|
-
:param pulumi.Input[str] uri: The URI the monitor runs against.
|
|
34
|
-
:param pulumi.Input[
|
|
35
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
36
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_publics: The location the monitor will run from.
|
|
37
|
-
:param pulumi.Input[str] name: The name for the monitor.
|
|
38
|
-
:param pulumi.Input[str] runtime_type: The runtime that the monitor will use to run jobs.
|
|
39
|
-
:param pulumi.Input[str] runtime_type_version: The specific version of the runtime type
|
|
40
|
-
|
|
41
|
-
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `NODE_API` and `16.10` 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.
|
|
37
|
+
: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`.
|
|
38
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
39
|
+
:param pulumi.Input[_builtins.str] uri: The URI the monitor runs against.
|
|
40
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
41
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
42
|
+
: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.
|
|
43
|
+
:param pulumi.Input[_builtins.str] name: The name for the monitor.
|
|
44
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`NODE_API`).
|
|
45
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific semver version of the runtime type.
|
|
42
46
|
:param pulumi.Input[Sequence[pulumi.Input['BrokenLinksMonitorTagArgs']]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details
|
|
43
47
|
"""
|
|
44
48
|
pulumi.set(__self__, "period", period)
|
|
@@ -58,118 +62,118 @@ class BrokenLinksMonitorArgs:
|
|
|
58
62
|
pulumi.set(__self__, "runtime_type_version", runtime_type_version)
|
|
59
63
|
if tags is not None:
|
|
60
64
|
pulumi.set(__self__, "tags", tags)
|
|
65
|
+
if use_unsupported_legacy_runtime is not None:
|
|
66
|
+
pulumi.set(__self__, "use_unsupported_legacy_runtime", use_unsupported_legacy_runtime)
|
|
61
67
|
|
|
62
|
-
@property
|
|
68
|
+
@_builtins.property
|
|
63
69
|
@pulumi.getter
|
|
64
|
-
def period(self) -> pulumi.Input[str]:
|
|
70
|
+
def period(self) -> pulumi.Input[_builtins.str]:
|
|
65
71
|
"""
|
|
66
|
-
The interval at which this monitor should run. Valid values are EVERY_MINUTE
|
|
72
|
+
The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
67
73
|
"""
|
|
68
74
|
return pulumi.get(self, "period")
|
|
69
75
|
|
|
70
76
|
@period.setter
|
|
71
|
-
def period(self, value: pulumi.Input[str]):
|
|
77
|
+
def period(self, value: pulumi.Input[_builtins.str]):
|
|
72
78
|
pulumi.set(self, "period", value)
|
|
73
79
|
|
|
74
|
-
@property
|
|
80
|
+
@_builtins.property
|
|
75
81
|
@pulumi.getter
|
|
76
|
-
def status(self) -> pulumi.Input[str]:
|
|
82
|
+
def status(self) -> pulumi.Input[_builtins.str]:
|
|
77
83
|
"""
|
|
78
|
-
The monitor
|
|
84
|
+
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
79
85
|
"""
|
|
80
86
|
return pulumi.get(self, "status")
|
|
81
87
|
|
|
82
88
|
@status.setter
|
|
83
|
-
def status(self, value: pulumi.Input[str]):
|
|
89
|
+
def status(self, value: pulumi.Input[_builtins.str]):
|
|
84
90
|
pulumi.set(self, "status", value)
|
|
85
91
|
|
|
86
|
-
@property
|
|
92
|
+
@_builtins.property
|
|
87
93
|
@pulumi.getter
|
|
88
|
-
def uri(self) -> pulumi.Input[str]:
|
|
94
|
+
def uri(self) -> pulumi.Input[_builtins.str]:
|
|
89
95
|
"""
|
|
90
96
|
The URI the monitor runs against.
|
|
91
97
|
"""
|
|
92
98
|
return pulumi.get(self, "uri")
|
|
93
99
|
|
|
94
100
|
@uri.setter
|
|
95
|
-
def uri(self, value: pulumi.Input[str]):
|
|
101
|
+
def uri(self, value: pulumi.Input[_builtins.str]):
|
|
96
102
|
pulumi.set(self, "uri", value)
|
|
97
103
|
|
|
98
|
-
@property
|
|
104
|
+
@_builtins.property
|
|
99
105
|
@pulumi.getter(name="accountId")
|
|
100
|
-
def account_id(self) -> Optional[pulumi.Input[
|
|
106
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
101
107
|
"""
|
|
102
108
|
The account in which the Synthetics monitor will be created.
|
|
103
109
|
"""
|
|
104
110
|
return pulumi.get(self, "account_id")
|
|
105
111
|
|
|
106
112
|
@account_id.setter
|
|
107
|
-
def account_id(self, value: Optional[pulumi.Input[
|
|
113
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
108
114
|
pulumi.set(self, "account_id", value)
|
|
109
115
|
|
|
110
|
-
@property
|
|
116
|
+
@_builtins.property
|
|
111
117
|
@pulumi.getter(name="locationsPrivates")
|
|
112
|
-
def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
118
|
+
def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
113
119
|
"""
|
|
114
120
|
The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
115
121
|
"""
|
|
116
122
|
return pulumi.get(self, "locations_privates")
|
|
117
123
|
|
|
118
124
|
@locations_privates.setter
|
|
119
|
-
def locations_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
125
|
+
def locations_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
120
126
|
pulumi.set(self, "locations_privates", value)
|
|
121
127
|
|
|
122
|
-
@property
|
|
128
|
+
@_builtins.property
|
|
123
129
|
@pulumi.getter(name="locationsPublics")
|
|
124
|
-
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
130
|
+
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
125
131
|
"""
|
|
126
|
-
The location the monitor will run from.
|
|
132
|
+
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.
|
|
127
133
|
"""
|
|
128
134
|
return pulumi.get(self, "locations_publics")
|
|
129
135
|
|
|
130
136
|
@locations_publics.setter
|
|
131
|
-
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
137
|
+
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
132
138
|
pulumi.set(self, "locations_publics", value)
|
|
133
139
|
|
|
134
|
-
@property
|
|
140
|
+
@_builtins.property
|
|
135
141
|
@pulumi.getter
|
|
136
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
142
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
137
143
|
"""
|
|
138
144
|
The name for the monitor.
|
|
139
145
|
"""
|
|
140
146
|
return pulumi.get(self, "name")
|
|
141
147
|
|
|
142
148
|
@name.setter
|
|
143
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
149
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
144
150
|
pulumi.set(self, "name", value)
|
|
145
151
|
|
|
146
|
-
@property
|
|
152
|
+
@_builtins.property
|
|
147
153
|
@pulumi.getter(name="runtimeType")
|
|
148
|
-
def runtime_type(self) -> Optional[pulumi.Input[str]]:
|
|
154
|
+
def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
149
155
|
"""
|
|
150
|
-
The runtime that the monitor will use to run jobs.
|
|
156
|
+
The runtime that the monitor will use to run jobs (`NODE_API`).
|
|
151
157
|
"""
|
|
152
158
|
return pulumi.get(self, "runtime_type")
|
|
153
159
|
|
|
154
160
|
@runtime_type.setter
|
|
155
|
-
def runtime_type(self, value: Optional[pulumi.Input[str]]):
|
|
161
|
+
def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
156
162
|
pulumi.set(self, "runtime_type", value)
|
|
157
163
|
|
|
158
|
-
@property
|
|
164
|
+
@_builtins.property
|
|
159
165
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
160
|
-
def runtime_type_version(self) -> Optional[pulumi.Input[str]]:
|
|
166
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
161
167
|
"""
|
|
162
|
-
The specific version of the runtime type
|
|
163
|
-
|
|
164
|
-
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `NODE_API` and `16.10` 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.
|
|
168
|
+
The specific semver version of the runtime type.
|
|
165
169
|
"""
|
|
166
170
|
return pulumi.get(self, "runtime_type_version")
|
|
167
171
|
|
|
168
172
|
@runtime_type_version.setter
|
|
169
|
-
def runtime_type_version(self, value: Optional[pulumi.Input[str]]):
|
|
173
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
170
174
|
pulumi.set(self, "runtime_type_version", value)
|
|
171
175
|
|
|
172
|
-
@property
|
|
176
|
+
@_builtins.property
|
|
173
177
|
@pulumi.getter
|
|
174
178
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BrokenLinksMonitorTagArgs']]]]:
|
|
175
179
|
"""
|
|
@@ -181,38 +185,48 @@ class BrokenLinksMonitorArgs:
|
|
|
181
185
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['BrokenLinksMonitorTagArgs']]]]):
|
|
182
186
|
pulumi.set(self, "tags", value)
|
|
183
187
|
|
|
188
|
+
@_builtins.property
|
|
189
|
+
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
190
|
+
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
191
|
+
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
192
|
+
|
|
193
|
+
@use_unsupported_legacy_runtime.setter
|
|
194
|
+
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
195
|
+
pulumi.set(self, "use_unsupported_legacy_runtime", value)
|
|
196
|
+
|
|
184
197
|
|
|
185
198
|
@pulumi.input_type
|
|
186
199
|
class _BrokenLinksMonitorState:
|
|
187
200
|
def __init__(__self__, *,
|
|
188
|
-
account_id: Optional[pulumi.Input[
|
|
189
|
-
guid: Optional[pulumi.Input[str]] = None,
|
|
190
|
-
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
191
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
201
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
202
|
+
guid: Optional[pulumi.Input[_builtins.str]] = None,
|
|
203
|
+
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
204
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
205
|
+
monitor_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
206
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
207
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
208
|
+
period_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
209
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
210
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
211
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
198
212
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['BrokenLinksMonitorTagArgs']]]] = None,
|
|
199
|
-
uri: Optional[pulumi.Input[str]] = None
|
|
213
|
+
uri: Optional[pulumi.Input[_builtins.str]] = None,
|
|
214
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
200
215
|
"""
|
|
201
216
|
Input properties used for looking up and filtering BrokenLinksMonitor resources.
|
|
202
|
-
:param pulumi.Input[
|
|
203
|
-
:param pulumi.Input[str] guid: The unique entity identifier of the monitor in New Relic.
|
|
204
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
205
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_publics: The location the monitor will run from.
|
|
206
|
-
:param pulumi.Input[str]
|
|
207
|
-
:param pulumi.Input[str]
|
|
208
|
-
:param pulumi.Input[
|
|
209
|
-
:param pulumi.Input[
|
|
210
|
-
:param pulumi.Input[str]
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
:param pulumi.Input[str] status: The monitor status (ENABLED or DISABLED).
|
|
217
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
218
|
+
:param pulumi.Input[_builtins.str] guid: The unique entity identifier of the monitor in New Relic.
|
|
219
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
220
|
+
: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.
|
|
221
|
+
:param pulumi.Input[_builtins.str] monitor_id: The monitor id of the synthetics broken links monitor, not to be confused with the GUID of the monitor.
|
|
222
|
+
:param pulumi.Input[_builtins.str] name: The name for the monitor.
|
|
223
|
+
: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`.
|
|
224
|
+
:param pulumi.Input[_builtins.int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
|
|
225
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`NODE_API`).
|
|
226
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific semver version of the runtime type.
|
|
227
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
214
228
|
:param pulumi.Input[Sequence[pulumi.Input['BrokenLinksMonitorTagArgs']]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details
|
|
215
|
-
:param pulumi.Input[str] uri: The URI the monitor runs against.
|
|
229
|
+
:param pulumi.Input[_builtins.str] uri: The URI the monitor runs against.
|
|
216
230
|
"""
|
|
217
231
|
if account_id is not None:
|
|
218
232
|
pulumi.set(__self__, "account_id", account_id)
|
|
@@ -222,6 +236,8 @@ class _BrokenLinksMonitorState:
|
|
|
222
236
|
pulumi.set(__self__, "locations_privates", locations_privates)
|
|
223
237
|
if locations_publics is not None:
|
|
224
238
|
pulumi.set(__self__, "locations_publics", locations_publics)
|
|
239
|
+
if monitor_id is not None:
|
|
240
|
+
pulumi.set(__self__, "monitor_id", monitor_id)
|
|
225
241
|
if name is not None:
|
|
226
242
|
pulumi.set(__self__, "name", name)
|
|
227
243
|
if period is not None:
|
|
@@ -238,130 +254,142 @@ class _BrokenLinksMonitorState:
|
|
|
238
254
|
pulumi.set(__self__, "tags", tags)
|
|
239
255
|
if uri is not None:
|
|
240
256
|
pulumi.set(__self__, "uri", uri)
|
|
257
|
+
if use_unsupported_legacy_runtime is not None:
|
|
258
|
+
pulumi.set(__self__, "use_unsupported_legacy_runtime", use_unsupported_legacy_runtime)
|
|
241
259
|
|
|
242
|
-
@property
|
|
260
|
+
@_builtins.property
|
|
243
261
|
@pulumi.getter(name="accountId")
|
|
244
|
-
def account_id(self) -> Optional[pulumi.Input[
|
|
262
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
245
263
|
"""
|
|
246
264
|
The account in which the Synthetics monitor will be created.
|
|
247
265
|
"""
|
|
248
266
|
return pulumi.get(self, "account_id")
|
|
249
267
|
|
|
250
268
|
@account_id.setter
|
|
251
|
-
def account_id(self, value: Optional[pulumi.Input[
|
|
269
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
252
270
|
pulumi.set(self, "account_id", value)
|
|
253
271
|
|
|
254
|
-
@property
|
|
272
|
+
@_builtins.property
|
|
255
273
|
@pulumi.getter
|
|
256
|
-
def guid(self) -> Optional[pulumi.Input[str]]:
|
|
274
|
+
def guid(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
257
275
|
"""
|
|
258
276
|
The unique entity identifier of the monitor in New Relic.
|
|
259
277
|
"""
|
|
260
278
|
return pulumi.get(self, "guid")
|
|
261
279
|
|
|
262
280
|
@guid.setter
|
|
263
|
-
def guid(self, value: Optional[pulumi.Input[str]]):
|
|
281
|
+
def guid(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
264
282
|
pulumi.set(self, "guid", value)
|
|
265
283
|
|
|
266
|
-
@property
|
|
284
|
+
@_builtins.property
|
|
267
285
|
@pulumi.getter(name="locationsPrivates")
|
|
268
|
-
def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
286
|
+
def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
269
287
|
"""
|
|
270
288
|
The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
271
289
|
"""
|
|
272
290
|
return pulumi.get(self, "locations_privates")
|
|
273
291
|
|
|
274
292
|
@locations_privates.setter
|
|
275
|
-
def locations_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
293
|
+
def locations_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
276
294
|
pulumi.set(self, "locations_privates", value)
|
|
277
295
|
|
|
278
|
-
@property
|
|
296
|
+
@_builtins.property
|
|
279
297
|
@pulumi.getter(name="locationsPublics")
|
|
280
|
-
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
298
|
+
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
281
299
|
"""
|
|
282
|
-
The location the monitor will run from.
|
|
300
|
+
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.
|
|
283
301
|
"""
|
|
284
302
|
return pulumi.get(self, "locations_publics")
|
|
285
303
|
|
|
286
304
|
@locations_publics.setter
|
|
287
|
-
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
305
|
+
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
288
306
|
pulumi.set(self, "locations_publics", value)
|
|
289
307
|
|
|
290
|
-
@property
|
|
308
|
+
@_builtins.property
|
|
309
|
+
@pulumi.getter(name="monitorId")
|
|
310
|
+
def monitor_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
311
|
+
"""
|
|
312
|
+
The monitor id of the synthetics broken links monitor, not to be confused with the GUID of the monitor.
|
|
313
|
+
"""
|
|
314
|
+
return pulumi.get(self, "monitor_id")
|
|
315
|
+
|
|
316
|
+
@monitor_id.setter
|
|
317
|
+
def monitor_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
318
|
+
pulumi.set(self, "monitor_id", value)
|
|
319
|
+
|
|
320
|
+
@_builtins.property
|
|
291
321
|
@pulumi.getter
|
|
292
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
322
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
293
323
|
"""
|
|
294
324
|
The name for the monitor.
|
|
295
325
|
"""
|
|
296
326
|
return pulumi.get(self, "name")
|
|
297
327
|
|
|
298
328
|
@name.setter
|
|
299
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
329
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
300
330
|
pulumi.set(self, "name", value)
|
|
301
331
|
|
|
302
|
-
@property
|
|
332
|
+
@_builtins.property
|
|
303
333
|
@pulumi.getter
|
|
304
|
-
def period(self) -> Optional[pulumi.Input[str]]:
|
|
334
|
+
def period(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
305
335
|
"""
|
|
306
|
-
The interval at which this monitor should run. Valid values are EVERY_MINUTE
|
|
336
|
+
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`.
|
|
307
337
|
"""
|
|
308
338
|
return pulumi.get(self, "period")
|
|
309
339
|
|
|
310
340
|
@period.setter
|
|
311
|
-
def period(self, value: Optional[pulumi.Input[str]]):
|
|
341
|
+
def period(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
312
342
|
pulumi.set(self, "period", value)
|
|
313
343
|
|
|
314
|
-
@property
|
|
344
|
+
@_builtins.property
|
|
315
345
|
@pulumi.getter(name="periodInMinutes")
|
|
316
|
-
def period_in_minutes(self) -> Optional[pulumi.Input[int]]:
|
|
346
|
+
def period_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
317
347
|
"""
|
|
318
348
|
The interval in minutes at which Synthetic monitor should run.
|
|
319
349
|
"""
|
|
320
350
|
return pulumi.get(self, "period_in_minutes")
|
|
321
351
|
|
|
322
352
|
@period_in_minutes.setter
|
|
323
|
-
def period_in_minutes(self, value: Optional[pulumi.Input[int]]):
|
|
353
|
+
def period_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
324
354
|
pulumi.set(self, "period_in_minutes", value)
|
|
325
355
|
|
|
326
|
-
@property
|
|
356
|
+
@_builtins.property
|
|
327
357
|
@pulumi.getter(name="runtimeType")
|
|
328
|
-
def runtime_type(self) -> Optional[pulumi.Input[str]]:
|
|
358
|
+
def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
329
359
|
"""
|
|
330
|
-
The runtime that the monitor will use to run jobs.
|
|
360
|
+
The runtime that the monitor will use to run jobs (`NODE_API`).
|
|
331
361
|
"""
|
|
332
362
|
return pulumi.get(self, "runtime_type")
|
|
333
363
|
|
|
334
364
|
@runtime_type.setter
|
|
335
|
-
def runtime_type(self, value: Optional[pulumi.Input[str]]):
|
|
365
|
+
def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
336
366
|
pulumi.set(self, "runtime_type", value)
|
|
337
367
|
|
|
338
|
-
@property
|
|
368
|
+
@_builtins.property
|
|
339
369
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
340
|
-
def runtime_type_version(self) -> Optional[pulumi.Input[str]]:
|
|
370
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
341
371
|
"""
|
|
342
|
-
The specific version of the runtime type
|
|
343
|
-
|
|
344
|
-
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `NODE_API` and `16.10` 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.
|
|
372
|
+
The specific semver version of the runtime type.
|
|
345
373
|
"""
|
|
346
374
|
return pulumi.get(self, "runtime_type_version")
|
|
347
375
|
|
|
348
376
|
@runtime_type_version.setter
|
|
349
|
-
def runtime_type_version(self, value: Optional[pulumi.Input[str]]):
|
|
377
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
350
378
|
pulumi.set(self, "runtime_type_version", value)
|
|
351
379
|
|
|
352
|
-
@property
|
|
380
|
+
@_builtins.property
|
|
353
381
|
@pulumi.getter
|
|
354
|
-
def status(self) -> Optional[pulumi.Input[str]]:
|
|
382
|
+
def status(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
355
383
|
"""
|
|
356
|
-
The monitor
|
|
384
|
+
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
357
385
|
"""
|
|
358
386
|
return pulumi.get(self, "status")
|
|
359
387
|
|
|
360
388
|
@status.setter
|
|
361
|
-
def status(self, value: Optional[pulumi.Input[str]]):
|
|
389
|
+
def status(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
362
390
|
pulumi.set(self, "status", value)
|
|
363
391
|
|
|
364
|
-
@property
|
|
392
|
+
@_builtins.property
|
|
365
393
|
@pulumi.getter
|
|
366
394
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BrokenLinksMonitorTagArgs']]]]:
|
|
367
395
|
"""
|
|
@@ -373,58 +401,66 @@ class _BrokenLinksMonitorState:
|
|
|
373
401
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['BrokenLinksMonitorTagArgs']]]]):
|
|
374
402
|
pulumi.set(self, "tags", value)
|
|
375
403
|
|
|
376
|
-
@property
|
|
404
|
+
@_builtins.property
|
|
377
405
|
@pulumi.getter
|
|
378
|
-
def uri(self) -> Optional[pulumi.Input[str]]:
|
|
406
|
+
def uri(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
379
407
|
"""
|
|
380
408
|
The URI the monitor runs against.
|
|
381
409
|
"""
|
|
382
410
|
return pulumi.get(self, "uri")
|
|
383
411
|
|
|
384
412
|
@uri.setter
|
|
385
|
-
def uri(self, value: Optional[pulumi.Input[str]]):
|
|
413
|
+
def uri(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
386
414
|
pulumi.set(self, "uri", value)
|
|
387
415
|
|
|
416
|
+
@_builtins.property
|
|
417
|
+
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
418
|
+
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
419
|
+
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
388
420
|
|
|
421
|
+
@use_unsupported_legacy_runtime.setter
|
|
422
|
+
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
423
|
+
pulumi.set(self, "use_unsupported_legacy_runtime", value)
|
|
424
|
+
|
|
425
|
+
|
|
426
|
+
@pulumi.type_token("newrelic:synthetics/brokenLinksMonitor:BrokenLinksMonitor")
|
|
389
427
|
class BrokenLinksMonitor(pulumi.CustomResource):
|
|
390
428
|
@overload
|
|
391
429
|
def __init__(__self__,
|
|
392
430
|
resource_name: str,
|
|
393
431
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
394
|
-
account_id: Optional[pulumi.Input[
|
|
395
|
-
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
396
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
397
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
398
|
-
period: Optional[pulumi.Input[str]] = None,
|
|
399
|
-
runtime_type: Optional[pulumi.Input[str]] = None,
|
|
400
|
-
runtime_type_version: Optional[pulumi.Input[str]] = None,
|
|
401
|
-
status: Optional[pulumi.Input[str]] = None,
|
|
402
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
403
|
-
uri: Optional[pulumi.Input[str]] = None,
|
|
432
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
433
|
+
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
434
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
435
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
436
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
437
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
438
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
439
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
440
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['BrokenLinksMonitorTagArgs', 'BrokenLinksMonitorTagArgsDict']]]]] = None,
|
|
441
|
+
uri: Optional[pulumi.Input[_builtins.str]] = None,
|
|
442
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
404
443
|
__props__=None):
|
|
405
444
|
"""
|
|
406
|
-
Use this resource to create, update, and delete a Synthetics Broken Links monitor in New Relic.
|
|
407
|
-
|
|
408
445
|
## Example Usage
|
|
409
446
|
|
|
410
|
-
<!--Start PulumiCodeChooser -->
|
|
411
447
|
```python
|
|
412
448
|
import pulumi
|
|
413
449
|
import pulumi_newrelic as newrelic
|
|
414
450
|
|
|
415
451
|
foo = newrelic.synthetics.BrokenLinksMonitor("foo",
|
|
452
|
+
name="Sample Broken Links Monitor",
|
|
453
|
+
uri="https://www.one.example.com",
|
|
416
454
|
locations_publics=["AP_SOUTH_1"],
|
|
417
455
|
period="EVERY_6_HOURS",
|
|
456
|
+
status="ENABLED",
|
|
418
457
|
runtime_type="NODE_API",
|
|
419
458
|
runtime_type_version="16.10",
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
|
|
424
|
-
)],
|
|
425
|
-
uri="https://www.one.example.com")
|
|
459
|
+
tags=[{
|
|
460
|
+
"key": "some_key",
|
|
461
|
+
"values": ["some_value"],
|
|
462
|
+
}])
|
|
426
463
|
```
|
|
427
|
-
<!--End PulumiCodeChooser -->
|
|
428
464
|
See additional examples.
|
|
429
465
|
|
|
430
466
|
## Additional Examples
|
|
@@ -435,25 +471,25 @@ class BrokenLinksMonitor(pulumi.CustomResource):
|
|
|
435
471
|
|
|
436
472
|
> **NOTE:** It can take up to 10 minutes for a private location to become available.
|
|
437
473
|
|
|
438
|
-
<!--Start PulumiCodeChooser -->
|
|
439
474
|
```python
|
|
440
475
|
import pulumi
|
|
441
476
|
import pulumi_newrelic as newrelic
|
|
442
477
|
|
|
443
|
-
|
|
478
|
+
foo = newrelic.synthetics.PrivateLocation("foo",
|
|
479
|
+
name="Sample Private Location",
|
|
444
480
|
description="Sample Private Location Description",
|
|
445
481
|
verified_script_execution=False)
|
|
446
|
-
foo_broken_links_monitor = newrelic.synthetics.BrokenLinksMonitor("
|
|
482
|
+
foo_broken_links_monitor = newrelic.synthetics.BrokenLinksMonitor("foo",
|
|
483
|
+
name="Sample Broken Links Monitor",
|
|
447
484
|
uri="https://www.one.example.com",
|
|
448
|
-
locations_privates=[
|
|
485
|
+
locations_privates=[foo.id],
|
|
449
486
|
period="EVERY_6_HOURS",
|
|
450
487
|
status="ENABLED",
|
|
451
|
-
tags=[
|
|
452
|
-
key
|
|
453
|
-
values
|
|
454
|
-
|
|
488
|
+
tags=[{
|
|
489
|
+
"key": "some_key",
|
|
490
|
+
"values": ["some_value"],
|
|
491
|
+
}])
|
|
455
492
|
```
|
|
456
|
-
<!--End PulumiCodeChooser -->
|
|
457
493
|
|
|
458
494
|
## Import
|
|
459
495
|
|
|
@@ -467,18 +503,16 @@ class BrokenLinksMonitor(pulumi.CustomResource):
|
|
|
467
503
|
|
|
468
504
|
:param str resource_name: The name of the resource.
|
|
469
505
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
470
|
-
:param pulumi.Input[
|
|
471
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
472
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_publics: The location the monitor will run from.
|
|
473
|
-
:param pulumi.Input[str] name: The name for the monitor.
|
|
474
|
-
:param pulumi.Input[str] period: The interval at which this monitor should run. Valid values are EVERY_MINUTE
|
|
475
|
-
:param pulumi.Input[str] runtime_type: The runtime that the monitor will use to run jobs.
|
|
476
|
-
:param pulumi.Input[str] runtime_type_version: The specific version of the runtime type
|
|
477
|
-
|
|
478
|
-
|
|
479
|
-
:param pulumi.Input[str]
|
|
480
|
-
:param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['BrokenLinksMonitorTagArgs']]]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details
|
|
481
|
-
:param pulumi.Input[str] uri: The URI the monitor runs against.
|
|
506
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
507
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
508
|
+
: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.
|
|
509
|
+
:param pulumi.Input[_builtins.str] name: The name for the monitor.
|
|
510
|
+
: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`.
|
|
511
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`NODE_API`).
|
|
512
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific semver version of the runtime type.
|
|
513
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
514
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['BrokenLinksMonitorTagArgs', 'BrokenLinksMonitorTagArgsDict']]]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details
|
|
515
|
+
:param pulumi.Input[_builtins.str] uri: The URI the monitor runs against.
|
|
482
516
|
"""
|
|
483
517
|
...
|
|
484
518
|
@overload
|
|
@@ -487,28 +521,25 @@ class BrokenLinksMonitor(pulumi.CustomResource):
|
|
|
487
521
|
args: BrokenLinksMonitorArgs,
|
|
488
522
|
opts: Optional[pulumi.ResourceOptions] = None):
|
|
489
523
|
"""
|
|
490
|
-
Use this resource to create, update, and delete a Synthetics Broken Links monitor in New Relic.
|
|
491
|
-
|
|
492
524
|
## Example Usage
|
|
493
525
|
|
|
494
|
-
<!--Start PulumiCodeChooser -->
|
|
495
526
|
```python
|
|
496
527
|
import pulumi
|
|
497
528
|
import pulumi_newrelic as newrelic
|
|
498
529
|
|
|
499
530
|
foo = newrelic.synthetics.BrokenLinksMonitor("foo",
|
|
531
|
+
name="Sample Broken Links Monitor",
|
|
532
|
+
uri="https://www.one.example.com",
|
|
500
533
|
locations_publics=["AP_SOUTH_1"],
|
|
501
534
|
period="EVERY_6_HOURS",
|
|
535
|
+
status="ENABLED",
|
|
502
536
|
runtime_type="NODE_API",
|
|
503
537
|
runtime_type_version="16.10",
|
|
504
|
-
|
|
505
|
-
|
|
506
|
-
|
|
507
|
-
|
|
508
|
-
)],
|
|
509
|
-
uri="https://www.one.example.com")
|
|
538
|
+
tags=[{
|
|
539
|
+
"key": "some_key",
|
|
540
|
+
"values": ["some_value"],
|
|
541
|
+
}])
|
|
510
542
|
```
|
|
511
|
-
<!--End PulumiCodeChooser -->
|
|
512
543
|
See additional examples.
|
|
513
544
|
|
|
514
545
|
## Additional Examples
|
|
@@ -519,25 +550,25 @@ class BrokenLinksMonitor(pulumi.CustomResource):
|
|
|
519
550
|
|
|
520
551
|
> **NOTE:** It can take up to 10 minutes for a private location to become available.
|
|
521
552
|
|
|
522
|
-
<!--Start PulumiCodeChooser -->
|
|
523
553
|
```python
|
|
524
554
|
import pulumi
|
|
525
555
|
import pulumi_newrelic as newrelic
|
|
526
556
|
|
|
527
|
-
|
|
557
|
+
foo = newrelic.synthetics.PrivateLocation("foo",
|
|
558
|
+
name="Sample Private Location",
|
|
528
559
|
description="Sample Private Location Description",
|
|
529
560
|
verified_script_execution=False)
|
|
530
|
-
foo_broken_links_monitor = newrelic.synthetics.BrokenLinksMonitor("
|
|
561
|
+
foo_broken_links_monitor = newrelic.synthetics.BrokenLinksMonitor("foo",
|
|
562
|
+
name="Sample Broken Links Monitor",
|
|
531
563
|
uri="https://www.one.example.com",
|
|
532
|
-
locations_privates=[
|
|
564
|
+
locations_privates=[foo.id],
|
|
533
565
|
period="EVERY_6_HOURS",
|
|
534
566
|
status="ENABLED",
|
|
535
|
-
tags=[
|
|
536
|
-
key
|
|
537
|
-
values
|
|
538
|
-
|
|
567
|
+
tags=[{
|
|
568
|
+
"key": "some_key",
|
|
569
|
+
"values": ["some_value"],
|
|
570
|
+
}])
|
|
539
571
|
```
|
|
540
|
-
<!--End PulumiCodeChooser -->
|
|
541
572
|
|
|
542
573
|
## Import
|
|
543
574
|
|
|
@@ -564,16 +595,17 @@ class BrokenLinksMonitor(pulumi.CustomResource):
|
|
|
564
595
|
def _internal_init(__self__,
|
|
565
596
|
resource_name: str,
|
|
566
597
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
567
|
-
account_id: Optional[pulumi.Input[
|
|
568
|
-
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
569
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
570
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
571
|
-
period: Optional[pulumi.Input[str]] = None,
|
|
572
|
-
runtime_type: Optional[pulumi.Input[str]] = None,
|
|
573
|
-
runtime_type_version: Optional[pulumi.Input[str]] = None,
|
|
574
|
-
status: Optional[pulumi.Input[str]] = None,
|
|
575
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
576
|
-
uri: Optional[pulumi.Input[str]] = None,
|
|
598
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
599
|
+
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
600
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
601
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
602
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
603
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
604
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
605
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
606
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['BrokenLinksMonitorTagArgs', 'BrokenLinksMonitorTagArgsDict']]]]] = None,
|
|
607
|
+
uri: Optional[pulumi.Input[_builtins.str]] = None,
|
|
608
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
577
609
|
__props__=None):
|
|
578
610
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
579
611
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -599,7 +631,9 @@ class BrokenLinksMonitor(pulumi.CustomResource):
|
|
|
599
631
|
if uri is None and not opts.urn:
|
|
600
632
|
raise TypeError("Missing required property 'uri'")
|
|
601
633
|
__props__.__dict__["uri"] = uri
|
|
634
|
+
__props__.__dict__["use_unsupported_legacy_runtime"] = use_unsupported_legacy_runtime
|
|
602
635
|
__props__.__dict__["guid"] = None
|
|
636
|
+
__props__.__dict__["monitor_id"] = None
|
|
603
637
|
__props__.__dict__["period_in_minutes"] = None
|
|
604
638
|
super(BrokenLinksMonitor, __self__).__init__(
|
|
605
639
|
'newrelic:synthetics/brokenLinksMonitor:BrokenLinksMonitor',
|
|
@@ -611,18 +645,20 @@ class BrokenLinksMonitor(pulumi.CustomResource):
|
|
|
611
645
|
def get(resource_name: str,
|
|
612
646
|
id: pulumi.Input[str],
|
|
613
647
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
614
|
-
account_id: Optional[pulumi.Input[
|
|
615
|
-
guid: Optional[pulumi.Input[str]] = None,
|
|
616
|
-
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
617
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
618
|
-
|
|
619
|
-
|
|
620
|
-
|
|
621
|
-
|
|
622
|
-
|
|
623
|
-
|
|
624
|
-
|
|
625
|
-
|
|
648
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
649
|
+
guid: Optional[pulumi.Input[_builtins.str]] = None,
|
|
650
|
+
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
651
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
652
|
+
monitor_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
653
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
654
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
655
|
+
period_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
656
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
657
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
658
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
659
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['BrokenLinksMonitorTagArgs', 'BrokenLinksMonitorTagArgsDict']]]]] = None,
|
|
660
|
+
uri: Optional[pulumi.Input[_builtins.str]] = None,
|
|
661
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None) -> 'BrokenLinksMonitor':
|
|
626
662
|
"""
|
|
627
663
|
Get an existing BrokenLinksMonitor resource's state with the given name, id, and optional extra
|
|
628
664
|
properties used to qualify the lookup.
|
|
@@ -630,20 +666,19 @@ class BrokenLinksMonitor(pulumi.CustomResource):
|
|
|
630
666
|
:param str resource_name: The unique name of the resulting resource.
|
|
631
667
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
632
668
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
633
|
-
:param pulumi.Input[
|
|
634
|
-
:param pulumi.Input[str] guid: The unique entity identifier of the monitor in New Relic.
|
|
635
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
636
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_publics: The location the monitor will run from.
|
|
637
|
-
:param pulumi.Input[str]
|
|
638
|
-
:param pulumi.Input[str]
|
|
639
|
-
:param pulumi.Input[
|
|
640
|
-
:param pulumi.Input[
|
|
641
|
-
:param pulumi.Input[str]
|
|
642
|
-
|
|
643
|
-
|
|
644
|
-
:param pulumi.Input[
|
|
645
|
-
:param pulumi.Input[
|
|
646
|
-
:param pulumi.Input[str] uri: The URI the monitor runs against.
|
|
669
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
670
|
+
:param pulumi.Input[_builtins.str] guid: The unique entity identifier of the monitor in New Relic.
|
|
671
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
672
|
+
: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.
|
|
673
|
+
:param pulumi.Input[_builtins.str] monitor_id: The monitor id of the synthetics broken links monitor, not to be confused with the GUID of the monitor.
|
|
674
|
+
:param pulumi.Input[_builtins.str] name: The name for the monitor.
|
|
675
|
+
: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`.
|
|
676
|
+
:param pulumi.Input[_builtins.int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
|
|
677
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`NODE_API`).
|
|
678
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific semver version of the runtime type.
|
|
679
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
680
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['BrokenLinksMonitorTagArgs', 'BrokenLinksMonitorTagArgsDict']]]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details
|
|
681
|
+
:param pulumi.Input[_builtins.str] uri: The URI the monitor runs against.
|
|
647
682
|
"""
|
|
648
683
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
649
684
|
|
|
@@ -653,6 +688,7 @@ class BrokenLinksMonitor(pulumi.CustomResource):
|
|
|
653
688
|
__props__.__dict__["guid"] = guid
|
|
654
689
|
__props__.__dict__["locations_privates"] = locations_privates
|
|
655
690
|
__props__.__dict__["locations_publics"] = locations_publics
|
|
691
|
+
__props__.__dict__["monitor_id"] = monitor_id
|
|
656
692
|
__props__.__dict__["name"] = name
|
|
657
693
|
__props__.__dict__["period"] = period
|
|
658
694
|
__props__.__dict__["period_in_minutes"] = period_in_minutes
|
|
@@ -661,91 +697,98 @@ class BrokenLinksMonitor(pulumi.CustomResource):
|
|
|
661
697
|
__props__.__dict__["status"] = status
|
|
662
698
|
__props__.__dict__["tags"] = tags
|
|
663
699
|
__props__.__dict__["uri"] = uri
|
|
700
|
+
__props__.__dict__["use_unsupported_legacy_runtime"] = use_unsupported_legacy_runtime
|
|
664
701
|
return BrokenLinksMonitor(resource_name, opts=opts, __props__=__props__)
|
|
665
702
|
|
|
666
|
-
@property
|
|
703
|
+
@_builtins.property
|
|
667
704
|
@pulumi.getter(name="accountId")
|
|
668
|
-
def account_id(self) -> pulumi.Output[
|
|
705
|
+
def account_id(self) -> pulumi.Output[_builtins.str]:
|
|
669
706
|
"""
|
|
670
707
|
The account in which the Synthetics monitor will be created.
|
|
671
708
|
"""
|
|
672
709
|
return pulumi.get(self, "account_id")
|
|
673
710
|
|
|
674
|
-
@property
|
|
711
|
+
@_builtins.property
|
|
675
712
|
@pulumi.getter
|
|
676
|
-
def guid(self) -> pulumi.Output[str]:
|
|
713
|
+
def guid(self) -> pulumi.Output[_builtins.str]:
|
|
677
714
|
"""
|
|
678
715
|
The unique entity identifier of the monitor in New Relic.
|
|
679
716
|
"""
|
|
680
717
|
return pulumi.get(self, "guid")
|
|
681
718
|
|
|
682
|
-
@property
|
|
719
|
+
@_builtins.property
|
|
683
720
|
@pulumi.getter(name="locationsPrivates")
|
|
684
|
-
def locations_privates(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
721
|
+
def locations_privates(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
685
722
|
"""
|
|
686
723
|
The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
687
724
|
"""
|
|
688
725
|
return pulumi.get(self, "locations_privates")
|
|
689
726
|
|
|
690
|
-
@property
|
|
727
|
+
@_builtins.property
|
|
691
728
|
@pulumi.getter(name="locationsPublics")
|
|
692
|
-
def locations_publics(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
729
|
+
def locations_publics(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
693
730
|
"""
|
|
694
|
-
The location the monitor will run from.
|
|
731
|
+
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.
|
|
695
732
|
"""
|
|
696
733
|
return pulumi.get(self, "locations_publics")
|
|
697
734
|
|
|
698
|
-
@property
|
|
735
|
+
@_builtins.property
|
|
736
|
+
@pulumi.getter(name="monitorId")
|
|
737
|
+
def monitor_id(self) -> pulumi.Output[_builtins.str]:
|
|
738
|
+
"""
|
|
739
|
+
The monitor id of the synthetics broken links monitor, not to be confused with the GUID of the monitor.
|
|
740
|
+
"""
|
|
741
|
+
return pulumi.get(self, "monitor_id")
|
|
742
|
+
|
|
743
|
+
@_builtins.property
|
|
699
744
|
@pulumi.getter
|
|
700
|
-
def name(self) -> pulumi.Output[str]:
|
|
745
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
701
746
|
"""
|
|
702
747
|
The name for the monitor.
|
|
703
748
|
"""
|
|
704
749
|
return pulumi.get(self, "name")
|
|
705
750
|
|
|
706
|
-
@property
|
|
751
|
+
@_builtins.property
|
|
707
752
|
@pulumi.getter
|
|
708
|
-
def period(self) -> pulumi.Output[str]:
|
|
753
|
+
def period(self) -> pulumi.Output[_builtins.str]:
|
|
709
754
|
"""
|
|
710
|
-
The interval at which this monitor should run. Valid values are EVERY_MINUTE
|
|
755
|
+
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`.
|
|
711
756
|
"""
|
|
712
757
|
return pulumi.get(self, "period")
|
|
713
758
|
|
|
714
|
-
@property
|
|
759
|
+
@_builtins.property
|
|
715
760
|
@pulumi.getter(name="periodInMinutes")
|
|
716
|
-
def period_in_minutes(self) -> pulumi.Output[int]:
|
|
761
|
+
def period_in_minutes(self) -> pulumi.Output[_builtins.int]:
|
|
717
762
|
"""
|
|
718
763
|
The interval in minutes at which Synthetic monitor should run.
|
|
719
764
|
"""
|
|
720
765
|
return pulumi.get(self, "period_in_minutes")
|
|
721
766
|
|
|
722
|
-
@property
|
|
767
|
+
@_builtins.property
|
|
723
768
|
@pulumi.getter(name="runtimeType")
|
|
724
|
-
def runtime_type(self) -> pulumi.Output[Optional[str]]:
|
|
769
|
+
def runtime_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
725
770
|
"""
|
|
726
|
-
The runtime that the monitor will use to run jobs.
|
|
771
|
+
The runtime that the monitor will use to run jobs (`NODE_API`).
|
|
727
772
|
"""
|
|
728
773
|
return pulumi.get(self, "runtime_type")
|
|
729
774
|
|
|
730
|
-
@property
|
|
775
|
+
@_builtins.property
|
|
731
776
|
@pulumi.getter(name="runtimeTypeVersion")
|
|
732
|
-
def runtime_type_version(self) -> pulumi.Output[Optional[str]]:
|
|
777
|
+
def runtime_type_version(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
733
778
|
"""
|
|
734
|
-
The specific version of the runtime type
|
|
735
|
-
|
|
736
|
-
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `NODE_API` and `16.10` 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.
|
|
779
|
+
The specific semver version of the runtime type.
|
|
737
780
|
"""
|
|
738
781
|
return pulumi.get(self, "runtime_type_version")
|
|
739
782
|
|
|
740
|
-
@property
|
|
783
|
+
@_builtins.property
|
|
741
784
|
@pulumi.getter
|
|
742
|
-
def status(self) -> pulumi.Output[str]:
|
|
785
|
+
def status(self) -> pulumi.Output[_builtins.str]:
|
|
743
786
|
"""
|
|
744
|
-
The monitor
|
|
787
|
+
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
745
788
|
"""
|
|
746
789
|
return pulumi.get(self, "status")
|
|
747
790
|
|
|
748
|
-
@property
|
|
791
|
+
@_builtins.property
|
|
749
792
|
@pulumi.getter
|
|
750
793
|
def tags(self) -> pulumi.Output[Optional[Sequence['outputs.BrokenLinksMonitorTag']]]:
|
|
751
794
|
"""
|
|
@@ -753,11 +796,16 @@ class BrokenLinksMonitor(pulumi.CustomResource):
|
|
|
753
796
|
"""
|
|
754
797
|
return pulumi.get(self, "tags")
|
|
755
798
|
|
|
756
|
-
@property
|
|
799
|
+
@_builtins.property
|
|
757
800
|
@pulumi.getter
|
|
758
|
-
def uri(self) -> pulumi.Output[str]:
|
|
801
|
+
def uri(self) -> pulumi.Output[_builtins.str]:
|
|
759
802
|
"""
|
|
760
803
|
The URI the monitor runs against.
|
|
761
804
|
"""
|
|
762
805
|
return pulumi.get(self, "uri")
|
|
763
806
|
|
|
807
|
+
@_builtins.property
|
|
808
|
+
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
809
|
+
def use_unsupported_legacy_runtime(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
810
|
+
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
811
|
+
|