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